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
  skyrockets.
  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.