Skip to content

The Humble Programmer

In 1972, Edsger W. Dijkstra published a paper titled The Humble Programmer. Dijkstra was trained in math and physics and was a university professor for much of his life. This paper is an interesting reflection on the history of computers and contains thoughts for the future. A few quotes are included below:

  • Those who want really reliable software will discover that they must find means of avoiding the majority of bugs to start with, and as a result the programming process will become cheaper. If you want more effective programmers, you will discover that they should not waste their time debugging, they should not introduce the bugs to start with. In other words: both goals point to the same change.
  • To put it in another way: as long as machines were the largest item on the budget, the programming profession could get away with its clumsy techniques, but that umbrella will fold rapidly.
  • The competent programmer is fully aware of the strictly limited size of his own skull; therefore he approaches the programming task in full humility, and among other things he avoids clever tricks like the plague. 
  • Another lesson we should have learned from the recent past is that the development of “richer” or “more powerful” programming languages was a mistake in the sense that these baroque monstrosities, these conglomerations of idiosyncrasies, are really unmanageable, both mechanically and mentally. I see a great future for very systematic and very modest programming languages.
  • The best way to learn to live with our limitations is to know them. By the time that we are sufficiently modest to try factored solutions only, because the other efforts escape our intellectual grip, we shall do our utmost best to avoid all those interfaces impairing our ability to factor the system in a helpful way.
  • We shall do a much better programming job, provided that we approach the task with a full appreciation of its tremendous difficulty, provided that we stick to modest and elegant programming languages, provided that we respect the intrinsic limitations of the human mind and approach the task as Very Humble Programmers.

Dijkstra was 42 years old when we wrote The Humble Programmer. At a similar age of 47 years, I too have come to appreciate the value of simple programming languages and a careful approach to writing software. Two modern languages that embody some of these principles are Go and Elm. While on the surface these languages may seem very different (one is procedural and one is functional), the values of the languages are similar. Both are designed with a great respect for the finite capability of the human brain. Both strive for simplicity first, and features are only added to the language after careful consideration. Both have excellent tooling that helps ensure consistency and correctness. Both are not just a syntax, but rather a culture and mindset. Experience on recent projects indicates that Go and Elm are effective languages, especially when I compare to previous experiences on C++/Javascript projects. There are rarely run-time exceptions. Compiler errors are relatively easy to understand and fix. Tooling is simple and almost invisible. Program maintenance and refactoring is enjoyable. The combined cognitive load of the language and the tooling is small freeing up resources for solving the problem at hand.

Today, there is a huge amount of churn in the software development world. Especially in front-end development, new frameworks are being released at an astounding rate. Many have their place, and perhaps each addresses some need. But it seems there is something fundamentally wrong with so many solutions for the same problems. Thus, it is encouraging to see new approaches where the authors have carefully studied the past, tried to learn from everything that has been done, and have created solutions where simplicity is valued. This is key to developer effectiveness, and really to life in general.