A few quite incoherent thoughts on software, interfaces and beauty, or how to think like a superuserIntroductionIn the following guide/tutorial/essay/call-it-how-you-like, I'll be talking a lot about productivity. When I use that word, I normally mean the speed at which you do some kind of work. While this is limited by your choice of text editor/document reader/insert-working-environment-here, other aspects of your environment influence the speed at which you actually think, so minimizing distraction will be a very important topic that, albeit not always explicitly mentioned, is almost always implicated.
But what is this writing for?
To become more productive, or as some call it, to become a superuser, and, more importantly, to understand the principles that are behind productivity in a computing environment. Please note that this is a quite subjective topic, so some of the advice and especially examples I will give, are tailored to my personal preferences. Still, the goal is to make the reader understand the principles behind my setup, to optimize his own.
So, let's get started.
Most of us probably work in some kind of computing environment on a regular basis, but a much smaller percentage actually shape this environment actively, instead of letting the
environment shape their workflow. This task (configuring and tinkering that is) can become a huge timesink and might seem like a huge waste of energy and personal resources to outsiders. But if done right, it can heavily increase your productivity and make your environment not just suitable to the current task at hand, but also versatile and flexible.
Actually, some weird souls actually enjoy configuring their systems, but if you belong to this group, I feel the urge to warn you: Don't make it an excess, otherwise you might end up just wasting your time*.
Still, it is a useful task which follows a few key principles that actually
make it useful. Although I present these principles in terms of my own preferences, experience and opinions, I believe it to be partly universal, and to some extend transferable to other contexts (your setup that is).
Let's talk about beautyFirst of all let's do what the section's title suggests (now don't go all like "Oh no, he's going to shove his opinion down our throats...", because I will. Bear with me). While in itself, beauty is hard to describe, and even harder to actually define, there exist a few key notions of it that are rooted in mathematics (or science in general), and formulas in particular. While working with the mathematical notation of an equation or a problem, it becomes clear that simplicity, clean expressions are much easier to handle, and thus allow a far more beautiful description of a problem, situation, task etc., which is applicable in a far more generalized, less specialized context. This is what so different things, like functional programming, tiling window managers, vim and the theory of special relativity have in common; they either form or allow for simple, concise building blocks that can be (re-)combined to a larger whole, while being very
elegant themselves and this way allowing to express complex things in a natural fashion.
TL;DR simplicity is beautiful. But what does beauty have in common with my computing environment?
Simple. You want to keep things simple and effective, stay focused on your task and
get stuff done. And we already know that simple things are beautiful. Sounds familiar? You're right - the UNIX philosophy goes down that lane. And now, we will apply this humble principle:
How to get simplicity into your workflow - a checklist1. Get rid of your mouse. This one is mentioned a lot. And for a reason. First of all, mousedriven interfaces tend to be badly designed, because screen space for buttons and menus is rare. Secondly, using your mouse requires conscious thinking, whereas a keyboard shortcut finds it's way into muscle memory after regular usage. And you need time to get your hand from the keyboard, find the mouse, and reposition your hand on the keyboard afterwards. But not always this is possible and feasible. Keep a healthy balance where needed, which brings us to the next point.
2. Use software that helps you realize point 1. In case of bad keyboard support, get yourself a replacement that does it better. Simple, yet effective.
3. Use consistent interfaces. If common usage-patterns in different applications follow the same logic, they are easier to learn and use.
4. Keep things visually clean, too. The first three points dealt with removing clutter from interfaces and your workflow, so why not do the same to your screen space? If you never use a GUI menu, it's useless, so hide it or switch your app for a better (cleaner) one (see point 2). Remember: the fewer distractions, the more productivity.
Now how do you actually realize that?Below is a list of tools that help you do what was said above.
1. Choose the right OS. There is this great
guide about that. The logic behind this point is simple: if your OS embraces simplicity, it will be easy to configure, modify and configure.
2. Choose the right WM. Possibly a tiled one. You spend (almost) all your time in it, so choose wisely. *
Wikipedia article on tiled window managers * Examples include awesomeWM, Xmonad, dwm, i3, herbstluftwm, … google's your friend. I personally use awesomeWM, because it is extremely simple, completely keyboard-driven, configurable via Lua and generally awesome.
3. Do stuff in terminals. The CLI is very powerful and configurable, also very keyboard-friendly (duh.) And, for instance the Z Shell (ZSH) is very feature-rich and allows for a great deal of productivity.
4. Choose the right text editor. If you write anything, be it code or prose, chances are that you do it often. So make sure that you do it effectively. Some people swear by vim (I do), others by EMACS, go with what suites you most. Both are very feature-rich, extensible, and widely used. For a reason.
5. Improve your browsing experience. Most people spend very much time in a browser window, and most GUI browsers have slightly imperfect keyboard interfaces. Luckily, there are plugins that introduce vim-like or emacs-like shortcuts, to avoid the mouse and keep your interfaces consistent with each other. I recommend VimFX for Firefox.
This was quite an elaborate thought on beauty, simplicity, and how it applies to computing. Of course, there is no go-to solution for everybody, so this is merely a guide to get you started finding your own. One last note on how I do it:
- Try something new if you're not fully content with what you have already.
- Test it. Look how others do it. Read the docs. Research.
- Apply it.
- Repeat.
This actually applies to many different things.
If someone is interested, I'll include more details about my own config. Screenshots can be found hereSame goes for your own experience. If you want me to include something, mention a topic etc., just comment belowHappy tinkering!
* I know what I talk of, since I've spent literally days configuring software etc. I didn't end up using.
