Issue 49: Trillions of Lines Written, and We're Still at Day Zero

Will code ever be finished?

Dear Reader,

Food For Thought

... despite the millions of people who have written code, and the billions, if not trillions of lines of code written since the field began, it still often feels like we're still making it up as we go along. People still argue about what programming is: mathematics or engineering? Craft, art, or science?

-- Coders at Work: Reflections on the Craft of Programming (affiliate link)

This month, I've been reading Coders at Work by Peter Seibel, a collection of interviews in 2008 with world-class programmers, including household names (among the tech nerds at least): Donald Knuth, Peter Norvig, Douglas Crockford, Frances Allen, and many more (there are fifteen interviews in total). Undoubtedly, with many of these visionaries, you may have never heard of them by name, but you have most certainly used or have benefitted from their work: Haskell, Javascript, compilers, JSON, etc.

When people throw the phrase around: "We stand on the shoulders of giants", these are the giants being referred to.

Reading this book now (in 2024) feels more relevant than ever as the landscape of the craft of programming is being rocked to its core with the introduction of large language models like ChatGPT and IDEs like Cursor or Github Copilot. The blistering rate of change makes it necessary for both developers and those who benefit from computers to take a step back, pause, and to witness the forest over the trees. The current news is a moment, a flash in the pan. Some flashes will indeed cause sparks, and some of the sparks will grow into full blown flames, but we must stay vigilant, and we must stay level-headed and at peace. After all, the present has a certain biased appeal to it (or whatever period of time you consider "the golden days"...science advances one funeral at a time, they say). These biases and the frenetic immediacy of the "latest developments" have a certain gravity to them, and that gravity can quickly become quicksand if we aren't cautious.

Generations; Generative

The jargon discussed in Coders at Work are relevant to a generation of programmers that I am not part of. The techniques they use are unfamiliar. Some of the languages are relics. Many of the concepts are too! And yet, there are some languages, machines and ideas that are the foundations of the work that I do today, and some of these ideas will continue to live long past me and my career as well.

To paint the scene of 2008, the corporate programming world was in the midst of a Java wave (which was open-sourced by Sun systems in 2008). Cloud computing had just got off the ground (AWS was created in 2006). The US economy would suffer a housing market crash, triggering a global recession. Facebook was four years old, Google was ten, and they just put out the Chrome browser. The iPhone was one year old, and the app store was launched in July 2008.

Of these meta trends, some caused proactive changes in the craft of programming, others reactive. The craft of programming had to rise to the challenge of distributed computing, and began to dream of how to do mobile computing at scale. Functional programming and OOP continued to square off as Haskell and Erlang took on the titans, Java and C++ (Javascript and Python have evolved to take elements from both paradigms).

Seibel: What do you think is the biggest change in the way you think about programming compared to back then?

Crockford: There was a period of maybe a decade where efficiency was really, really important. I guess it was in the early microprocessor era when memory was still really small and the CPUs were still really slow. We'd get down into assembly language in order to do things like games and music to make it fit and to make it fast. Eventually we got over that, so today we're writing big applications in JavaScript that run in a browser. It's such a profoundly inefficient environment compared to the stuff that we used to do, but Moore's Law sort of made it all OK.

-- Coders at Work: Reflections on the Craft of Programming (affiliate link)

Today's Dillemma

The present of programming is a living, breathing set of individuals, organizations, problems, business practices and a healthy dose of generational trauma.

Programming is a pseudo-perfect information game. Assuming you can get your hands on the source code of a project, there is nothing stopping you from getting the same program to run "anywhere" else. Code is like a strand of RNA, merely waiting for an engine to replicate it.

However, the hidden information of why a programmer solved their problem in a certain way may be lost to history. This is the key. All programmers, in the practice of their craft, take their why with them as they retire or pass away. They may be able to train a few juniors in their image with pair programming, or fancy Agile techniques, or beautifully written documentation, but at the end of the day, we are where we are and must do with what we can.

With all of the done work being... "done", with all of the local and global problems from their era solved and git commit(ed) -am "to history" by the programmers of yore, we stand for better or worse on the foundations of their choices. Some were good, others bad, but choices were made. Even inaction is action.

Each generation of programmers has a duty to do what they think is best, as to leave the next generation with the highest likelihood to be successful as possible in the ever exciting world of software. And so, let's reinforce the good patterns. Let's set aside our egos of how we want the world to be vs. how it is. Let's say yes to the things that need to be built, and perhaps more importantly, say no to the things that shouldn't be built. We do it for the love of the craft, we do it for the love of the game.

What will we leave behind, I wonder?

Leaving aside the work of Ada Lovelace—the 19th century countess who devised algorithms for Charles Babbage's never-completed Analytical Engine—computer programming has existed as a human endeavor for less than one human lifetime: it has been only 68 years since Konrad Zuse unveiled his Z3 electro-mechanical computer in 1941, the first working general-purpose computer. And it's been only 64 years since six women—Kay Antonelli, Jean Bartik, Betty Holberton, Marlyn Meltzer, Frances Spence, and Ruth Teitelbaum—were pulled from the ranks of the U.S. Army's “computer corps”, the women who computed ballistics tables by hand, to become the first programmers of ENIAC, the first general-purpose electronic computer.