Dotfiles & Managing Complexity

Dotfiles summarize a lot of what I’ve learned recently about managing complexity and seeking reasonable fundamental understanding above all else. I’ve always known to attempt to understand things at a high level and view learning as a process that generally starts from the top down. However, what that meant in real life as an actionable algorithm for the daily, I was a bit more unsure. Like many things I find myself involved in, without careful attention, it converges into a situation of all theory and no implementation. Without a proper understanding of the fundamentals and the high level overview of what you’re building, its easy to to know what you want to do but not know how to make actual meaningful progress. You need to strike the right balance.

I’ve always thought that it would be pretty cool to have a completely decked out terminal setup, with all the fancy shell bells and whistles, text completion and project file indexing in vim, and having memorized all the keybindings – flying through the terminal with hyper-efficiency. However, I never really found the time or need to do something like that. I edited my bashrc every now and then to add a convenient alias to the directories I used to store code for classwork or the like, or to add some new tools to the path, but that was the extent of my terminal tinkering. I still spent a lot of time in the terminal, but preferred to use some other graphical tools to do development instead (e.g. VS Code). There recently came a need at work to spend more time the terminal on a remote machine, so I was unable to use my existing tools. And given the shelter-at-home restrictions, I figured it would be a good time to finally sit down and make my computer my own.

I was quick to jump on GitHub and copy the first and highest rated vimrc’s, but found that I could never tell what was really run in the background, what keybindings were enabled, etc. – thus, it felt more like a hinderance that happened to look nice than anything actually useful. I was looking for a shortcut. In these situations, spending time looking for shortcuts ends up taking longer than actually doing it the right way. Also, as I later came to realize, dotfiles are pretty private to each person. You can’t just use someone elses’s configuration and expect it to work 100% with how you work. You need to make it your own.

So, I took a step back and reverted all my configs to their base form. I used naked vim, tmux, etc. for a while, and configured as I saw fit when the time came for me to do so – often when I found things to be clunky. Of course I still borrowed snippets of some people’s dotfiles, but knowing exactly what I was putting in where, and for what reason, really made things more managable. Tying this back briefly: I always knew what I wanted in theory, and knew what tools to use: a text editor, terminal multiplexer, etc. but in attempts of doing everything at once, I made little progress. Only by explicitly seeking to understand things firstly at a high level but then easing gradually into lower level understanding does it make things more manageable. So I’ve found that a necessary prerequisite to really mastering complexity is to extract simplicity. Walk yourself down to lower and lower levels of understanding gradually, and you’ll get there in no time. It sounds simple, but to put it to practice takes some real discipline, it turns out. And when it comes to dotfiles, you gotta be your own person!