I’m once again having a go at creating a BOOL Reference Implementation. I’ve tried this in code nearly half a dozen times before, and I’ve doodled countless lines of pseudo-code over the years, but I’ve always gotten bogged down in details and unknowns before.
No small chuck of the problem is due to my own indecision regarding certain language details. Witness the recent post about finally (I think; well, almost certainly; at least for now) deciding on how arrays should be. ) It’s really tough to design an implementation when you’re not really clear on a representation!
I find, too, that I can easily get mixed up between what I need to implement for what amounts to the compile representation versus what I need to implement for the run-time representation. In BOOL those two are very close to identical, but there are still significant differences. For example, data objects no longer have names at run-time (although one of the many open questions is the idea of retaining them as do function objects).
On top of this is the need to write an actual compiler and run-time engine, which again is really a challenge when the language implementation isn’t well-defined. Dithering over the language spec makes the compiler particularly tough — it has no idea what to compile.
The icing is a pronounced tendency to spend far too much time on small details, which makes things rather the long way ’round, so it’s no wonder I get bogged down, set it aside and never return. Often, by the time I hit the bog point, it’s all become such a convoluted mess that returning it to it is all but impossible.
However, to quote a famous starship captain (no, not that one; not that one, either), “Never give up, never surrender!” BOOL is an infrequently visited friend I’ve known for too many decades to walk away from now.
Retirement has brought something I’ve never had before in such large amount: time. For the first time in my life, really, I have the time to really work on projects, and one of the ones I’ve picked up is BOOL (hence this blog). The goal here is to, at long last, finally get it all down in one, accessible, place.
And so, once again, I’m having a go at a BOOL Reference Implementation. I’m using Python this time (making it the third go using Python). Previous versions used Java, C++ and C. (It’s possible I even had a whack at an assembly version back when I was doing a lot of that.)
It may be all the previous attempts, or it may be the ability to really focus on it, or both or whatever, but this time seems to be flowing easier. Still running into ‘wait a minute’ moments regarding whether I’m in compile space or run-time space. (And as I say, the line gets really fuzzy in places.) It may be that, in my dotage, I’ve finally learned to let go of my Engineer’s love of Excessive Complexity. I may have finally absorbed the lesson that the kitchen sink doesn’t need to be included in everything.
I do really love Python, and it’s flexible and fast enough to make experimenting and prototyping quite painless. (Plus it’s just a fun language.)
In any event,… here we go again!