I should have kept a log, but here we are: a bullet list of lessons learned from Advent of Code this year in no particular order.
- Egel is a fine language for short scripts, but—here we go again—it lacks an order in performance.
- When I do stuff right, and this year I did, Egel programs are comparable in size to Haskell programs but -in my mind- way more readable.
Where Haskell shines is sometimes clever use of laziness and -very important- list comprehensions. Egel sometimes shines because of clever use of dynamic typing (usually the use of none), and having mutation.
In comparison to K, both Haskell and Egel take an order more symbols. Ken Iverson was on to something. - Where Egel is slow that is usually due to several factors.
First, the interpreter implements a slow rewriter and something like a one-instruction increment which comes at virtually no cost in most imperative languages takes orders, and not a small amount, more.
Then second, I often iterate over dictionaries, which means first creating the list of keys and then folding over all those keys. I am not sure that is even that hefty a cost, but I should probably write folds and maps for dictionaries.
Third, looking up a value in a dictionary costs much more than indexing in an array.
That means that one example, day 6, which involves an enormous amount of iteration over a board, is very, very slow and times in at 12 minutes. - I added namespace mechanisms and that seems to be a win. Because I added namespaces however, and I still wanted to be able to include the out-of-the box utilities with a short statement I decided to uniquely name all combinators. (I.e., you'll normally find a length operator on lists, strings, and dictionaries, those now all have different names.)
That was a mistake, roughly I need to use the namespaces where nothing in System, OS, and List overlaps but it's fine to have a length operator on strings and use the namespace mechanisms to rename or include that in the manner deemed fit. - I should implement more generic combinators akin to Python or array languages like J/K. Just having add on atoms and complex data shortened the code substantially.
- I still get bitten by `-1` versus `-` `1`. I also got bitten by my dumb operator precedence heuristic, the latter did fine for a while but now I need to fix that.
- At the end of Advent of Code, programs become longer, and development becomes painful in Egel. I expected this but Egel is indeed only usable for relatively straightforward code.
For short programs, something like a missing or wrongly named argument is trivially found by inspecting the output after running the program. For longer complex programs, it becomes hard to see where the bug is without strong typing. - There was a segfault somewhere during coding this month I can no longer reproduce.
Egel is, after several years of ad-hoc development, still in an alpha stage. But I am getting there.
Egel programs and several metrics are in the README.
Egel programs and several metrics are in the README.
