Advancing as a Programmer
About how I can become a better programmer. What directions might I take my skills? Where should I put my energy?
This note is framed in light of the following texts:
- Beating the Averages (“Classic” P. Graham essay on power)
- In defense of blub studies
- A defense of boring languages.
- Get better at programming by learning how things work
- What technologies should I learn?
That is founding the exploration on the notion of a imagined dichotomy between learning “boring” details (blub studies) and learning new shiny things.
These are of course not mutually exclusive. While it’s true that you can grasp the workings of let’s say the TCP layer of the Internet as abstract knowledge, to properly understand the concepts and implementation you’ll also have to know some languages.
Learning boring details (blub studies)
Examples of skills and knowledge that often feel undervalued but that still are important and essential:
- web servers
- IP/TCP stack
- DNS
- kernels
- git: Things I wish everyone knew about Git (Part I)
- zip and compression
- compilers
- DOM details
- browser redering engines
- terminal, unix, shell:terminal, unix, shell: The TTY demystified, The bash book to rule them all
Note that many of these pertain to systems programming.
We have used too many levels of abstractions and now the future looks bleak Another essay using this line of reasoning but this time focusing on systems security.
New languages and paradigms
Some alternatives I have been thinking about
- JS/node
- Swift
- Julia
- Rust
- Elixir
- Lisp
- Haskell
I have some experience with the langs in bold.
To generalise, these sort into some typical use-cases and motivations:
- Web-dev: JS/node
- iOS/macOS-dev: Swift
- Scientific programming: Julia
- Systems programming: Rust
- Theory and “power”: Lisp, Haskell
- Concurrency: Elixir
That is, JS Swift sort into a more practical and commercial use. Continuing to use Julia for scientific computing would further my understanding of maths and physics. I’d use Rust to learn about how kernels, OSes and low-level systems work. Lisp (an Haskell) would help me learn more about programming language theory and computer science. Elixir’d give me exposure to concurrent programming thinking and problems.
JS/node
Having developed some backends in node and many frontends in vanilla JS my current felling is that
Swift
Julia
Rust
Elixir
Lisp
Scheme, Chez, Chicken, Racket or ANSI Common Lisp, (ne Clojure dėl JVM).
The legendary SICP uses the Scheme Lisp dialect so that’s what I got started with.
Haskell
I dont’t think Haskell is a language I want to thoroughly learn, but some aspects of it has piqued my interest.
From what I have gathered so far its approach to many certain seem inspired by theory and mathematics; algebra and category theory. This in itself makes me interested.
Resources
Books
I have aqcuired some books that will aid me. I looked for the best I could find:
- The Pragmatic Programmer
- Seven More Languages in Seven Weeks (Julia, Elixir…)
- Programming Rust
- SICP (Scheme Lisp)
- Elixir in Action