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.