I gave a talk at Pittsburgh Tech Fest that I’d been wanting to do for a while, which is a talk about how to program a time machine and what the programming language for it might look like. I re-recorded the talk.
I wanted this to feel as real as possible, so there is a website, timeline-lang.com that talkes about Timeline, the programming language. I even built a syntax highlighter for it as well as a vim syntax file
Some of the concepts I like about it are that instead of having a free-wheeling syntax, upon which you must place “best practices”, the language simply
requires them. For example, rather than debate putting spaces around operators…you have to. Rather than discuss how to extract expressions into well-named
variables or functions, you just can’t use expressions in
if statements - you have to use a variable. And instead of having discussions about using good
variable names, you simply can’t use a word in a variable that isn’t defined in the dictionary.
These are features I think any language could implement. The other part of what I imagined about timeline was baking in observabililty. We tend to litter our code with log statements, stat measurements, and the like, and it not only creates distracting code, but it also requires some deep thinking about what to instrument.
What if the language runtime simply logged everything that happened in your app? What if execution of your app produced a “black box” that you could visualize to understand what your code actually did? We usually are far more interested in what a program does (or will do) than what the programmer intent was.
I’ve come to believe more and more that consistency around how we work, and simple rules about undifferentiated work, enforced by tooling, is the way to scaling and productivity. Why cant our programming languages work this way, too?