Hello there! You are currently visiting gopherspace through a
proxy. To learn more about gopher and how to browse it, read this.

My software philosophy
Essential aspects of software that I consider good:

- Reliability:
Software must do its job consistently every time, without crashes
bugs or performance degradation even after running continously
for months. There's nothing worse than having to watch software
slow down to a crawl and having to restart it.
Reliability should be server-grade even on desktop applications.

- Less is more:
Tasks should be simplified into as little features as possible.
The bigger and complex the codebase is the higher the probability
of bugs. Complex tasks should be split into multiple tools that
do a few things and do them well. If the code is too complex to
be readable without splitting it into more than 2-3 files, you're
usually doing it wrong.

- Standalone binary and source:
Dependencies on 3rd party libraries should be minimized.
Don't you hate it when you install a simple program and it pulls
multiple huge libraries that use disk space and take a long time
to build/install?
Not to mention, the probability of breakage due to other software
wanting other versions of that library and generating conflicts
Ideally when I extract your code it should build out of the box
by calling a simple build script or, at most, running configure
and make.
I shouldn't have to install cmake, ninja, or other crap.
If there are any third party dependencies, they should be
statically linked whenever possible.
Basically, the application should be as close to a single
executable that runs out of the box anywhere as possible.

- Command line interface:
With the exception of tasks that absolutely require a GUI, there
should always be a command line interface to do everything and
the GUI should be optional.
Ideally, the user should also be able toggle the entire GUI layer
off when building the program to reduce dependencies, executable
size and build times.

- Performance:
Especially with software that needs to run continously, you don't
want it to use more resources than it should. CPU usage should be
minimized, with the exception of stuff like games and other stuff
that should run as fast as possible. Even in the case of
applications like games, framerate should be resonable for the
amounts of resources used (ideally 120+fps on low-end machines
for games at low settings).

- Simple config files:
Config files that are meant to be edited by the user should be
plain text with as little nesting as possible. Json with < 3
levels of nesting is fine, but you usually want to stay away from
json unless your programming language supports it without a
third party library.
The ideal config file simply contains default values for command
line parameters that you would always pass to the tool. mpv's
and livestreamer's config files are a good example.

- UI design:
The UI should at the very least fit into a 800x600 display or
smaller. Information should be compact and close together.
Unless the task at hand absolutely requires images and other
graphical stuff that terminals can't do, it's usually better to
have a ncurses UI that you can use from the terminal (which also
makes it more easily usable over ssh or from the tty).

- Keyboard control:
With the exception of pointing-heavy tasks like drawing, software
should have keybinds for everything so that advanced users can
speed up their workflow by not having to reach for their mouse.

Also see the suckless software philosophy, which I strongly agree
with: http://suckless.org/philosophy

If you want to read a full rant with examples that explains how I
got to this mindset, read modern_software_is_at_its_worst.txt.