These days there are some damn cool things out there to build up your Unixoid (development) environment. This is a medium-sized elaboration on the stuff I like.

Spoilers: Including an editor that can be considered better than VIM in some regards and the single most awesome shell there is (no, not ZSH). I structured it a bit though so you can skip through the parts that are boring to you :-).

images/screenshots/i3_ff_xonsh_ranger_kakoune_thumb.png

In the olden days a Unixoid OS had to be a giant pile of processes that work together to achieve a common goal: Setting up mail on your machine would usually involve setting up a local SMTP server, a local POP3 server (both of which did nothing but forward stuff) a MUA, procmail, etc... Text editing was done on commandline tools with names such as "ed", "sed" or "awk". (Followed of course by more user-interaction with emacs, vi, etc... you heard of them.) To some, this was just pure beauty, for some users (or lets better say: use cases) this was more than just cumbersome, as the process boundaries where mostly defined by technical reasons not so much by ease of use. So came a trend to develop more monolithic powertools, VIM, Blender, Gimp are some of the names that comes to mind when one thinks of tools from the Unixverse that have seemingly unlimited power and horrible learning curves.

While there is a prominent branch that goes towards more full-fledged GUI-hide-it-all environment (which is great for newbies) a kind of renaissance is happening where tools are being built that try to do "one thing well". This "keep it simple" is usually bundled with the idea of making it easy to connect different tools together and externalize tasks. Some go even es far as imposing hard limits on number of lines of their code, and deny the idea of configuration files (and instead change configuration in code, requiring a recompile). I personally do not agree with that idea.

There are however lots of tools that are doing a great job of finding a "sweet spot" between a simple implementation and ease of use (from the perspective of a technology-affine user). It so happens some of them made their way into my development environment, here is why I like them.

You find some of my config files for these and others in my dotfiles-public repository.

Linux Distro

ArchLinux. Why? In short: Because it lets me have all the new stuff integrated in the package management system (through AUR) while still not producing a total dependency hell (seriously I have no idea how you guys do it, but awesome work). That was never really possible with debianesque systems (although Ubuntu w/ PPAs is coming pretty close these days). Another great aspect of Arch is the KISS mentality: There is no complex buildup of distro system scripts that try to do something clever automatically, rather they focus on giving you a hand to make it very easy to set things up manually. The major downside is that due to the rolling release scheme, ArchLinux really should only be used when you are willing to load updates regularly, for a not-so-frequently maintained server system its probably not the right choice as you would probably rather prefer something less bleeding edge and with lower demands on maintenance. For a desktop/laptop system its (IMO) the perfect choice.

Window Manager

i3 is by far my favorite tiling window manager. I had tried before (admittedly most of these long long ago):

However none of these got close to the ease of use of i3, that is being easy to configure and extend and at the same time having easy to use shortcuts for getting the windows where you want. I'm not gonna go into depth about all the features here (there is enough material on the web), but let me also mention that you can control it with a separate client commandline tool, making it easy to use whatever you want for scripting.

Shell

Xonsh <3.

Do you like Bash and co.? Don't you just love spending hours of figuring out how to do the right combination of escaping and quoting or how to get a certain string operation right? Don't you love using sed, awk, tr, xargs, find, date, etc. in your scripts? When you want to do some quick math, "bc" is your go to guy? If the answer is no and you also happen to like Python, then fear no more. Xonsh manages to provide a full-fledged unix shell that is based on Python scripting. That's right, your shell scripts are python scripts and at the same time its of course possible to "just run commands" (i.e. you don't have any syntax overhead for that). At the same time you can just enter any Python 3 code directly in your shell (import modules, define functions/classes/variables, etc...). To me it really feels like the first time in 40 years there is a shell that makes sense :-)

File Manager

Ranger is by far my favorite (console-based) file manager, after having tried also mc, Vifm and LFM. Ranger features an OSX-like 3-pane view, previews for images, PDFs, code and other file types and recently also a split view that allows you to see multiple directories at the same time. Its nicely extensible using Python of course.

Text editor

This is pretty much the newcomer of the year, if not of the century. Kakoune is a text editor that was heavily inspired by VIM but with (from my perspective) two key differences:

  • Kakoune tries to really keep it simple, that is it does not have a large pile of features built in but rather relies on external tools for things like spell checking (e.g. aspell), file managing (e.g. ranger), fuzzy finding (e.g. fzf), formatting (e.g. clang, fmt) or even displaying multiple windows (e.g. tmux or simply your window manager).
  • While VIMs keybindings usually go "VERB - MOVEMENT" (eg. "dap" is "delete a paragraph") plus macros and various other functions to execute things repeatedly, Kakoune focuses on making it easy to deal with selections, having multiple selections and then running commands on them. This leads to a workflow that is more like "MOVEMENT/SELECTION - VERB" which not only lets you see what you are doing but oftentimes requires less keystrokes to achieve a task.

Both in combination make Kakoune an editor with a power comparable to VIM but with much saner integration with external tools and a way nicer learning curve. Oh and did I mention it has a client-server model allowing nice communication with external tools and setting up multiple views of the same editing session? If you want to see what it looks like, be sure to look into this nice introduction with visual examples