proj-oot-ootHistory

Starting in grade school i learned a bunch of programming languages.

Eventually i went to grad school for computational neurobiology. After i joined Chuch Stevens' lab, one of my thesis project ideas was to study scaling in computer architecture, and relate it to Chuck's work on scaling in brains. I started reading about concurrency mechanisms in computing. But then i chose another thesis project, and put that on hold.

Later on during grad school i started trying to survey all of the 'good' programming languages, for three reasons. First, i like to collect ideas (I also started making a list of programming language constructs). Second, i was studying neuroscience, so i wanted to learn about many different Turing-equivalent systems so that i could more easily reverse engineer what the brain is doing. Third, i realized that i would be writing a lot of software in the future, so i wanted to learn about what programming languages are out there so that i could pick the best one and use that.

After reading a little, i decided that i wanted to learn Haskell next. I wanted to look at languages that could be used to write programs in a massively concurrent style, and i had heard arguments that Haskell was particularly good for concurrency. The argument was that, since it seems that shared state is the bottleneck preventing concurrency, Haskell's purely functional emphasis is just the ticket. I learned a tiny bit of Haskell and found it extremely interesting, but then i saw a Python and a Haskell implementation of the core of an autocorrecting spell-checker, and the Python version was both shorter and easier to read. This and other reasons (see [1]) led to decide that i preferred Python over Haskell. This was disappointing, because i liked various things about Haskell, especially its purely functional emphasis, its higher-order functions and partial application, its laziness, and its type system, especially the idea of typeclasses. I started thinking about writing a framework on top of Haskell, which would bake in some common monads for e.g. state and exception handling. Then the idea expanded to a new programming language which would mostly follow the semantics of Haskell (with a few fixes to remedy the problems i identified in Why Not Haskell) yet be easy to read, like Python (in my head i called it "the Python of Haskell"); this is described at the bottom of the Why Not Haskell page, although that was written later.

i don't quite remember when this occurred, but definitely no later than 2009.

At some point, I named the language Jasper, for two reasons. First, i thought the name Perl was a cool name, so i wanted to name the language after a rock, and my favorite kind of rock is Picture Jasper. Second, i was planning to implement it on top of the JVM, so having the name start with a J seemed appropriate. However, later on, i decided i didn't like the name Jasper as much anymore. First, it's not as easy to type on the command line as commands like 'perl', 'lua', 'awk', etc. Second, my conception of the language is no longer tied to the JVM, and currently, having a language-y thing start with the letter 'J' makes one think of Java; if one thinks of a two-letter abbreviation for Jasper, the most obvious one is 'JS', but currently, that makes one think of Javascript (although 'JP' would work (even though it is associated with Japan)). Third, since it's a real English word, if you Google for it, you get various existing hits, so it's not extremely Googlable.

So, in October 2014, i decided to change the name to Oot. Oot is the sound a submarine makes. Like Jasper, the name of my favorite kind of rock, Oot is personally meaningful for me; it is named after a picture that my wife once drew.

At some point, i decided that the language should have graphs as a pervasive data structure. I think i started out thinking that associative arrays would be that structure, and then thought, 'Can i generalize associative arrays to something even more powerful?' I don't remember when or why i first had the idea of having associative arrays as a pervasive data structure. Some possibilities:

I started writing down notes on the new language. I also became attentive to praises and criticisms of other languages (I was mostly reading Hacker News for these), and started taking notes also on what other languages seemed to be doing right or wrong, and on the pros and cons of various language design alternatives. I also read things like Graham's essay http://www.paulgraham.com/power.html and similar, and took notes on what people thought were the design criteria that made a good programming language. Graham's essay starts by asserting that Python values readability over succinctness, and goes on to argue that that's bad. But I noticed that one of the things i most valued about my favorite language, Python, was its readability. I eventually came to the conclusion that although i thought that expressiveness and succintness was important, readability was as important or more important, for reasons i won't fully discuss here (but it has to do with TMTOWTDI giving different programmers freedom to use different idioms based on different subsets of the language, producing mutually hard-to-read code; Graham doesn't penalize the language for hard-to-read code whenever the programmer COULD HAVE written the code in an easy to read way, but i do).

Eventually my notes file(s) became unmanageably long, and i started creating different notes files for different topics, such as syntax, data, control, etc. Eventually some of these became too long too, so for each topic i had one main file (ootTopic.txt), with only relatively settled decisions, and also a Thoughts file (ootTopicThoughts.txt) with less settled decisions, and also one or more Notes files (ootTopicNotes1.txt).

Much later, i started drafting a whyOot.txt file that would list Oot's features. This quickly became very long, and one day i thought of my 'prime priority' method and applied it to select the most important features or groups of features. This gave me a lot of clarity as to what i thought were the most important ideas for Oot. Originally this was a bulleted list, but then i decided to write up that list as prose. The resulting prose gave me more clarity on what my design goals were for Oot.