Erst wenn die letzte Ölplattform versenkt,
die letzte Tankstelle geschlossen ist,
werdet ihr merken,
dass man bei Greenpeace nachts kein Bier kaufen kann.

Currently, I am trying to get familiar with Qt and C++. It makes C++ endurable, especially when combined with the new stuff from C++11. Basically, I don't want to tilt at windmills anymore - I wand to get some of my private projects finally finished. Still, this does not imply that I do not have an opinion about software.

And one strong opinion I have is that I usually prefer good terminal applications to GUI applications.

Let me first explain why I prefer plain text to "rich text", and why I prefer text-oriented software (like LaTeX) to graphic-oriented software (like LibreOffice). Don't get me wrong, LibreOffice is a decent piece of software. But like its competitor (MS Office) it makes people believe that "WYSIWYG" actually works, and even that their formatting will be conserved between different versions of the software. I can remember when I once had to fill in a list of a .doc file, which looked completely garbled, because the person I got it from had a font that I did not have installed, and another font was silently substituted. And more than once I saw people getting confused because the documents they printed omitted some characters, or changed their size. Ideally, formatting would not suffer from such minor changes, but in practice this is an extremely hard problem. In LaTeX, you will be aware of the font you used, and of all the packages and ressources you included. You will be aware of the formatting you use, because you have to type commands to do it. And you will be aware that there is a difference between your abstract document and the thing that is actually printed. Anyway, if it is sufficient, I prefer fixed-width ASCII or UTF-8 text. It consumes less memory, it is harder to garble, it has less clutter, and it is simple. In some cases, graphic is useful, like for mathematical formulae. But typesetting it is usually still easier with a text oriented format.

Text oriented formats can be edited using terminal applications, and plaintext can even be viewed in the terminal. As I said, I like good terminal applications, where "good", of course, means "good according to my opinion", and especially, just because an application is not good does not mean that it is bad. The problem is that there are a lot of terminal applications who share a philosophy of making it extremely hard for unexperienced users to learn. If you have to read a several pages long documentation and memorize all of the key combinations to use a terminal application, it is not "good" in the sense I mean. Even though vi and mutt might be powerful, and certainly not "bad", I still prefer emacs and thunderbird.

One of the first terminal programs I often used was the IDE of Quick Basic. Here is a screenshot:

Screenshot of Quick Basic.

The top line shows a main menu, similar to the one that can be found in many GUI applications. I opened the third item "View". The entry "SUBs..." is marked - it is currently selected. Next to the items, there are their global keybindings. And single characters of the Items are in white instead of black - these are mnemonic codes, which would be underlined in most GUIs. You can see scroll bars and a blue text field in the background. The red rectangle you can see on the text field is the mouse cursor. On the bottom line, you can see the tooltips of the selected entry. There are a lot of things done to make this UI usable for newbs. Still, it has global keybindings, so it can be used quickly by experienced people. It is not perfect, though. I don't see a reason why the scroll bars are always there and why there is an additional frame around the text field, which wastes space. Now, let me give you another screenshot:

Screenshot of the Mutt help screen.

The menu above looks like the main menu from Quick Basic, but it is not. It is just a list of some key bindings that can currently be used. This is Mutt's help screen. I cannot really say why, but many people consider Mutt "hard to use", and it is not just because you have to write a configuration file. You have to read the help file, or you will not be able to use it. There is no real "learning curve". Either you know the commands you need, or you can't use it. You cannot "explore" the program. This is the kind of UI I do not like. One can get used to it, and people who got used to it usually insist that they "like it that way". Well, having the possibility to disable a main menu and customize keybindings is a feature that good software should have. But an exploratively learnable piece of software would be nicer.

An advantage of Mutt over QuickBasic would be that it might be more accessible. QuickBasic imitates what GUIs do. But most GUI toolkits have an accessibility bridge like AT-SPI that can read out menu items. Still, both Mutt and QuickBasic can be used with BRLTTY, and probably Mutt is a little better in that case. However, not having an accessibility bridge is not an intrinsic property of terminal UIs. In theory, it would be possible as well, it just isn't implemented yet (to my knowledge). On the other hand, as far as I know, the more widely used screen readers have script support, and special scripts for many applications that would not be (well-)accessible on their own, but they can still fail with some applications - it is easy to design a GUI application to death. Parsing the output of a terminal application like QuickBasic should be possible, and with a reasonable API, it should be simple to learn to write customization scripts. So while at the current state it might be easier to write accessible applications with standard GUI toolkits, it is a lot easier to completely garble their accessibility that it is for terminal applications.

One major disadvantage of terminal applications is, of course, that they cannot show Graphics. In some cases, graphics are inevitable. Some applications like w3m use tricks to do so in a graphical environment, and there are terminal protocols that support line drawing. The obvious question one might ask then is, why use a terminal program at all. Links2 has a graphical mode which can show images and otherwise behave like a terminal: Good Websites mostly contain text with only few images, but when they use images, they either have an Alt text, or they usually have a purpose:

Screenshot of the links2 in graphical mode showing a comic from uxul.de

As long as graphics will not be used as pure design elements for applications, most of the benefits of terminal applications remain. In the case of links2, however, there is no good support of CSS and JS, which makes it almost useless for most modern websites.

Further disadvantages are not having multiple windows, no common look and feel, and often no mouse support or support for common key bindins. All of this, including an accessibility bridge, graphics and multiple windows, could in theory be changed. Especially, just because this can be done with GUIs does not mean that it is usually used to improve software.

In fact, many GUI applications could as well be terminal UIs. Many "music players", besides sophisticated design, only consist of a progress bar and a few slide rulers. Most chat clients and SIP phones could be replaced by terminal applications, and video players and video phones could be terminal applications, except for the one graphic element that shows the actual video. Many of these applications just suffer from having bloated and inaccessible GUIs.

In my opinion, terminal applications are usually easier to program, easier to reason about, clearer laid out, easier to script, and there are well-established remote access protocols (SSH, MOSH).