Programmers are talking about proper (adequate, reflecting actual aspects of reality) abstractions, right data-structures and algorithms that follows and books, while coders are always talking about tools, popular bloated libraries or mega-frameworks and class-hierarchies.

The recent disaster (or rather a major regression of a human intelligence) which is called NodeJS and npm is too tragic to discuss here.

So, let's talk about tools. (I'm an oldfag - a senior Master UNIX Administrator and System Programmer after all.)

Tools increase productivity

This is exactly what is a tool - a device, an instrument, a program which allows more efficient completion of a task. Computer is a tool, a type-checker is a tool, a machine gun is a tool.

An appropriate tool gives you a leverage. This is what it does. With a long-enough lever one could move the world. Not using tools is plain stupidity. All your competitors are using some tools.

Leverage means a ratio between the magnitude (quality) of the result and time and effort invested. Select the tools that give the highest leverage (a machine gun).

Basic Tools

  • Vim - basic (quick) editing
  • Trac - a collaboration and publishing tool
  • Emacs + [wiki/Tools/OrgMode org-mode] - extensible (programmable) editing environment
  • make - basic automation with dependencies tracking.
  • Python - a quick prototyping language with tons of libraries.
  • Cmake - the old (and fucked) way to manage C++ projects


Do not reinvent the wheel. Re-use the products of tens of thousands of man-hours (of much better training and higher intelligence) instead of growing your own wood to make a paper.

No car (or an aircraft) is being made from a raw steel and polyester. Instead, aircrafts are assembled from pre-build parts (made by organizations of other people). This is the only reasonable way to build a large complex system.

Use (compose) functions from best quality libraries. This is the only way.

Parallel processes

It is ridiculous to busy-wait staring at a kettle until the water is boiled. Spawn a process and continue until notified is the universal pattern. Even cells do this.

Right tools allow you spawn parallel processes - refactoring, type-checking, code reviewing, compilation, testing, validation, deployment, etc.


A kettle that switches off when the water is boiled is what automation is all about. If it could send a notification (play a melody or send an SMS) that would be even better automation.

If you have to do something more than twice, write or find a tool the third time. make is a wonderful tool. So is crond.

Automate everything, like in a SCI-FI movie - imagine that your scripts or programs are commands ran by your voice.


Testing is an overlooked part of a scientific process. Hypothesis must be tested, otherwise they are mere ideas, stories, beliefs. Testing is software engineering is as important as it is in science. Engineering is an application of the scientific method to solving problems.

An airplane does a self-test before takeoff. That is for a reason.

Quality control

Quality wins. Always. The most important metric ever is code quality, which is related to optimal simplicity, which is a sign of beauty and elegance. Beautiful code, like a poetry, cannot be improved - it is a closest approximation to a local optimum.

Metrics (feedback)

If you can't measure it, you can't improve it. Metrics must reflect reality, not imagination.

Validation (reality check)


Faster iterations is a big leverage. Time is money.

Faster tools runs often. Eclipse is a slow, bloated crapware.

  • Linux/FreeBSD/etc. - Evolved (not pushed by marketing departments) community-maintained UNIX-like platforms. There is no reason to consider proprietary OSes except unavoidable necessity.
  • Vim - for quick, in-place (remote) text editing. The small miracle of software engineering.
  • Emacs - Editing Macros for source code manipulations, more than Good Enough, a huge miracle.)
  • svn, git - just do it.


  • Scripting (prototyping)

Python3 - The only scripting language we need. It is almost close to perfection.
Julia - matrix manipulation, fast prototyping, data exploration and analysis.
Luajit - yet another miracle of software engineering (a JIT compiler and VM)

  • System (Low-Level)

C - The language of choice for System Programming, more than Good Enough.

gcc - De-facto standard C Compiler for all platforms. Good Enough for everyone.
Clang - backed by Apple aim to produce a better compiler. It works.

  • General Purpose

Go - The only alternative to Java madness and C++ mess, made by best brains from Bell Labs and Google.

Protocol Buffers - The right way of using tools to save programmer's time.
GRPC - RPC based on Protobuf over HTTP2 or TLS

Swift - The second most well-crafted perfectionist language after Go (Apple-only so far).

  • High-Level

Scheme - The language for Modeling and Prototyping, daily programming.

MIT Scheme - mature implementation right from the horse's mouth.
Racket - an attempt to make Scheme cool and sexy. Almost successful.
Gambit-C - what a single talented and passionate engineer can do.
Bigloo - the mature and stable Scheme system from Europe (France).
Chez Scheme - state of the art money can buy, brought by Cisco.

Common Lisp - The Lisp programming language in its full glory.

CMUCL - industry-strength implementation from CMU - famous AI workshop.
SBCL - in December 1999, SBCL forked off the main branch of CMUCL.
CCL - another serious implementation, based on classic code.
CLISP - a famous Lisp by Bruno Haible, with dynamic modules.

Erlang - Difficult things (concurrency, parallelism and fault tolerance) done right - the functional language based on the Actor model. Toys like Node.Js did not even came close to this.

Haskell - This is a "Common Lisp" of the ML-family world.

  • JVM

Clojure - If we are so ignorant and unfortunate, that we *MUST* mess up with Java.
Scala - This is an over-engineered perfectionism by the ambitious leading expert in the field.

  • Tools

PostgresSQL, LevelDB, Redis, memcached, Nginx, etc.

There is a list of recommended books which might clarify our selection of tools.


just use Haskell

homogeneous conditionals and lists (and other aggregates) - no, thank you!

What about C++?

A terrible mess.

Why not Ruby?

It is not multi-paradigm, it forces OO, it has messy syntax.


Well, it was nice..

Javascript! NodeJS! Coffescript!

Go away..



Last modified 7 months ago Last modified on Aug 2, 2019, 7:19:45 AM
Note: See TracWiki for help on using the wiki.