June 9, 2022

I've been a heavy Vim/NeoVim user for more than 10 years. But until recently, I had one foot stuck in JetBrains world. I used to switch between Vim/NeoVim and GoLand/PyCharm/IntelliJ/RubyMine/etc... I couldn't talk myself into completely switching to Vim/NeoVim due to the debugging features in JetBrains IDEs. A few months ago, I finally made the switch, and now I use only NeoVim, and it's amaaazing!!! I feel like I'm so much more productive. The vim-go plugin has been a huge help for go development, and its debugging features using delve helped me to make the switch. The following is a list of six tips for getting around quickly in Vim/NeoVim (things that have helped improve my productivity over the years)



1. Use the NeoSnippet plugin

The NeoSnippet plugin allows you to define small templates for commonly used code, or use pre -defined default snippets available for a number of different programming languages. For example, the pre-defined default snippets include a go.snip file containing several snippets for the golang programming language, including a test function snippet, which looks like this

# test function
snippet test
abbr func TestXYZ(t *testing.T) { ... }
	func Test$ {1:Function}(t *testing.T) {
		$ {0}
	}

2. EasyMotion plugin

The EasyMotion plugin changed my life. I learned very early on how to jump around in vim, to the bottom of a file/buffer (Shift+g), or to the top of a file/buffer (gg), or down 10 lines (10j), etc. But to move to a very specific place in a file, say the middle of a line in the middle of a file/buffer, required jumping down some number of lines or typing a line number + g then hitting several keys to move over to the middle of the line...

Enter EasyMotion. With EasyMotion, I type <leader>w and the buffer becomes filled with highlighted characters. I then type the first highlighted character closest to where I want to jump and then type a second highlighted character.



To move down to the "container" class name in the "section" element, I type co.



Voila, cursor lands right on the text in the middle of the buffer, saving me a few key presses.

3. FZF.vim plugin

FZF is a command-line fuzzy finder. FZF.vim brings fuzzy search to Vim. It is very handy for searching for files within the current project. I wrote the following vim script function in my init.vim (neovim equivalent for .vimrc for vim) and mapped it to <leader>g

nnoremap <leader>g :call FZFProjectRoot()<CR>

" search from the git root if we're in a git repo
function! FZFProjectRoot()
    let project_root = system('git rev-parse --show-toplevel 2> /dev/null')[:-2]
    if strlen(project_root) > 0
        call fzf#run(fzf#wrap('FZFProjectRoot', {'dir': project_root}))
    else
        call fzf#run(fzf#wrap('FZFProjectRoot'))
    endif
endfunction

4. NERDTree

NERDTree is a vim file explorer plugin. It isn't faster, per se, than the standard vim file explorer, but it's so much nicer and easier to use. And it definitely makes you faster in vim. With the NERDTree buffer in focus, you can visualize the file tree, and you can use EasyMotion or term search within the buffer to get around the explorer quicker.



I have NERDTree configured to be off by default when opening a new buffer. And I have a key mapping set up to toggle NERDTree on and off with <leader>n or Ctrl+l+l. And I also have a key mapping for opening NERDTree at the path of the currently open buffer with <leader>f.

nmap <leader>n :NERDTreeToggle<CR>
nmap <C-l>l :NERDTreeToggle<CR>
nmap <leader>f :NERDTreeFind<CR>

5. Tagbar

Tagbar is a plugin that, when toggled, shows a view of the structure and list of tags (class names, function names, constants, variables, and other configured tags) within the current file. And, more importantly, allows you to easily jump between tags within that file.

By default, Tagbar has a dependency on ctags to provide tags integration, and some additional formats can be handled by other providers. Vim-go, for example integrates Tagbar using gotags as the provider.

6. Term search

Lastly, you can search for specific terms in the current buffer by typing "/" (forward slash). So, for example, if I type "/toolbar" and hit enter in my current buffer, it will find all instances of "toolbar" and take me to the first instance. I can now type "n" to move forward to the next instance of the word, or "N" (Shift+n) to go backward to the previous instance.

These six tips can really help increase speed and productivity in vim/neovim. Of course, in order to become comfortable with all of them, one must practice and use them often. After some time, it becomes second nature to use each of them, as everything does with vim/neovim. You'll eventually find yourself flying around at a blistering pace!

September 2, 2021

This is just a simple demonstration on how to use python from within a shell script. Both of the following two python files are imported and functions are accessed from the shell script at the bottom.

new_api_keys_map = {
    "consumer1": "abcd-efgh-ijklmnop",
    "consumer2": "bcda-fghe-jklmnopi",
    "consumer3": "cdab-ghef-klmnopij",
}

def get_new_key_by_name(name):
    return new_api_keys_map.get(name, "")

kafka_consumer_secret_replace_map = {
    "secret1": {2: "secret-value1"},
    "secret2": {2: "secret-value2"},
    "secret3": {2: "secret-value3"},
}

def get_kafka_consumer_secret_replacement(name, num):
    return kafka_consumer_secret_replace_map.get(name, {}).get(num, "")

#!/bin/zsh

  NEW_KEY=$(
  /usr/bin/env python3 - <<EOF
from api_key_maps import get_new_key_by_name
key = get_new_key_by_name("${GROUP}")
print(key)
EOF
)

  REPLACEMENT=$(
    /usr/bin/env python3 - <<EOF
from kafka_secret_maps import get_kafka_consumer_secret_replacement
replacement = get_kafka_consumer_secret_replacement("${GROUP}", ${NUM})
print(replacement)
EOF
)

February 5, 2021

I often take lessons from sports for personal development in business and in my personal life. One thing I recently recognized is that Competitiveness is a drive that must be team-oriented.

For example, if a superstar on a basketball team is ultra competitive, but less interested in team success and more interested in personal accolades and scoring the most points, that team is rarely successful. On the other hand, if that same superstar learns to become more interested in the success of the team, then that team has a much greater chance of having success.

The same goes for teams in business. I've been on teams where certain individuals are more interested in their own personal career growth and their own accolades and show zero interest in the success of the team as a whole. Those teams were almost always much less successful than teams whose individual members all cared about the success of the team as a whole.

I've tried to take that lesson with me to every team I am part of, and try to quickly correct myself whenever I find myself seeking personal attention or accolades ahead of my team. I also try to quickly take ownership for team failures and am quick to recognize my team for team or individual successes.

November 9, 2020

Binary trees are encountered often in programming. It's a very simple and efficient data structure that can be used to solve many problems in software systems.

For example, binary trees are used for decision trees, sorting, database indexing, data compression, blockchains, search, and many other applications in software.

An Inorder traversal over a binary search tree can be used to sort values in an efficient manner with O(N) (linear) time complexity. Here's a code example showing a method that takes a list of decimal numbers and constructs a binary search tree. An Inorder traversal function is then used to traverse over the binary search tree to print the sorted values.

First, we create a Node class, which holds properties left and right (since there will always be up to two children for each node in the tree), and a data property that holds its value.

class Node(object):
    left, right = None, None

    def __init__(self, data=None):
        self.data = data

# Binary search tree insertion
def insert(root, key):

    # if the root is None, create a new node and return it
    if root is None:
        return Node(key)

    # if the given key is less than the value of the root node,
    # recur over the left subtree
    if key < root.data:
        root.left = insert(root.left, key)

    # otherwise, recur for the right subtree
    else:
        # key >= root.data
        root.right = insert(root.right, key)

    return root

def constructBST(keys):
    root = None
    for key in keys:
        root = insert(root, key)

    return root

def inorder(root):
    if root:
        inorder(root.left)
        print(root.data, end=' '),
        inorder(root.right)

keys = [1, 2, 5, 6, 3, 4]

root = constructBST(keys)
inorder(root)

The output we get after running the inorder function on the binary search tree is a sorted list of the raw unsorted input list

1 2 3 4 5 6