The Right Path

Not all the paths to the top of a mountain are equal. Some (most of them) are dead-ends (and backtracking is required), some eventually meet at the top.

Some paths are too steep, so they only seems shorter or more direct. In reality they are much slower and most of the time abandoned halfway.

Other paths, however, are better, less traveled, and among them there is always one - the right path - not too steep, not too long. Just right.

UNIX-like systems

The right path is through the most admirable human achievement - religious monuments (of the Church Of Reason).

Start with a UNIX-like OS

  • Gentoo
  • FreeBSD

Ricing of Gentoo or FreeBSD is the practice of problem solving and reverse-engineering.

Eventually, you will learn the most fundamental, universal concepts and notions which are at the core of a UNIX-like system, such a [wik:/FirstPrinciples/Structures linear and tree-like structures], sequences and isolated processes.

More than that, these concepts form a foundation of so-called [UNIX Philosophy] and, in part, the philosophy behind the great systems like Erlang.

GNU Emacs

Understanding and customizing Emacs is the right practice of programming and problem solving.

Understanding of Emacs is actually very deep and profound. It is a huge, complex ecosystem which is a proof (by example) of soundness of the underlying principles.

It shows how certain constraints of the environment (such as serial communication lines of terminals) have been satisfied, appropriate data structures (text streams) and corresponding functions and DSLs has been evolved (literally).

C- and M- keys have been used to increase the number of possible symbols which could be transmitted across serial lines and interpreted by the editor (which later became a standardized encodings).

Linear data structures (usually "packets" with fixed-length header and variable-length body) has been used.

Domain Specific Languages to describe various layers of a text structure (Text has a deep structure!) has been evolved.

Functional compositions (function pipelines) which are transforming text streams became the main paradigm of Emacs development. This is also a profound insight (which is related to biological pipelines inside a cell).

Once you standardize the interfaces (text streams between functions or UNIX pipes) you could easily (and transparently for other functions) wrap any function with your own, or even replace some function with your own down in the pipeline. As long as you follow the standard protocol and respect the standard interfaces everything will like a clock.

This is what the legendary extensibility of Emacs rests upon - functional pipelines, layered DSLs, proper high-level language (Emacs Lisp).

You will learn how to zoom in and out between layers of abstraction, through different DSLs,

You could easily zoom in from the level of packages, via standardized interfaces and well-established protocols (immutable boundaries, a membrane of a process, so to speak) to individual functions and "primitive procedures" and zoom out, back to a high-level abstract concepts, such as buffer, AST, etc.

The most important skill is to manage an appropriate (just right) level of details you have to deal with, by realizing and understanding of the natural

abstraction boundaries (protocols and interfaces).

The level of a packages, which provides an interface to the system, the level of functions, which have their own particular interfaces, and the level of primitive procedures and system calls (which are, of course, are interfaces too).

Interfaces all the way down.


This is the teaching language of decent CS schools.

Racket is the last in this tradition.


This is the monument of an applied functional programming - principle-guided real-world commercial project.


Purity of logic and math implemented as slightly extended and syntactically sugared Lambda Calculus, property typed with type-classes.

Programming Languages

Learn proper languages

Dynamically strongly-typed

  • Scheme
  • Common Lisp (Emacs Lisp)
  • Erlang
  • Clojure

Well-Typed (statically strongly typed with type-inference)

  • Standard ML (Ocaml)
  • Haskell

Statically strongly-typed

  • Scala
  • Rust
Last modified 11 months ago Last modified on Jan 10, 2020, 12:53:35 PM
Note: See TracWiki for help on using the wiki.