Another month gone, so quickly. What the heck did I do? It’s difficult to recall, but my git history is helping.
It seems my major accomplishments this month were:
- implemented automatic unit testing for the AO dictionary (runs all `test.` words)
- implemented an automatic type analysis based on partial evaluation
- implemented a few list processing functions (e.g. nub, partition, sort, map, each)
- simplified and optimized fixpoint combinator (15 ABC prims, from 80)
- cleaned up the conditional behavior words (e.g. `if` and `if_`).
- partially developed an incremental processes model (based on `µP.[a→(P*b)]`)
Not too bad, but I can’t say I’m entirely satisfied. I had an aha-moment idea for direct compilation of ABC into a Haskell monad (to improve bootstrap performance) but that ran into a wall. After picking up the pieces and removing the debris, all I had left of that effort was the typechecker. I also ended up removing adverbs, after experimenting with the idea and finding I needed more specialization for context and category (e.g. lists vs. streams vs. automata).
Ah, six steps forward, two steps back. That’s progress.
My plans for the next month are to start building functions for data structures: maps/records, sequences, streams. And to further fill out the set for lists. I hope to get far enough along that I can start modeling grammars in April. At the moment, I have 844 words in AO, of which slightly more than half (440) are documentation (`doc.`), tests (`test.`), or assertions (`id.` or `eqv.`). I don’t know how many words I’ll need to bootstrap an ABC or AO compiler – quite a few, I imagine, but hopefully fewer than 10k. Regardless, I need to pick up the pace.
More subjectively, I quite enjoy programming in my new language.
The REPL plus automatic tests mix is very effective. I’d still like some automatic visualization and continuous feedback tools, and I very strongly look forward to rendering colors/styles instead of suffixes/prefixes for large words. But I’m not desparate for these features. AO has been delightful in its simplicity, security, safety, and flexibility. The first-class nature of the environment gives me much greater feeling of ‘control’ than I’ve felt in other languages. Going back to Haskell is starting to feel a little painful.
My main pain point for AO right now is the awful interpreted performance. I’ll be a lot happier with AO when I can compete with other languages for performance.