finger of verisimilitudes.net Pseudonym: Prince Trippy Email: programmer@verisimilitudes.net Projects: Meta-Machine Code; pleasing patterns; network protocols; SHA Languages: Common Lisp, Ada, APL, Forth, machine codes 2019-05-25 I've decided I'll be using Finger as a log of a sorts. If something is worth mentioning yet doesn't warrant an article through Gopher or the WWW, I'll find myself compelled to mention it here instead. Perhaps I'll also be more inclined to more frequently work on my various plans, due to this. Currently, I seek to finish learning Ada, write proper networking libraries for Common Lisp and Ada, write proper server implementations for a Gopher hole and Finger, finish work on my JSON Common Lisp library I've named JSON-SUCKER, and, lastly, continue work on and finish that reimplementation of my Meta-Machine Code targeted at CHIP-8 written in Ada 2012. I'll see how my daily progress on these improve now that I have this. 2019-05-28 I fiddled with my JSON-SUCKER a tad and I added some new functionality to the ACUTE-TERMINAL-CONTROL Common Lisp library; all in all, I made some progress but I didn't actually finish much programming. That's the way it should be, I suppose. 2019-06-01 I somewhat begrudgingly refined one of the previous features added to ACUTE-TERMINAL-CONTROL to have it use that overwhelming convention for the meta key, as opposed to that much simpler convention I'd implemented days ago. I'm particularly pleased with a neat little thing I've done with regards to this Finger service this day. I'd had a copy of this Finger output available over Gopher and I realized the protocols are so similar I can have the Gopher transparently refer to the Finger. So, I had the menu referencing the Finger resource use the proper name as the selector and have it report to port seventy-nine. Now, a simple Gopher client will make a Finger request without even knowing and a more advanced client will easily switch over to Finger; my Finger service is now more easily accessible and yet without Gopher taking any attention away from it. All left was to add an ending period line to accomodate Gopher's text resource ending. How nice. 2019-06-09 I improved the way ACUTE-TERMINAL-CONTROL detects the function keys, adding better support for those stupid conventions used by xterm and also adding support for function keys sent as that FUNCTION KEY control sequence, which is the only way this should be done. 2019-06-14 Yesterday, I'd created many integer symbols in my three-by-three pattern I enjoy so. Today, I'd use this to improve my 2019-02-12 article. 2019-06-22 While trying to sleep, I would think of an alternative metadata format for my MMC targeted at CHIP-8 again; I believe I'll be implementing it in the Ada reimplementation instead of what I've been using and the only real drawback is the name limit going from 2^12-1 to 2^11-1, but this is still far more names than would actually be used. I finished chapter twenty-three in that ``Programming in Ada 2012'' by John Barnes, which covers the standard predefined library, yesterday. Now I feel ready to truly start programming in Ada and also to resume reading the standard document. It will still be at least until the end of this year until I'm truly proficient and comfortable with Ada, but I'm still excited. Once I have my own networking libraries, I'll be set to start reimplementing network software I use. 2019-06-26 Yesterday I'd made a correction to this Finger service that permitted the Emacs client to access it; it merely involves allowing the ``@'' and domain to follow the name in the request and was simple to adjust. Today I started the article for my comics, most of which will relate to computing; I'll see how that progresses. 2019-06-30 I've decided I'm going to start replacing my Gopher and Finger servers, with Ada, gradually and as I learn more. To start, I can use a basic Gopher server with xinetd, as my current Gopher server does and once I've a good networking library for Ada I can have that entire system be Ada. At least then I'll have good logs, using the format I've designed for such. I would, eighteen months after releasing my SHUT-IT-DOWN Common Lisp library, release a similar such library, today. My COMMON-CHARACTER-SETS library is licensed similarly and does not even define any package, merely placing certain keywords into *FEATURES* to denote which character sets are detected as being supported. This is intended to make writing network software and whatnot easier, since the Common Lisp standard doesn't dictate the character set to be used. That particular Unicode encoding used will likely be an issue, though. In any case, I like this simple little library, so far. 2019-07-14 I've struggled with Ada more today. So far, I've only written very trivial programs that are simple procedures and I've had no real success going further. No package I wrote was good enough to stand, on its own. I've gotten out of this rut however, by deciding I should simply write programs without a package, for now. I'm inclined to believe a good bit of my issue was trying to work with improper package boundaries. I'd finished some of a Finger server implementation, today. Finger is good for this, as it is simple and concerns textual communications. I may have a version working with xinetd soon and then have a fully independent version later. I feel I am beginning to understand Ada well. How nice. 2019-07-25 A few days back I'd started reading the ``Ada Reference Manual'' again since I'm somewhat bored with reading ``Programming in Ada 2012''. Yesterday, I'd passed my previous point, and so now I'm making progress with that again. I don't use my MMC much at all, due to various issues with flaws in it or most likely my mood these past few months, but I'm changing that today. I was going to write a nice little Tennis game with several game modes and making use of self-modifying code with the goal to be smaller than 512 octets, as I'm aware of a Tetris in as much, and mine should be smaller. However I have recently thought of an even simpler way to slip back into these things: I'll write a Rule 30 in CHIP-8; it will be interactive, of course, but this is even simpler than Tennis and, while I've seen the Game of Life I've not seen Rule 30, making this option all the more interesting. Currently I've the pattern entering section rather finalized in, roughly twenty five instructions, and I'll see the rest finished later. Perhaps I'm out of my most recent rut, now, or perhaps not. The highlight of this CHIP-8 programming was my having already had the interface decided upon and my realizing I could avoid explicit sprite data, if only I could locate an FE. I knew I'd need an FXYY instruction that was manipulating register fourteen for this, which seemed unlikely; I had FF65, the register loading instruction, manipulating every register, so that my program could claim it did not depend on the initial register state of the interpreter and I noticed I could change this to FE65 to get this constant I wanted, since I need not an initialized register fifteen anyway, as it is such a special register that is used as an implicit register by many instructions; with this I can avoid an otherwise necessary irregularity in some positioning code I have planned; it can now use a different starting value that will be in line with the prime loop of the program and so I've likely saved some instructions. This is because I did have an FF constant available at the beginning of the program I would've otherwise used. How nice. 2019-07-27 For however brief of a time, I've had the idea of a high-level interface in Ada for OpenBSD's pledge mechanism. I've designed the package, containing two simple enumeration types, an array thereof, an exception, and a single Pledge procedure accepting that array. Today, I finished an initial version of the package body, which is currently an imported C_Pledge procedure and Pledge itself; this was a valuable learning experience, as this was the first package and package body I am particularly proud of. The implementation was simple, straightforward, and I learned a good amount concerning standard packages and how to use them well, as well as seeing good compiler messages and gradually correcting them until it successfully compiled. I lightly tested it by allowing and disallowing that ``stdio'' promise and trying to use Ada.Text_IO.Put, with the expected results. How nice. 2019-07-28 I continued improving my Ada interface for OpenBSD's pledge. I rearranged and improved the comments along with removing an unnecessary package use and, as figured, preconditions appear to be my single method for making the code more robust to change and so I've been working on an appropriate such one and almost have it finished. 2019-08-03 I've updated my Ada interface to support both pledge and unveil, changing the package name to simply ``OpenBSD''. I've also rewritten and expanded upon the documentation, along with improving comments and writing Unveil to fail to compile upon uncoordinated changes to its Permission enumeration type. 2019-08-06 I began working on my MMC targeted at CHIP-8 written in Ada again. I've largely finished that which comprises the ``personality'' of the tool, the routines that ask questions to create instructions or display instructions, and have struggled with designing a coherent package for all of this. I think working on the primitives of this system and going back and forth, until I met these extremes in the middle, is the best approach currently and so I started work on those primitive input routines, just as I did when writing the Common Lisp implementation. That implementation was mired with tangential experiments, however, and the Ada isn't, leading to a better and more abstract set of primitives, in comparison. The two input routines are those which collect: one line of input and collect a bounded integer with a name association. I have also abstracted a routine for displaying important messages that must be acknowledged. Currently, only the bounded integer routine is left, although it is also the most complex; what I have currently will require only minor modifications to integrate with that remainder of the system, once I progress further. 2019-08-09 I worked again on my Rule 30 implementation in CHIP-8; I gave the register layout more thought and I mulled over enhancements I can make to a future version so that I could enter in the OctoJam VI with other programs I write entirely in October. These improvements are with regards to making the speed and cell pattern interfaces more clear. I've also thought of an easy way to have my speed interface map easily to its CHIP-8 speed; since it'll resemble the cell pattern entry, it will be a simple bar with the vertical position indicating the speed and, clearly, the top-most should be faster than any lower position. Given that CHIP-8 coordinates map lower positions to higher coordinates, and CHIP-8 timing is in terms of the delay, that means the highest coordinate will have a zero delay along with the lowest having the highest delay, so this maps nicely, as identity. In any case, I found myself struggling to write the twelve instructions that I did. These implement the core Rule 30 algorithm and I simply need write the surrounding loop and whatnot around these. I believe I may simply be out of practice. I'm now holding to the idea that I must not fall out again and so should write at least a little machine code every day. As for my writing style, perhaps it's truly easiest and most natural to write machine code as disconnected fragments which are slowly made to coalesce. As is obvious, it's so much easier to mull over than to do, it always seems. 2019-08-10 I wrote most of the prime loop around the main Rule 30 code, sans the shifting behavior. I also had the drawing code optimized and whatnot; most of the program is now finished. The drawing behavior's interesting, because it would be simple to have a loop draw eight eight-by-eight sprites and have it at that, but the most optimal form of this code is drawing four eight-by-fifteen sprites followed by drawing an eight-by-four sprite and so I went with this latter option. I should be finishing with this program soon. Doing just a little machine code programming each day is nice and I shouldn't've let my practice falter so. I mulled over a loop that would repeat sixty- four times and how best to write that, when trying to sleep. That recursive approach, of using four calls to four calls to four calls to the actual routine, would consume twenty-eight bytes of memory. Using an explict loop would require four, for the skip instruction and so also the conditional jump; this requires a counting register and, in deciding which direction it should follow, I realized that register used as an index and vertical coordinate would have values zero to sixty-four in its usage, and so that settled that. How nice. 2019-08-18 I'm collecting my work from the past several days into a single location, as in isolation much of it wasn't worth making a note in this. I realized the cell access of my Rule 30 would access past the last memory address, so I shifted the location of the pattern storage down one, rather than make any greater changes or add special cases. That's nice and simple. I did not name this address, being so certain it wouldn't change, as I like to do, yet it harmed me this time, as I'd to update it manually. I'll keep this in mind next time I avoid naming an address; it's fine if I'm absolutely certain, such as using the last three addresses for a decimal digit buffer as I've done before, but I was so certain of this choice, the last sixty- four, and yet had to change it, due to a lack of forethought; I'll need be more cautious, I suppose. In saving space by overlapping unused initial register values with those that would be used, I saw I would have the name for the beginning of these values consumed by another range and so I would add a new display method for such named addresses to my MMC, having planned it a long while back. I chose orange as the color, to contrast with yellow, and I noticed a pleasant value for it: RGB 255 127 63. Today, I scanned through it again, made final changes, and tested that program in an implementation. I realized I'd done some horizontal coordinate figuring from the right end, instead of the left end, but the core of the program behaved properly, and once I corrected all of those it worked correctly. Since the ends of the pattern are dead cells, an unpleasant pattern eventually overtakes the screen, neverending, so I'm going to experiment later with the ends being alive, and alternating which would be alive and which would be dead; I'm glad to have finished this initial version and plan to have an improvement for a CHIP-8 programming event I want to enter again; I of course documented the program today in an article. This all made today a good day. 2019-08-26 I have struggled a great deal continuing with Ada these past few days. My MMC is still a fuzzy idea and this does not go well with a language such as Ada, but I have little other option and can't bear to look upon the Common Lisp again, so I'll persevere with it. I've modified that arrangement of the last nine characters of the character set, making it much more pleasant, I find. I've done much of the work to have the fundamental Show_Row procedure implemented nicely, learning that Ada requires me to encode UTF-8 manually, from a Wide_Wide_String, but it does provide packages specifically for this. Ada also seems to have poor standard functionality for when I must have a very particular format for integer output, so I have written my own. This is valuable experience with Ada and as I persist I'll find it increasingly easy, I figure. I've already learned so much in just what I've done. 2019-08-30 I began work on my CHIP-8 Tennis game, starting with the main menu functionality that ties different modes together; I only wrote five instructions. I read the IETF RFCs 760 and 768, concerning the IP and UDP, respectively; my initial plan was providing only a high-level library for varying protocols and I recognized the stream and datagram concepts were too different to really work well for such an interface. I've decided I'll instead work on specific libraries for the relevant protocols and then perhaps later attempt to combine them under another interface. It's amusing to read of the security fields of IP and how it was considered reasonable at the time to include such things. 2019-09-04 I worked on and rather finished the package specification for this Reliable_UDP Ada library I've had planned. This largely concerns a protected object and hides the underlying initialization assigning the port by doing other necessary work there as well; there is a single Sending entry, there are six Receive entries, and I've had the idea of Mismatch which will provide for behavior where the Receive is given more or less data than is possible or alloted for. Half of the Receive varieties ignore IP source address and source port out parameters. There are four exceptions. This is a good start for a high-level networking library, I think. 2019-09-05 I mulled over how I'll implement a nonogram game next month for the sixth OctoJam event. The simple and obvious method for processing the pattern data will be too slow to run on a calculator, which is expected to process forty or so instructions per second. A table-based approach to decoding such is acceptable and likely wouldn't consume much space, based on how many contiguous segments are encoded and how large each can be. I'd prefer to have three segments possible, but this requires double the storage by virtue of requiring three nibbles. Further, to avoid issues of binary table inversion, I would need to store each pattern twice for each way, halving the number of patterns and complicating adding new patterns greatly, by making the requirements greater than being able to simply mindlessly append new data to the end, although even that would have some restrictions. I figure I'll be doing a variety of these implementation strategies for the event. I largely rewrote what I'd had previous with regards to the Tennis game, now having written eleven instructions in sum. 2019-09-07 I wrote a single line of APL today. Twenty-two characters on one line result in a program which can produce a checker-board pattern. This is an obvious application of reshape with an even pattern and an odd second dimension; the only reason it's as long as it is came from making it work with an even second dimension; my solution was to increment such even dimensions and lop off the last column when the requested dimension was even, whereas the odd case accepts the entire result. My APL article is improved by a description of this program and I'm glad to still enjoy writing APL. 2019-09-08 I feel fatigue working with POSIX sockets and I've so far interfaced with the socket function itself and only started with bind. I'm writing my library to free myself from such a baroque interface, so I've easy networking programming to anticipate, at the least. 2019-09-11 I wanted an excuse to name a program or library ``retard'' and have my eyes set on eventually having a new Common Lisp library for processing the tar format, REmarkable Tape ARchive Deconstructor. I'm still largely ignorant of this poorly designed format, but I've thought of a suitable way to process it in Lisp and expect I'll have it soon enough. 2019-09-12 Lately I've been struggling with working on my programs and I believe at least part of the issues in this are a choice paralysis or choice overwhelming; I've thought of a solution that I decided to use today and it worked quite well: I created a list of ten things I could work on, two unrelated to any hacking, even, and I rolled a ten-sided die to randomly select between these different pursuits. It chose my CHIP-8 Tennis game and I was pleased with this; I found I was able to concentrate very well and so this decision method seems good. I wrote forty-three instructions, starting with the pattern entry code that largely took from my Rule 30 implementation and later began work on the main game; I expect I may rewrite or even discard much of what I wrote, but it was still good to do, as I'm aware of planning issues I need to face now, such as register exhaustion and also the collision method I'm rather required to use, due to the customizable player sprite. I can face register exhaustion using a lone register for all constants and then simply loading them wherever and before they're used, for a nice example. I should sit myself down and plan the game out in some detail before I continue it. 2019-09-13 Today my selection method chose my UDP Ada library and so I worked on that. I now have the sockaddr structure as an Unchecked_Union with an access type and I may be finished with initialization. I'll now be working on the Sending and Receiving entries; I'll be adding some alterations to my design of the latter to add more varieties for blocking and timeout approaches. I vehemently dislike this API and working with it is dreadful; it is filled with decades of poor ``design'' decisions, unnecessary fields, useless padding, and is generally unpleasant. Writing my OpenBSD Ada bindings was much more pleasant. I expect to also make some changes to take some advice and have this work nicely with the Ada.Streams facilities. Perhaps I'll work more on my TCP library design, later. 2019-09-14 I wrote a single line of APL today. This transforms a one-dimensional vector into a two-dimensional array where the first dimensions are the pattern and the remaining elements are spaces. It's simple and I'd decrease it to thirty-eight characters tommorow by some trivial transformations. 2019-09-18 I've written a simple little Common Lisp TCP client library that works in two implementations. It's named EASY-PEASY-TCP and it's less than one hundred lines. I'm somewhat bothered by the notion that I seem to be one of the few not wanting to work with an interface deriving from POSIX sockets. This name properly betrays the casual nature of the library. 2019-09-21 I last touched my Gopher client written in Common Lisp in the third month. Today, spurred by my TCP client and how I enjoyed that, I continued working on it. The two main functions are PARSE-MENU and PARSE-ENTRY, which together transform a Gopher menu into a list of Gopher menu entries. Now there's not much left to do, sans add some manipulation functions and other niceties. I painstakingly added restarts for every reasonably recoverable error and it's disappointing that I still find the restart and handler system a tad clunky, at least to write; it's nice enough to use programmatically and the same options being usable interactively is pleasant and allows one to do it manually until finding a good automation, but it's still not necessarily pleasant to write. An unpleasant aspect of what was done today was how I struggled through it, in a rather bored fashion, adjusting code until it worked ofttimes, rather than contributing a more critical thought to it; it was that manner of programming. 2019-09-25 I began working on the Common Lisp version of my MMC targeted at CHIP-8 again. I went past fatique, unlike previous times. This programming amounted to translating the comments I'd left for myself to macro calls and I also implemented some of these macros; I also wrote the display strings in Unicode and alternatives in the portable Common Lisp character selection, so that this program won't require any particular character set, for those display strings needing this. The 00CX, 00DX, and DXYZ need special consideration, as they don't fit the patterns particularly well, and so they've been written separately. I also reviewed and modified a reimplementation of SAVE I'd written months back using a better envisioning of how the metadata is organized. 2019-09-26 I reimplemented my READ-LIMITED-LINE as READ-STRING; the former is forty-two lines and the latter is eighteen and far more structured and high-level in approach. I'm pleased. This is a function which references no global state and, as I noticed a while back that all strings needed in my MMC have the same length, isn't even parameterized. It's amusing to have translated my quite unstructured Common Lisp to structured Ada and then translate that to structured Common Lisp. The form is a simple loop around event collection, an if to separate characters from the rest, and then a simple case on those characters to handle those controlling characters. I make nice use of fill-pointers to simplify the function and I see further ways I can easily simplify it further. I also finished the DXYZ creation routine, which is the most complex of them all, and it's nice to see it and its display routine in a high-level fashion. The DXYZ is the only instruction which hits an intended limit of my name system in that names are granular to a single byte, but DXYZ could reasonably have two in one, for register and height, and so a choice between these is demanded in that case. That alternative is unnecessary storage solely for such a case, and I'd decided a ways back that was unreasonable for such a rarity. 2019-09-27 I reimplemented my READ-INTEGER, that more complex primitive. The old implementation is ninety-five lines whereas this new is fifty-six. I wrote this in the night, just as I did with READ-STRING, and I believe I programmed mostly uninterrupted for two and some hours as I had both side-by-side slowly reimplementing part of the old in the new and then erasing it from the old. It seems it's been some time since I last programmed for hours, uninterrupted, and this experience has me wanting to do more and longer. The routine is similar to READ-STRING in several ways; I started by reimplementing only the integer collection and was able to reorganize the control flow similarly; after this it was easy to see how to add the name collection elegantly. The name collection mostly involved extracting and so copying the inner mechanisms of READ-STRING and then modifying them to suit things. Comparing to the previous implementation, the new control flow is inverted, and consists of a loop which collects characters, an if which determines which of the two modes is in effect, and then processes this in a way similar to READ-STRING; I believe I understand my own routine better now and could create a flow chart more easily were I ever to need to; it's also much less repetitive. I left that final aspect, concerning name validation, for later, and would finish it after other work with what I believe will be a better envisioning of my name system manipulation primitives. I also finished lesser routines. That other work involved StumpWM. I want my system commands to use a different history from my Lisp REPL and used the system to scour itself, greatly helped by functions which remember the source file they were defined in. At first, I thought I'd be needing to add an optional history argument across several lower routines, but I believe I've realized a simpler solution in extending commands to have an optional history field and then modifying the controlling machinery to use it. As the history is a special variable, I should be able to simply rebind it at the highest point and avoid any changing of the lower routines, which I find elegant in a way. This is work for later, however. 2019-10-01 I programmed for hours over the course of the day. I believe I started by finishing the ugly macros for generating instruction display and creation functions; these macros are somewhat poorly written, unpleasant to read, and require precisely those input characteristics I give them, but they generate what I want and are only intended to save me work, so they're fine; it's fun to debug macros through viewing their expansions. I'd also noticed some design oddities that had previously gone unnoticed, and I'd correct these along with other general improvements. My intention's saving the instructions generated by creation routines to later provide default answers, as opposed to having something else for such. I also worked on the abstract types and structures employed to good extent. I didn't use every structured idea from my Ada, but now I've a mechanism for building and displaying instructions from the more raw data. I rewrote SHOW-ROW and it went from eighty-three to thirty-three lines; the REDRAW-DISPLAY increased to fifteen, from fourteen. Perhaps oddly, I found the programming accomplished today to be noticeably unfulfilling. I'm struck by the idea that I may find myself discarding the Common Lisp I've written and returning to Ada, now with the structure I lacked. In any case, I feel I'm making good progress. I can begin writing the entries I've planned for the Octo Jam, so I may start soon. I think I'll segue back to writing Ada. 2019-10-04 I'd like to eventually write a DNS client in Common Lisp. It would be nice were a DNS service to be available at 127.0.0.1:53, which would use the operating system settings, and so make programs using DNS able to use these same settings transparently. It's my understanding this isn't common and that POSIX wants programs to use its ugly little system calls for this; that's certainly a POSIX solution to a problem; there can be simple methods for accessing system resources that make programs entirely independent of the underlying mechanisms or one can just tell everyone to use C. I began writing my Rule 30 Improved today. I'm using the left side of the screen for display and it has several advantages due to how coordinates are calculated, meaning simpler code can be used; that 0,0 coordinate in particular is nice; as I'm only drawing the first bit of the sprite now, that also creates a pleasant one-to-one mapping with the drawing logic. Hindsight from the first version made some optimizations clear and I'd usage information to know what's worthwhile as routine and whatnot. In particular, I wanted to remove conditional code for the cycling of horizontal coordinates my last version used; another nicety of the left side is these coordinates are three, two, one, and zero and so have nice binary qualities; I sought to use a decrement followed by an AND with three and figured I'd need a register solely for this; I mistakenly used register two in writing this and realized its value of 128, used for the drawing pattern, would fall into this cycle perfectly and, as it was also no longer needed at this stage, I used that register and saved space. I thought I'd use three for a key code later, but ultimately wouldn't. I didn't finish the code today, but it was 148 bytes, only eight larger than my previous implementation, despite doing much more. This was fun hacking. 2019-10-05 I tested my Rule 30 to recognize I'd made a mistake involving a jump address and also forgot a chunk for clearing the pattern array, which also has code that makes it simple to change the right pattern boundary; I'd been unable to recall precisely what was missing, beforehand. I like how I wrote that clearing chunk, as it sets I to properly before the array, loads all registers, and then stores them four times without any looping; it's the most elegant way to solve the issue. I also fixed some odd display and key issues I believe are the fault of the implementation rather than my program, such as changing the key codes of the interface to avoid spurious input. I noticed early in the day that my pattern entry code needed only one pass, not two, and making this change allowed me to remove chunks that became superfluous. I padded the program to an even size. The program is 154 bytes now and if I'd been targeting size alone I could've decreased its size by eight. This has been pleasant and is my best documenting yet. 2019-10-10 I've recently read the DNS IETF RFCs and have begun work on a DNS client in Common Lisp I've decided to name EXPROPRIATION. It would be pleasant to have Common Lisp programs only depend on such things as any network access than baroque system calls and whatnot. I chose CL-GOPHER to be the concern of my fiftieth article, today. I've experienced dissatisfaction with my work lately, not seeing beauty and whatnot in many of my programs, even though they work and well. It seems only that Ada library, the machine code, and those APL lines of mine bring me any lasting satisfaction. Every one of these is simple, obvious, and with no or clear error-handling; all but that Ada is entirely self-contained yet the Ada has an obvious error-handling strategy and so I believe that is what has me satisfied by it. It's not the ideas that cause any grief, but those implementations for machine. I can have the purest thoughts and knowledge and encode my complete understanding, but it seems if I fail to arrive at the single most optimal implementation, it dissatisfies me; in any case, I wrote a simple Rule 30 implementation in one line of APL, and this gave me such a sense of fulfillment that it knocked away these negative feelings. 2019-10-11 I made that APL Rule 30 more convenient to use with helping functions and also rewrote a good bit of APL I've previously written, along with the article documenting, to make it independent of the Index Origin and correct errors I'd then noticed. 2019-10-19 I've been using my implementation of Rule 30 in one line of APL to write a one-page article for that ``Paged Out!'' zine I've recently become aware of. I've used the largest font that would have it on a lone line, to emphasize how concise it's. In wanting my R30I function to have a larger font, I've successfully noticed ways to make it much shorter several times and have ultimately reduced its size by eight characters or so; I'd to check the standard to ensure I was making valid size optimizations and I believe I'm. I believe I finished the final revision, today. 2019-10-21 I made some improvements to my ACUTE-TERMINAL-CONTROL including using INTERNAL-TIME-UNITS-PER-SECOND for some of my timing and adding ``Page Up'', ``Page Down'', and ``Delete'' as :PAGE-UP, :PAGE-DOWN, and translation to the #\Rubout, respectively, in the event code. I've integrated this into my MMC, but have yet to make it all publicly available yet. 2019-10-30 I'd lightly entertained writing a tennis game in CHIP-8 as another Octo Jam submission, but sought a simpler game which would be simple, small, and satisfy the strictest instruction hertz requirements. Recalling a game I'd played on a cell phone some fifteen or so years back, I decided I'd implement a falling symbols game, in which the goal is to hit the corresponding key before it touches the bottom of the screen. My implementation is forty octets, nineteen instructions and two data octets, one of those two being unnecessary, but rounding to an even count. A random key is selected and drawn at a random horizontal coordinate at the top; pressing the correct key restarts the game; otherwise, that vertical coordinate is increased and whatnot before looping. In my original testing, the screen was left blank upon losing, but I rearranged some instructions to have the failing symbol remain in this case. The game could be thirty-two octets, were those four instructions comprising my delay code to be removed. I also documented the game today, of course. This was a nice hack, I think, although I dread the thought I'll only ever write small machine code programs, not that this is inherently bad; I want to work more on my MMC and write larger programs soon. 2019-11-02 I was reading to another my favorite passage from ``Alan Turing's Electronic Brain'' and this had me realize I'd not yet attempted to remove that single data octet from my falling game by treating code as data. As I only truly needed a low delay value and a zero, I found two suitable sequences that I could use, but a larger delay makes this game much less fun and adjusting the falling rate or bottom vertical coordinate makes the animation less smooth. It also becomes infeasible to modify the delay in any way. I've shown that it's possible to make my game two octets smaller, but the disadvantages don't weigh well against a two octet cost. 2019-11-06 In the preceding days I've been resuming work on my MMC targeted at CHIP-8 written in Common Lisp; I believe it's already largely in a state where I could begin testing it once I finish the prime loop. It's pleasant to be able to review a procedure I'm mulling over reimplementing and realize the other reimplementing has already removed all of its calls. I'm cleaning the interfaces rather well and my ideas of the inner workings of my tool are becoming more well-formed. I've been thinking over a new variety of functions in my ACUTE-TERMINAL-CONTROL which wouldn't allocate for a time now; I've added support for the ``Home'' and ``End'' keys as :START and :END respectively, but have still yet to add these modifications to the public release. 2019-11-07 I was knocked off the cadence of working on my MMC by other work; when trying to sleep this morning, I considered the ``Look and Say sequence'' and realized how easy it would be to implement in APL. I later noticed I'd been mulling over the reverser and not the generator, but it was neat in any case. 2019-11-11 I did lightly continue work on my MMC, in a preceding day and regarding the prime loop, yet I've yet to complete it. I wrote that trivial word count program in Ada and Common Lisp today, spurred by an article I'd read before. The Ada used Ada.Sequential_IO instantiated with that Character type; that Ada.Text_IO performs unwanted processing, making it unsuited to this. Rather than making a package, due to complications with Ada.Sequential_IO types, it's a lone program and subprogram. I believe it took me a few hours to write this and have it working, but it was good practice, I think. I wrote a Common Lisp implementation using a similarly naive approach in just a few minutes and it has no need for optimizations, which is nice. I of course put these two programs to separate articles. 2019-11-18 I imagined myself having a discussion regarding how higher languages are more capable of using lower systems than a similarly lower system is. I also considered those lower systems which are so poorly designed and malformed that this isn't true. A logical count primitive is a good lower system and I realized I'd never written this in APL and so did so. My implementation behaves as a typical scalar monadic function and it was good practice, reminding me of some APL tricks I'd forgotten. 2019-11-26 I properly started work on a SHA package in Ada, beginning that with SHA1. I'd given decent time to mulling over an idealized interface for this; reading the IETF RFC necessarily changed some details; I decided to use my own integer and array types for this. I like the idea of transforming the state used for partial hashing into that final digest, even though this is actually the same data, so this is enforced by the design. The initial status is expressed as a constant and there are function and procedure varieties for partial hashing, based on whether the initial partial hash should be treated differently or not; there's a full hashing procedure for the case where the data fits in the memory. I also lightly started work on the Common Lisp SHA1 code, and I'll likely just use a BIGNUM for that status and whatnot; I make fewer harder decisions with the Common Lisp, certainly. 2019-11-30 Over these preceding days I've continued with my SHA1 implementations, making the most progress with the APL, as it's the most concise and that which I need worry over least with regards to the details of the interface it exposes; that's certainly an advantage of APL that's become more apparent to me. 2019-12-06 I've continued working on my SHA1 implementations and other things, finishing with the APL today. I should work to improve my APL hacking, as it's that language I struggle with most; I usually do know the precise transformations I need, but struggle to express these and practically must use the REPL. I should review the standard and practice more, so that I slowly gain my independence from such. My stupor even had me organizing two vectors into an array to reduce with addition, until a late review had me realize using addition directly would achieve the same, as it's one of those dyadic primitive scalar functions. In any case, it was good hacking that gained me valuable experience and it should make my other SHA1 implementations easier to finish. The APL version operates on bit vectors unlike the others I've planned. 2019-12-10 I've decided on using a dual-buffer approach for my Ada SHA1.Pad procedure, as this approach is that which is least error-prone and the cost of the otherwise unnecessary buffer isn't so very great; I'm of the opinion my Ada implementation will easily be the best, considering the great thought I've put into it. I decided that my implementations should all use different core units and so this fixes an issue I'd been having with Common Lisp, which will merely focus on octets. 2019-12-11 The Ada has been simplified by only dealing in words, being repetitive otherwise; with the exception of SHA1.Pad, I've also made the naming scheme entirely uniform, which is nice. My urge to do so and also have natural alignment had me name all Digest parameters Datum, rather than Data, which is good and all that was needed. 2019-12-12 I finished my Ada SHA1 today and this was the first time I'd ever needed to use GDB. The first flaw was, as with my APL, in the little-checked display code. Using GDB was roughly half of what an REPL gives me and was leagues more convenient than the stupid option of showing internal state hard-coded and so manually; I learned more constraints regarding what I can use in aggregates and had to change some of the SHA1.Hash returning Digest machinery in order to support this. I've still yet to verify the program in more detail. I'm a better Ada programmer than before I wrote this. 2019-12-19 I reviewed my Ada SHA1 and was elated to find everything correct, sans a lone edge case in SHA1.PAD. The Bit_Length mod 512 being zero case makes what I recognize is a mistaken assumption; effectively, it communicates block N-1 is to be used verbatim and for the Auxiliary block to receive all padding, yet this fails in that sole case of a zero Bit_Length, as there's no preceding block and the Primary should receive all padding the Auxiliary would; I handled this explicitly, with an early return that falls into the other cases, otherwise. This was fun to discover and it was noticed without testing. 2019-12-22 I rather finalized the design for my Common Lisp SHA1, heavily influenced by the Ada, and using CLOS to achieve similar overloading. My SHA1:PAD will nicely make use of multiple return values. 2019-12-25 I finished my Common Lisp SHA1 today and, as SHA1 isn't amenable to debugging by staring, I bothered to sort out my CL:STEP issues and got that working suitable to find the issue. I gave my GNU system SHA1 a message ending in octet two hundred and it gave a digest which disagreed with my versions and a different system SHA1, but the flaw has apparently been corrected in later versions and so I can't report it; it's almost a shame, but it shouldn't have had such a flaw anyway. 2019-12-28 I wrote a delightfully different pad function for my APL SHA1; the basic logic is unconditional, and the only conditional behaviour is in shaping intermediate zero padding and the final result, being a 512 vector or 2 512 matrix. I spent longer on this than I'd prefer to admit, as I didn't want to be bothered with thought for the zero padding logic, but I eventually verified all other pieces of that line and then solving that was simple, merely requiring some thought and then some refactoring so it would be more brief. The constants used betray those other two pad functions, but it's still nicely different. 2020-01-23 I wrote the remaining name functions of the reimplementation of my MMC targeted at CHIP-8. I've now only the prime loop and some other rather independent functionality to rewrite before I can begin in testing and using my reimplementation, which is nice. I've a better idea of its organization, since this has been taking Meta-CHIP-8 routines, those littered with global variables, and other such code and rewriting it in a far more structured manner. I'll also need to write some interactive variants of some functions, but this will be trivial. 2020-02-02 I began work on a Forth implementation of SHA1, but predictably grew bored when implementing the pad word and decided to let it languish, with the K and F functions implemented along with half or so of the necessary pad subwords written. Forth has influenced my thinking and yet I don't use it; it may be that writing Forth correctly and concisely is so exhausting compared to other languages that such programming quickly becomes tiresome. 2020-02-16 I began work on implementing SHA224, SHA256, SHA384, and SHA512 in APL. As with my SHA1, the chosen unit is the bit vector, and this made the CH, MAJ, BSIG0, BSIG1, SSIG0, and SSIG1 machinery generic. I'm pleased with the seemingly prescient aspect of my Ada design, distinguishing Status, Digest, and To_Digest; this was unnecessary for SHA1, but needed for these four, and my design accomodates this. 2020-02-20 I mostly finished my SHA224 and SHA256 in APL; the latter pair would be a simple parameterization of the hash function, but I declined to do this for now, leaving it to later. Unfortunately, there's a flaw in it I've yet to correct, due to my lack of familiarity with the APL debugger facility. 2020-02-26 I started to implement SHA224 and SHA256 in Common Lisp, having mulled over a nice CLOS message set. The idea is to have the machinery specialized on the structure holding the data and have it make use of the block hashing function, which would be specialized elsewhere, enabled by other messages, such as one to collect the block size. It follows rather naturally from my SHA1, and it's all rewritten. 2020-02-27 I continued from yesterday. I'm pleased with my STREAM method of my HASH generic function; I worked by referencing the SHA1 implementation, and needed to recall precisely what the hack described there was; the SHA1 implementation would use a read block before checking if it was the final block, which would lead to issues when the message size was divided perfectly by the block size, and so that hack involved working around that case for handling the final block, which is a suboptimal method to use. Since I was already preallocating a second block for PAD, I could use it as a store for the purpose. I spent too long rewriting the loop, trying to make it look as nice as I could, but this did lead to a nicer and distinguished pre-loop form, by using an alternate I'd recognized during this rewriting. 2020-02-29 I continued my work on the Common Lisp, focusing on PAD now. This newer, generic SHA implementation is going much better than the SHA1, so far. 2020-03-02 I worked on the Common Lisp CH, MAJ, BSIG0, BSIG1, SSIG0, and SSIG1, but they're not as pleasant nor as generic as the APL; for the latter four, I'll need two versions for the thirty-two and sixty-four bit lengths, and these should really be defined with a single macro, anyway. I continued work on my BLOCKHASH as well, making extensive use of reader macros in the latter half; it's been good hacking. 2020-03-07 I corrected my SHA224 and SHA256 in APL. I didn't need to use the debugging tools, but merely focus when revisiting it. I read the hash function with a fresh mind and noticed I collected a single bit instead of thirty-two in one location, which was causing the length error; I continued and noticed a failure to convert a bit vector for an addition, and the final line which converts internal state to the return value was overly complicated and perhaps flawed, and so was also corrected. 2020-03-12 I wanted to have my Common Lisp SHA224 and SHA256 finished today, but lazily pushed it further back. Lately I've been reviewing its CLOS protocol and integral functions. I've finished a new version of the PAD function which isn't rule-based, and so less conditional, but haven't verified it yet. I've realized a nice method to have the DIGEST function simple, by having those members which need it use a :BEFORE method which will DECF the FILL-POINTER of their STATUS, but this requires accomodation in some places. I've also revised my CLOS protocol to have a single STATUS class which the others use. 2020-03-16 I tested my SHA224 and SHA256 BLOCKHASH first with an all-zero block, receiving an incorrect digest. The octet translation code couldn't've been the issue, but I reviewed it anyway, finding it fine. I realized I was misusing a function on the entire sum for the buffer-filling segment, instead of with a single previous buffer element to then be summed, but it still didn't work. The last error was my using SEVENTH instead of EIGHTH, as I'm not using the single-letter names of the formal description. 2020-03-18 My Common Lisp SHA224 and SHA256 was in a state ready for a release on par with the others. Methods for LIST and VECTOR aren't ready. I tested my PAD and noticed errors; it was pleasant to fix in the REPL, sparing me from giving it much thought for now. It's still too slow for practical purposes; I think COMPUTE-APPLICABLE-METHODS should be a suitable mechanism to remove the dispatching in a loop. 2020-03-22 I revisited my Common Lisp SHA224 and SHA256 to realize my DECF trick is invalid if done repeatedly, so it was changed to SETF to seven. Since BLOCKHASH ignores FILL-POINTERs, I realized I could avoid :BEFORE methods by setting the FILL-POINTER at the start. DIGEST will avoid modifying its argument. 2020-03-28 I wrote a DEFXROTR macro to replace the manual implementations of B0, B1, S0, and S1; this was easy. I noticed and employed a neat little trick to save part of a backquoted expression with #N= and #N#. 2020-04-02 I reorganized the CLOS hierarchy for my SHA. I've made SHA224 a descendent of SHA256, and SHA384 of SHA512, which gives the desired behaviour implicitly and the hierarchy true meaning. Another change had me realize I was being miserly with symbols. I dislike symbols used only for argument names and whatnot and conflated this loathing with any rarely used symbol, such as internal macros or routine. I repeated myself again and saw several uses of a pattern. I decided to see how a macro would fare, and it roughly halved the already brief segment. I added a small type definition, and now some code fit on fewer lines. My thinking was fine in the micro and poor in the macro. I decided to raise my tolerance to these symbols and see how it suits me. How silly, for me to not notice so, beforehand. 2020-04-07 I revisited thoughts concerning efficient and concise multiplication in CHIP-8, spurred by my seeing a similar machine code article and deciding it wasn't too insignificant for such. As BLOCKHASH will now modify its STATUS argument, the code is simplified and smaller, and I was able to reuse the main loop exactly by using SYMBOL-MACROLET, so it would still be pleasant; I wonder if I would've thought of this, had I not been rewriting it. Refinement is perhaps the best programming, not writing anew. 2020-04-12 I continued work on my SHA, now in DEFBLOCKHASH. I noticed an expansion thereof generated incorrect digests and, amusingly, the flaw was in the octet translation code, unlike the time prior. I didn't suspect it until after several hours or so of comparing my previous, working implementation with it. 2020-04-16 Having continued with work on this, it was in a suitable state for release today. I'd an issue with forgetting FILL-POINTER details, but solved it during a break. A flaw in my DEFBLOCKHASH had SHA512 digests partially filled with erroneous zeroes, as I'd forgotten to parameterize that final segment. Fortunately, my testing data needed one hash, which ensured this didn't cascade down into obscurity. 2020-04-22 I've been improving and correcting my SHA; it's unacceptably slow. Another couldn't compile it with SBCL and I corrected this: DEFCONSTANT begrudgingly became DEFVAR, as classes may not be present for compilation; another change would fail if an array lacked a FILL-POINTER, which is simple to correct with ARRAY-HAS-FILL-POINTER-P; and better speed lead to testing on larger data and had me notice I'd erroneously conflated edge cases in PAD, causing a one-octet flaw that, to its credit, resulted in a different digest; it's still slow. I may later pursue my alternate SHA design which is more static. 2020-04-25 I feel silly, for not recalling sooner EVAL-WHEN exists to ensure things be present for compilation. 2020-04-30 I've been working on my comprehensive Ada SHA library lately. The package specifications are rather nicely commented and whatnot. I hit a barrier with sharing across package boundaries, and I may see each child package of SHA be a mere skeleton renaming generic instantiations of its parent, instead. I'm seeing issues with my current approach, involving heavy generic instantiations using the others. 2020-05-05 I've worked on my APL SHA the past few days. The four sigma functions of the prior SHA256 have been rewritten to properly use the primitives and only reference the parameters once, suitable to inline. I feel silly, as I rewrite this code and notice all of the glaring inefficiencies. I worked hard to have it released today, and it's pleasant. The new SHA1 code has been greatly simplified; the K and F both use a single line each, taking proper advantage of repetition in array creation, with F being a vector of strings to evaluate. Sans header and footer, the SHA1 hash is four lines, the inner two being loops, and I'm so pleased with it; that second line for the W schedule creation is simple, and the third is similarly trivial. My APL still needs to improve, but I'm so much better than before I started using it much. Once again, some of the best hacking was in rewriting, not in pure creation. 2020-05-11 Disappointment with how the current state of my MMC will have me perhaps wastefully write a program, notice inefficiencies, and then rewrite it to correct such, rather than having these steps combined, inspired me to resume working on it. The main loop is still unfinished, but I corrected errors as I loaded, until it properly ran for the first time. Traversal works, so I can start adding to it now. 2020-05-13 More work on my MMC corrected minor errors, and revealed some amusing mistakes. I wrote a malformed COND in PRIME which tried to evaluate T as a function after its arguments, yet complex control flow, isolated testing, and other things hid this for a long while. The MMC is growing to more usability. 2020-05-18 Recent improvements involve the MMC display; the memory space no longer wraps, requiring cooperation between REDRAW-DISPLAY, UP, and DOWN, with the latter two merely restricting movement on either end. I noticed errors when testing with address zero, discovered to be an error with LOG of zero in READ- INTEGER; I was unaware zero wasn't allowed there, and this required a special case, with a different attempt to correct it using 1+ revealing another edge case involving address one; with both changes, the routine now displays such cases correctly; how poor of me to have made this mistake. Amusingly, the older version of the code merely used PRINC-TO-STRING and LENGTH, and was never incorrect there. The last major improvement involves largely eliminating flicker by avoiding erasing the screen prior to redraw. As each line is already erased, there was no point, and the uniformity of this interface works well to hide the redrawing. A final code handles the wrapping edge case. What a nice change. 2020-05-20 I resumed my Ada SHA work, deciding I should write a purely SHA256 version first as with the others. I still salvaged from my SHA, making concrete from generic, and am particularly pleased with my PAD, which is still generic for varying units. In enforcing length granularity by unit, every case is as simple as the binary case. To make Digest conversion to Strings and Bits simple, I use a To_Nibbles function, which has a one-to-one mapping with a String, and makes the Bits case simple to enumerate. 2020-05-25 I continued work on the Ada SHA256, but didn't finish it today. By now, everything is finished, but minor differences between my mental mapping of the language and reality caused many compiler errors. I made myself sick trying to meet the deadline today, so I'm taking another break from this for now. 2020-05-31 I leisurely worked on a ball breaker game in CHIP-8, but didn't finish it. I learned some tricks in writing and rewriting it, trying to compress it. It's easiest to have the paddle on the penultimate row, leaving that final row for miss checking; two trivial conditions are far simpler than a single, slightly more complex condition. The game just barely didn't work, and so I suppose the simple core I envisioned around predicated redrawing wasn't actually so simple; I'll try to find a simpler core. 2020-06-01 In reading an old APL idiom document, I found scanning or was the idiom needed to finish a generator for the ``Look and Say sequence'' I've been wanting to finish; it uses an explicit loop and is nice. 2020-06-02 I yearn to program daily, even making only minor progress, rather than wait for both inspiration and motivation to strike me and bring about an hours-long hacking session; know I'll not note every day. I resumed work on the prime loop of my MMC reimplementation, regarding instruction depositing. Now, I can write instruction sequences; it's been so long I must make the system agree on representation. 2020-06-11 By now, the instruction clearing command is finished and I can write several different instructions. I've the improved prime loop to save previous answers to work as defaults. My macros have improved. 2020-06-15 Now I can write all CHIP-8 instructions with my MMC, updating more internal representations in this. Today, I greatly improved the REDRAW-DISPLAY and SHOW-ROW, hiding the cursor, erasing that remaining line only after writing anew, and now the flicker is rather entirely eliminated; redisplay is cheap. 2020-06-17 I've started work on the name-manipulation commands now. Despite testing at the REPL upon errors, I skillfully overlooked that an array slot of a STRUCT was mistakenly being set to a valid element. I failed to properly debug, despite having given it careful thought beforehand, misreading the element as the entire array, because I didn't expect that was the error, not seeing what was truly there. I resolve to improve my debugging prowess and, with the horrible practice in mind from this, won't use the foolish ``print debugging'' ever again. I'll always use my tools properly and well, to improve. 2020-06-22 I realized a macro for writing special commands and whatnot was good; I should've recognized sooner. The name commands are mostly finished by now; I've changed the CATCHes and THROWs to use SIGNALs and handlers, with the disadvantage of creating CONDITIONs, but the advantage of easier use than THROWs. 2020-06-26 The interactive SAVE command is now properly hooked up and works fine; I should have an easy go with writing the INSTATE functionality; with today in particular, I finished the mouse command machinery. 2020-06-27 A mistake found when testing happened to be due to a typo in some of the name-manipulation commands. This revealed a deeper flaw of those commands not using the proper representation for lack of a name and I decided to add type declarations to all of the STRUCTs in the system to prevent such mistakes. I noticed, with a different terminal, colors weren't reset correctly between questions; I corrected. 2020-06-30 Now my MMC reimplementation is nearly equivalent in features to the prior version, which is so nice. Today I worked on a game concept I named ``Enchantment'', involving avoiding lines as they're drawn, as a pixel. The game needs more line variety, including intelligent, that I'll add in the Octo Jam. 2020-07-04 Now insertion and deletion work. Outside of the sole exception of instate, the reimplementation now matches that prior in features; I've been fixing miscellaneous flaws, such as instruction depositing hitting an edge case in the system I'll need to correct using tomorrow. This is such pleasant work. 2020-07-07 I released my reimplementation of my MMC targeted at CHIP-8 on the third anniversary of the article, finishing with several important details; whilst documenting, I realized an oddity with the 00CX and 00DX display routines, they didn't show associated names, and corrected this rather than documenting this flaw, as a proper programmer should. The INSTATE, MOVE, and some name commands are unfinished. 2020-07-10 I wrote two implementations of Fizzbuzz in APL using the simplest way of simply setting multiples of fifteen thrice; these differ in starting place and whatnot. I'd resumed working on that Ada SHA256. 2020-07-17 I've by now corrected several minor flaws in my MMC, including omitted name assocation code, display mistakes, a minor maximum value, along with miscellaneous tasks. I'm still adjusting my Ada SHA256. I modified the Generic_Pad of my Ada SHA256 to use an if, elsif, and else chain, rather than a case. I'd foolishly struggled to write this by case, until realizing my difficulty meant it wasn't suited. 2020-07-23 I finished that VECTOR method of my Common Lisp SHA; I'd a misconception in how ADJUST-ARRAY worked, requiring a :DISPLACED-TO, each use. Despite my improved debugging prowess, I still fell to a minor mistake in testing the vector and equivalent data, having a difference of one octet; recognizing the mistake took longer than I would've preferred. Debugging hash checksum code can be so very arduous. By now, my Ada SHA256 has one type of compiler error remaining, the ``instantiation body conflict''. I'd to manually convert a Unit_Array slice to the Unit_Block subtype in my Generic_Pad, being simple enough to notice and correct, but queer to have been needed. The design of the INSTATE of my MMC is going nicely; I've decided to use CERROR for all or most error signalling, making it nicer to debug. 2020-07-28 I released my Ada SHA256. I asked another if using renamings would solve my generics woes, learning they would, as expected. I changed the Pad length parameter name to include its unit name directly, rather than use Unit_Length, as the cost of renaming was then certain. I corrected flaws including: a ``duplicate body'' error which was truly an error, due to my mistaking one of the Hash subprograms for another; indexing a mistaken array in To_Octets; and it required I see that intermediate padding from my Common Lisp implementation to recognize I failed to multiply the unit length by its size. I was glad to have tested the zero-length message and uncover an error in that; a range checking error revealed my carefully-crafted calculation to adjust a zero-based type to a one-based would fail with zero, as I was using the conversion as implicit parentheses for ordering, and I'd overlooked that it would fail within the conversion, requiring I increment before converting. It's so easy to mistake. 2020-07-31 I decided it was too difficult to write a version of INSTATE, which doesn't allocate. Instead, I'll write a basic version of this loader which performs validation and basic instatement. I've recently started writing another CHIP-8 game I've named ``Asphyxiation'', based loosely on the Atari VCS game ``Entombed'', having read a nice paper detailing its maze generation; there have been interferences. 2020-08-02 I recognize I still do far too much work the machine should instead be doing. I've decided to begin working towards improving the automation of my machines. I particularly need to improve with email. 2020-08-04 I've continued working on my CHIP-8 game; its maze generation is mere queer one-dimensional cellular automaton, which can be done in-place, to simplify matters. I've decided to implement the mirroring behaviour and use large segments for the maze, leaving plenty I can improve later. A ``make break'' can simply draw directly to the screen, then being trivial to implement, and will actually be better than the Atari VCS version, as it won't mirror. There was an issue in needing an indirect call, yet CHIP-8 only provides an indirect jump; my solution was to write a routine with such. I stopped upon noticing, to my horrible dread, a flaw in the name updating system involving insertion and deletion. 2020-08-05 I noticed that error could only be in CHANGE-NAME, as both INSERT and DELETE, while by now decrepit, didn't seem to contain any flaws. The CHANGE-NAME performs a minor label normalization, ensuring no other label with the same value exists, and therein was the source of this error. The normalization should only occur after all labels have been shifted, lest the internal ordering cause issues in one direction. I placed this normalization into its own function, and CHANGE-NAME is called in but four locations. I'm relieved the error is vanquished, but I'll need to finish INSTATE before continuing. 2020-08-11 I've by now fiddled with that basic ONLY-INSTATE variant of INSTATE to the point it works. It still needs hooking up, and to validate invariants. It debugs well enough, with CERRORs in place, and the primary corrections involved simple flaws, such as mistaking a return value from a function; I hand- wrote a metadata file I knew was correct, realizing my suspicions of SAVE producing invalid outputs, lacking the terminating zero octet. I've also finally improved my Ada environment to switch _ and - and so spare my hands. I couldn't determine how to properly change that, as it kept reinstating old settings. My final solution was to make a local copy of the file and modify that directly, instead. 2020-08-12 I chose to improve the display of my MMC, as a reprieve. I envisioned the space occupied by cursor, filled with symbols indicating names were being used, potentially using one of several symbols; this was so ugly and disgusting to me that I refuse to do it. The empty column is pleasing, and an ethos of my MMC is the abandonment of unnecessary naming, not only most, and those symbols constitute such naming. The hexadecimal display now uses underlining to indicate name associations, and it looks so nice. The hacking went well with what SHOW-ROW already was. I wrote the octet case first, this was much of what was needed, being a four-case ECASE on the association; I split it into a function, and noticed the hextet case didn't need nested and repetitive ECASEs, but could use what already existed for octet. The latter octet association is switched to octet, if preceded by an address, or hextet. In testing, I realized the single octet case also needs this transformation. I was going to default to bold, but decided on underlining. It's easier to see, and already used elsewhere in the display. 2020-08-15 I've now hooked up ONLY-INSTATE properly, in a way allowing continuing and whatnot. Considering the prior MMC was rather incapable of metadata validation, it's now truly equivalent in features. Now I may use it more effectively and also start adding the greater commands I've wanted for a ways. This code really shouldn't've been necessary, using a better environment, but I won't let such sadden me. 2020-08-19 I spent on the order of eight hours or so fighting with Emacs gnus in one day, combined with reading its manual; I wanted to use gnus as an RSS reader, and G R is the chord bound to adding such a feed, but I was unable to learn how to automate this. Manually setting variables had no effect, functions for importing OPML files were still interactive in nature, and extracting the body of the feed adder was unsuccessful; it's easily the most unpleasant and confusing Emacs experience I've ever suffered. 2021-05-01 I began work towards realizing mine early English Elision with Ada, because the idea seemed so clear to me. Ada is the most exhausting language I know, because it exposes what I've not given enough of my thinking to, even in the package specifications. The memory management was complex to mull over. I realized some of the same unpleasantries of my design the Lisp exhibited, and I should instead use APL. It was nice using my chorded keyboard and trackball for this, programming with the Emacs menu. 2021-05-13 Having used APL for Elision earlier had me realize it was delightfully trivial, but so much so there was little point in continuing before I'd a dictionary to use, as expected but ignored, and also how the auxiliary dictionary translation table is just APL's grade function, providing a good base; I've trivially implemented it in Common Lisp, using :KEY indirection with SORT, but a similarly lazy path with Ada will likely be infeasible or much more difficult. I split the Ada into a Grade and an Iota to find it seemed Ada resisted this by making me introduce more types, but I needed them regardless. 2021-05-20 How poor that I've not updated this in nine months. I may write the entries for the interim, later. .