Things I Use
Published: 2020-07-28 20:49:19

If you have 3 developers in a room, and you ask them which tools they prefer, you will inevitably get at least 4 different opinions.  One or two of them may vehemently defend one camp or another, while the others might hand-wave while muttering something about "the best tool for the job".  Still another may rise on a pedestal and start preaching about Emacs.

Such is the landscape when it comes to the tools we all as developers use.  Today, you get to hear my voice of opinion regarding the things I have come to rely on for my day-to-day work.  As this will be a rather lengthy post, let's get right into it.

## Goals

When choosing tooling and utilities, my goal is to make development as efficient as possible.  In the past, I had other goals as well, such as building a system that supports music production: this is still important to me, but it is no longer something I spend a lot of time on, due to various reasons.  In the end, then, I want to be able to "boot to development" as fast as possible.

## Operating Systems

At the very moment when a developer sits down at their desk and starts their computer, lines have already been drawn. A side has already been chosen: what is your Operating System of preference?  Speaking in very general terms, you can pretty much loosely divide Operating Systems into two families: UNIX, and Windows.  The UNIX family of Operating Systems can be further divided into commercial variants (e.g., macOS, among others), and non-commercial variants.

In the past, I have done development work on Windows, but nowadays I prefer to develop exclusively on UNIX OSes.  They say that "UNIX is an IDE", and that is definitely true.  I typically have many dependencies on several tools to create an IDE experience on UNIX.  Here are the different flavors I have come to enjoy:

* macOS
* Ubuntu Linux
* Android

When it comes to an all-in-one, polished package, macOS is a very nice UNIX-variant.  I thoroughly enjoy working on macOS, and that is my requested preference when working at a company if they are willing to provide a Mac as a workstation.  However, I am unwilling to purchase Macs for my personal use, as I believe that their hardware is overpriced.  Enter the other distributions that I listed above.  At home, I run Ubuntu Linux on my Desktop (and yes, I do dual-boot Windows so that I can run certain programs).  I have tried Arch in the past, but have come to realize that I prefer Debian-based Linux distros.

When on-the-go, I use Android.  See the "mobile" section for more information on my setup there.

## Terminal

For me, most of my interaction with my computer happens in the Terminal, and therefore I spend some time setting it up in ways that make my time spent there easier.  Lately, my terminal emulator of choice has been [kitty](https://sw.kovidgoyal.net/kitty/index.html).  Kitty has all of the features that I want in a terminal emulator: it is fast, can render ligatures, and is configurable via dotfiles.  The close runner-up to Kitty is Alacritty, which can do all of that, except that, as of the time of this writing, it [cannot render font ligatures (yet)](https://github.com/alacritty/alacritty/issues/50).

I wish I had time to write about each of these projects individually, but in the interest of time, I will leave a list here:

* [KiTTY](https://sw.kovidgoyal.net/kitty/)
* [tmux](https://github.com/tmux/tmux/wiki)
* [Fish](https://fishshell.com/)
* [Dotfiles](https://gitlab.com/jrop/dotfiles) - [YADM](https://yadm.io/#)
* [JetBrains Mono Nerd Font](https://github.com/ryanoasis/nerd-fonts)
* [FZF](https://github.com/junegunn/fzf)
* [jq](https://stedolan.github.io/jq/)
* [lazygit](https://github.com/jesseduffield/lazygit)
* [mkcert](https://github.com/FiloSottile/mkcert)
* [rclone](https://rclone.org/)
* [supervisor](http://supervisord.org/) - when developing a microservice-architecture locally, this tool is truely invaluable
* [watch](https://gitlab.com/procps-ng/procps#tab-readme)

## Text Editors

My text-editing journey has endured many changes, and over the years, I have tried pretty much everything out.  The only editor I haven't fully dived into would be Emacs.  Up until about a year ago, I was an avid fan of VSCode, for it blends the best of many editors.  Having a built-in terminal, there was little not to love.  I kept, however, hearing the tales of the absurd efficiency of VI, but could not relate to it, mostly due to an unguided learning experience with it that over 10 years ago at my university.  I had forced myself to code a C++ project in ViM, and I learned enough to move around and get the project done.  However, what I did not know was that I was only utilizing around 5% of the power of ViM.

This all changed recently when I bought a ViM course during one of Udemy's flash-sales.  I was quickly sold when I realized that I had never used text objects beyond the verb "word" and that I could couple them with visual selection, among many other ViM actions.  Today, I probably still utilize a mere fraction of ViM's power, but I am nonetheless much happier with the efficiency of text-editing in ViM on a day-to-day basis.

I have chosen [NeoVim](https://neovim.io/) as the particular flavor that I prefer to use if not for the simple fact that the devs of NeoVim are attempting to bring ViM into the 21st century.  I consider the following features to be game-changers:

* Built-in LSP client (coming soon)
* Scriptable with Lua - I believe VimL is an extremely archane language that is showing its age.  While NeoVim will always have support for VimL, I believe Lua is the future to scripting ViM.
* ...and many more features!

## macOS-specific utilities

* [Homebrew](https://brew.sh/)
* [Flycut](https://github.com/TermiT/Flycut)
* [Karabiner Elements](https://karabiner-elements.pqrs.org/) - needed by Capslock
* [Capslock](https://github.com/Vonng/Capslock) - Make Capslock Great Again! 
* [Rectangle](https://www.rectangleapp.com/)
* [Espanso](https://espanso.org/)

## Languages

Practically speaking, there are many ways a developer may dictate their intent to the computer being controlled.  Over the years, many different languages have arisen with different paradigms that all accomplish different goals in slightly different manners.  Here is a short list of languages and tools I reach for when solving a new problem.  Although I am capable of using other languages and tools, these are the ones I utilize if the choice is mine:

* Config/Data/Declarative
  * YAML
  * JSON
  * TOML
* Shell
  * Fish
  * Bash
* Scripting
  * JavaScript/TypeScript/NodeJS
* UI - Web technologies + JSX
* Rust

## Miscellaneous Productivity

* [Nebula](https://github.com/slackhq/nebula)
* [NoMachine](https://www.nomachine.com/)

## Mobile

On the go, it is convenient to be able to develop if I am in a pinch.  I do not primarily develop on mobile, but there are tools I use to make it possible if an emergency arises.

* Android
* [Termux](https://termux.com/)
* Gboard
* [Hacker Keyboard (by Kaus Weidner)](https://play.google.com/store/apps/details?id=org.pocketworkstation.pckeyboard)

# Hardware

* PC: 6-core...
* Laptop: MacBook Pro
* Keyboard: 65% Drop Alt (formerly an Anne Pro II)
* Mouse: Logitech MX Master 2S
* Headphones: Panasonic...

# Things I have my eye on

* Arch Linux