Today's going to be a grab bag, because why not?
------
I not-so-recently revamped how I provided access to the Python source patches to make them work on Cygwin. I used to provide a lot more versions than what I have now, but did away with all that because of some recent fast updates from the Python Foundation with respect to fixing up the Python interpreter for all the new exploits that are coming at a geometric rate. Realistically with Python 3.14 series of patches, we won't need to worry about this for quite a while, and all the older patch-releases are just garbage anyway, so keeping them is really bad in terms of presentation; and thus, I chucked it all out.
On a semi-related note, I did a bit more tweaking with my 5×10 and 7×13 pixel fonts. With the help of GPT-6, I've discovered some irregularities with the corresponding .fd source files, and have fixed them (nothing too nefarious---it was silly things like not-quite-correct numbers of rows, or wrong widths for the text-based bitmap definitions), which I then fixed.
The other thing I did was to also do some tweaks between the two font faces so that they look like they might be from the same family (they sort of are). This was where I discovered an important principle that I don't think that I had explicitly made a note of: at smaller and smaller grid sizes, the relative position of a symbol can be more discriminative than one might expect. The particular situation where this turned up was with respect to , versus ., and ; versus :. In the old set up, they were sharing the same ``top height'' for the first active pixel for 7×13; I then updated the 5×10 to match that since that one had the , and ; actually sitting one pixel lower. After I did the change, I immediately regretted it---it was damn bloody impossible to determine ,/. or ;/: when they were next to each other. This was not so obvious most of the time only because the contextual clues often meant that it was usually the case that one of the two characters are more likely to show up than the other, for instance, if I were writing a C/C++ program, it was highly unlikely that : would be showing up. Putting them back to back though, it was obviously harder to tell apart.
And one of the core principles behind these custom tiny pixel fonts was to ensure that characters can be easily told apart from each other.
I reverted the change, and made the 7×13 one now have that funny different in height. I also updated the 5×10 font to use the much more aggressive { and } characters that I first saw in Intel One Mono.
...which naturally segues into the other thing that I had done with my website---I updated the Intel One Mono font there with the latest release. I don't think that the new features in this release are directly relevant to what I have, but it usually never hurts to update things where available. I know that GNU Unifont has a new version that supports Unicode 18+, but ah... the update of that is substantially more involved, what with the need to break up the .woff2 files into different blocks to reduce the download of too big a file when only a small number of glyphs are used.
------
I've been experimenting on and off with GPT-6 these days, getting it to tackle some hobbyist programming tasks that I wanted to do, but knew that it was too tedious to actually spend time doing them. Among the first was revamping the machine player's capability to the Game of Boxes, an old pencil-and-paper game that I enjoyed playing when I was a kid some decades ago. GPT-6 took a really ramshackle machine-playing algorithm and build it up to something that would actually make me sweat hard when playing it. It did so through iterating [very quickly] on the various strategies that I thought was interesting but found too tedious to code, and it was definitely an interesting hybrid approach to programming.
Another project I worked on with GPT-6 was the fixing of a very old (circa 2002) QBasic graphics library I wrote called FMODEX.BAS. The key idea was to make use of mode 12h, the highest resolution available in QBasic at that time with a whopping 640×480 resolution together with a RGGB 2×2 super-pixel dithering scheme combined with tasteful selection of 16-colour attributes out of the 262,144 possible colours available from VGA hardware (6-bit per channel of RGB), to create an effective 320×240 display with 6×11×6=396 colours, which has more colours than the classic mode 13h screen, more pixels (320×240 versus 320×200), not to mention also providing a more ``natural'' colour specification abstraction via RGB channels than the more complicated 256-colour attributes scheme used in mode 13h (this one encodes first the traditional 16-colour attribute scheme using 1-bit colour channels (16), then a grayscale ramp (16), followed by a colour cube for the remaining colours (too lazy to figure out how that works out for this post)).
The main issue that I had was that for some reason, I wasn't getting the correct green levels. The green channel had twice as many pixels per super pixel than the red and blue channels, and by right, it should have better gradation, but I wasn't getting it. Worse, it was uneven enough that I was getting green tinges at high enough saturation of the green channel too, which pissed me off some 24 years ago.
And GPT-6 solved it for me. Check out the after renders for RGB versus CMY.Wonderful isn't it? No point showing the before, because it was just dumb.
``But MT, why? Why such a stupid useless library?''
Because, believe it or not, doing such small projects of uselessness is one of the best ways to learn something inside out. I mean, is it useful? Hell no. But is it fun? Yes while I was doing it to learn something, in this case I was learning a lot about VGA registers, the math for fast low-level primitives of things like straight lines and circles (hi Bresenham!), Bezier curves, ways to exploit the provided QBasic regular mode 12h drawing primitives to speed up what runs in the interpreter (like using bit masks to draw four lines using the high-speed primitives to draw a super-pixel line).
Such energy is also part of the reason of one of the latest projects that I was smacking with GPT-6---the arbitrary precision uncertainty-aware propagation math library. The core tenet is based on what I had learnt from experimental physics a long time ago---each measurement has its own uncertainty, measurements should not be reported at a higher precision than what their uncertainty can show, and assuming that uncertainties are independent and first order, we can propagate them throughout computations through careful use of the Euclidean norm over the first order partial derivatives.
Now to be clear, I had written all these stuff a long while back, roughly when I first added the masses to my music instruments page. The role that GPT-6 played in this endeavour was improving the code base, and extending the math library to be more robust in the face of increasing nonsense that I was throwing at it.
For starters, it improved the differentiation needed through implementing dual numbers, something that I had learnt of recently through a Numberphile video---this was a project that I wanted to start earlier, separately from the uncertainty propagation, as an extension of Python's Decimal class---this was in lieu of the then central/left/right difference methods that I had implemented before. Then it added a decorator to provide analytical derivatives to improve the accuracy of the error propagation mechanism through reducing uncertainty propagation from the numerical methods.
After that was a steady drive under my probing/prodding/egging to update my Maclaurin/Taylor expansions of various functions to be faster and more accurate, before culminating into implementing some seriously difficult libm functions (staring at you, lgamma()!).
It was a fruitful cooperation. GPT-6 was damn good at coming up with various approaches the way a technically inclined hyperfocused individual could, but that could not move things without my constant cussing it out for spending stupendous efforts on doing something really useless. It got to the point that our ln() function was effectively faster than the built in ln() function, which tickles me to no end. Between GPT-6 and I, we've gotten this error-propagating arbitrary precision math library to complete computations for most of its functions (at 10,000-digit precision) to be at most tens of seconds. Some of the cranky things that GPT-6 did that I would take time to do include:
- Schema-respecting, lazy tangent number on-disk caching system;
- Creating deliberate branches for special cases;
- Much tighter domain checks before expensive computations are done;
- Using heavily [mathematically] refactored terms in the Maclaurin/Taylor series to speed things up; and
- Try all versions of asymptotic expansions that may work better.
``But MT, mpmath exists, so why are you wasting time?''
Again, the part of learning by doing overrides whether something ``has been done before'' or not. Yes, I end up with a nice math library that is also capable of propagating uncertainty, but the real value of this entire exercise is the literal experience on the limits/abilities of GPT-6 using a pure chat-only interface.
Will I release this library? At this point, I'm not sure. Unlike FMODEX.BAS, which is clearly a useless museum piece at this point, this library might actually be useful to someone out there. Yet at some fundamental level, since it has a lot of GPT-6 generated code, is it truly my code to release, despite me being the progenitor of the idea to do this entire nonsense in the first place? I don't know just yet.
That all said and done, GPT-6 (and by extension, some of the larger language models that one can have access to) is pretty useful as a tool. It appears smart, a tad smarmy, and has the level of hyperfocus that I would normally attribute to the carefree fourteen-year-old archetype in my usual preaching. But it is not exactly great at direction---it still needs a firm enough hand to point its energies in the direction to proceed. I have not gone down the path of orchestrating agents to do work, mostly because I still do not trust the full delegation of direction and decision-making to these tools just yet, and partly because I have not created the necessary conditions where an ``agentic approach'' is preferable over me using the LLMs solely as standalone-ish tools. I still think that at some fundamental level, we should be having more locally-run LLMs to allow better peering into the metaphoric minds of these tools, as well as having better resilience against when the LLM-providing companies will start turning the thumbscrews once they have a monopoly.
Will I then make it a policy to ``simi sai also AI''? No; I'd never take any single tool and claim it as the one universal thing that everyone needs to use, my job notwithstanding. ``The best tool for the job, if possible, or just a good enough tool for the job where applicable''---that is my motto.
------
And that's about all I want to talk about for now. We're already going past the usual 800-word length (it's about 1.9k+ according to Q10), and I think as a blog in a modern era, this is too damned long. Till the next update then.v



