Typographic Programming Language
Allow me to present a simple thought experiment. Suppose we didn’t need to store our code as ASCII text on disk. Could we change the way we write – and more importantly read – symbolic code? Let’s assume we have a magic code editor which can read, edit, and write anything we can imagine. Furthermore, assume we have a magic compiler which can work with the same. What would the ideal code look like?
Well, first we could get rid of delimiters. Why do we even have them? Our sufficiently stupid compilers.
Delimiters like quotes are there to let the compiler know when a symbol ends and a literal begins. That’s also why variables can’t start with a number; the compiler wouldn’t know if you meant a variable name or a numeric literal. What if we could distinguish between then using typography instead:
Here’s an example.
This example is semantically equivalent to:
print "The cats are hungry."; //no quotes or parens are needed
Rendering the literal inside a special colored box makes it more readable than the plain text version. We live in the 21st century. We have more typographic options than quotes! Let’s use them. A green box is but one simple option.
Let’s take the string literal example further:
Without worrying about delimiting the literals we don’t need extra operators for concatenation; just put them inline. In fact, there becomes no difference between string concatenation and variable interpolation. The only difference is how we choose to render them on screen. Number formatting can be shown inline as well, but visually separate by putting the format control in a gray box.
Also notice that comments are rendered in an entirely different font, and pushed to the side (with complete Unicode support, of course).
Once we’ve gone down the road of showing string literals differently we could do the same with numbers.
Operators are still useful of course, but only when they represent a real mathematical operation. It turns out there is a separate glyph for multiplication, it’s not just an x, but it’s still visually confusing. Maybe a proper dot would be better.
Since some numbers are actually units, this hypothetical language would need separate types for those units. They could be rendered as prose by using common metric abbreviations.
In a sense, a number with units really is a different thing than plain numbers. It’s nice for the programming language to recognize that.
As long as we are going to have special support for numeric and string literals, why not go all the way:
If our IDEs really understood the concepts represented in the language then we could write highly visual but still symbolic code. If only our compilers were sufficiently smart.
I’m not saying we should actually code this way but thought experiments are a good way to find new ideas; ideas that we could then apply to our existing programming systems.