Change to log/journal style.

4 files changed, 53 insertions, 203 deletions

diff --git a/_log/matrix-digital-rain.md b/_log/matrix-digital-rain.md
index b97bb7a..d4ea301 100644
--- a/_log/matrix-digital-rain.md
+++ b/_log/matrix-digital-rain.md
@@ -1,146 +1,45 @@
 ---
-title: Recreating the Matrix rain with ANSI escape sequences
+title: 'Matrix Rain: 2025 refactor'
 date: 2025-12-21
 layout: post
 project: true
 thumbnail: thumb_sm.png
 ---
 
-My 2022 implementation of the Matrix rain had too many loose ends. Unicode
-support was inflexible: the character set had to be a single contiguous block
-with no way to mix ASCII with something like Katakana; Phosphor decay level was
-stored in a dedicated array--still don't understand why I did that when I had
-already used bit-packing for the RGB channels; The algorithm was difficult to
-decipher. The 2022 version worked, but that’s not the same thing as correct.
+Fixed the Unicode issue finally. Can now mix ASCII + Katakana.
 
-I began by placing the decay factor in the LSB of the 4-byte RGB value. The PD
-value plays a somewhat analogous role to an alpha channel in that both
-influence transparency. However, they work very differently. So, I avoided
-labelling it A so as not to cause confusion:
+Took me 2 hours to decipher how this even works. For future me: mat.col[]
+stores shuffled column indices, mat.row[] tracks last updated row per column.
+shuffle() randomizes the working set, index i (line 333) and lines 364-370 draw
+one column at a time, swap() rotates columns in and out. That's the rain.
 
-```
-enum {
-    R,  /* Red   */
-    G,  /* Green */
-    B,  /* Blue  */ 
-    PD  /* Phosphor decay level */
-};
+Moved Phosphor decay level into the LSB of the RGB union - should've done this
+in 2022 instead of separate array. WTF was I thinking? 
 
-typedef union color_tag {
-    uint32_t value;
-    unsigned char color[4];
-} color;
-```
+Keeping the RGB/PD union as it is. I know the 'portability' nerds hate it, but
+I’m on a little-endian machine, and I’m the only one reading this. It’s
+cleaner.
 
-The decision to use union over more portable bit twiddling was made three years
-ago, as I recall, for readability. Seeing as all my systems are little-endian,
-this is unlikely to cause any trouble. Besides, if union is never to be used,
-why is it in the language anyway?
+New charset array works. UNICODE(min, max) macro packs the range into uint64.
+insert_code() picks random block, unpacks it, and picks random char. Elegant.
 
-The blend() function, which emulates the dim afterglow of Phosphor by eroding
-the RGB channels towards the background, with minor refactoring, remains as
-elegant as it did three years ago:
-
-```
-#define DECAY_MPLIER  2
-
-static inline void blend(matrix *mat,
-    size_t row, size_t col)
-{
-    unsigned char *color;
-
-    color = mat->rgb[index(mat, row, col)].color;
-    color[R] = color[R] - (color[R] - RGB_BG_RED) / DECAY_MPLIER;
-    color[G] = color[G] - (color[G] - RGB_BG_GRN) / DECAY_MPLIER;
-    color[B] = color[B] - (color[B] - RGB_BG_BLU) / DECAY_MPLIER;
-}
-```
-
-While the memory inefficiency of Phosphor decay was a technical oversight I
-hadn't noticed, the limitation around mixing nonadjacent Unicode blocks was a
-nagging concern even three years ago. So, a fix was long overdue.
-
-In the new version, I introduced an array that enables a user to add as
-many Unicode blocks as they want. The insert_code() function picks a block
-from it at random, and then picks a character from that block at random:
-
-```
-#define UNICODE(min, max)  (((uint64_t)max << 32) | min)
-
-static uint64_t glyphs[] = {
-    UNICODE(0x0021, 0x007E), /* ASCII */
-    UNICODE(0xFF65, 0xFF9F), /* Half-width Katakana */
-};
-
-static uint8_t glyphlen = (sizeof glyphs) / (sizeof glyphs[0]);
-
-static inline void insert_code(matrix *mat,
-    size_t row, size_t col) 
-{
-    uint64_t block;
-    uint32_t unicode_min, unicode_max;
-
-    block = glyphs[(rand() % glyphlen)];
-    unicode_min = (uint32_t)block;
-    unicode_max = (uint32_t)(block >> 32);
-
-    mat->code[index(mat, row, col)] = rand()
-        % (unicode_max - unicode_min)
-        + unicode_min;
-}
-```
-
-The Unicode blocks are stored in 8-byte containers: the low four bytes form the
-first codepoint and the high four bytes the last. Here, I chose bitwise
-operations over unions because, first and foremost, the operations themselves
-are trivial and idiomatic, and the UNICODE() macro simplifies the management of
-charsets.
-
-The init_term() function is the arbiter of this zero-dependency software. It
-prepares the graphical environment so that I can interact with it via ANSI
-escape codes instead of unnecessary layers of abstraction:
-
-```
-static inline int init_term(const struct winsize *ws) 
-{
-    struct termios ta;
-
-    if (tcgetattr(STDIN_FILENO, &ta) == 0) {
-        ta.c_lflag &= ~ECHO;
-        if (tcsetattr(STDIN_FILENO, TCSANOW, &ta) == 0) {
-            wprintf(L"\x1b[48;2;%d;%d;%dm", 
-                RGB_BG_RED, RGB_BG_GRN, RGB_BG_BLU);
-            wprintf(L"%s", ANSI_FONT_BOLD);
-            wprintf(L"%s", ANSI_CRSR_HIDE);
-            wprintf(L"%s", ANSI_CRSR_RESET);
-            wprintf(L"%s", ANSI_SCRN_CLEAR);
-            setvbuf(stdout, 0, _IOFBF, 0);
-            ioctl(STDOUT_FILENO, TIOCGWINSZ, ws);
-            return 1;
-        }
-    }
-    return 0;
-}
-```
-
-insert_code() seeds the Matrix, blend() creates the old monochrome CRT display
-nostalgia, and ANSI control sequences paint the screen. The result is a digital
-rain that captures the original Matrix aesthetic with high visual fidelity:
-
-```
-$ cc -O3 main.c -o matrix
-$ ./matrix
-```
+Looks a lot like the original now:
 
 <video style="max-width:100%;" controls="" poster="poster.png">
   <source src="matrix.mp4" type="video/mp4">
 </video>
 
-There was no cause to measure the program's performance characteristics
-precisely; it's gentle on the CPU. On my ThinkPad T490 running OpenBSD, which
-has a resolution of 1920x1080, it uses about 2-3% of the CPU, with occasional
-jumps of up to about 8%; the cores remain silent, the fans don't whir, the rain
-falls in quiet.
+Using half-width Katakana (U+FF61-U+FF9F) because full-width characters break
+columns.
+
+blend() is still good, left it alone.
+
+Tossed the license and automake cruft. Just `cc -O3 main.c -o matrix`. Don't
+need the ceremony.
+
+Performance regressions: none. Runs like a charm on the T490. 2% CPU. No
+whirring fans.
 
-Files: [source.tar.gz](source.tar.gz)
+Commit:
+[03f8d87](https://git.asciimx.com/matrix-digital-rain/commit/?id=03f8d87ba7c2e46bd3f3cc4c772fb3a2ac740c92)
 
diff --git a/_log/matrix-digital-rain/katakana.png b/_log/matrix-digital-rain/katakana.png
deleted file mode 100644
index b9df873..0000000
--- a/_log/matrix-digital-rain/katakana.png
+++ /dev/null
diff --git a/_log/matrix-digital-rain/source.tar.gz b/_log/matrix-digital-rain/source.tar.gz
deleted file mode 100644
index 5a69236..0000000
--- a/_log/matrix-digital-rain/source.tar.gz
+++ /dev/null
diff --git a/_log/suckless-software.md b/_log/suckless-software.md
index 21c9f88..02cf88f 100644
--- a/_log/suckless-software.md
+++ b/_log/suckless-software.md
@@ -1,89 +1,40 @@
 ---
-title: How to manage Suckless software installations
+title: Suckless upgrade workflow
 date: 2025-11-30
 layout: post
 ---
 
-Since <a href="https://suckless.org/" class="external" target="_blank"
-rel="noopener noreferrer">suckless</a> software requires users to modify the
-source code and recompile to customize, I need a way to maintain patches over
-the long term while retaining the ability to upgrade the software as new
-versions are released.
+Workflow for managing suckless patches across upgrades:
 
-## Initial setup
+Initial setup:
+- Clone from suckless
+- Reset to stable tag
+- Set push URL to my repo (git.asciimx.com)
+- Pull from upstream, push to mine
 
-When using a suckless program, I usually begin by cloning the project and
-setting the remote push URL to my own git repository:
+Config changes only:
+- Edit config.h (or let make generate it)
+- make clean install
+- Commit, push
 
-```
-git clone git://git.suckless.org/dwm
-git reset --hard <tag>
-git remote set-url --push origin git@git.asciimx.com:/repos/dwm
-```
+dwm/slstatus installs:
+- Can't replace running binaries
+- Kill dwm (Mod+Shift+q)
+- Switch to tty (Ctrl+Alt+F1 on OpenBSD)
+- make install
+- Back to X (Ctrl+Alt+F5)
 
-This way, I can pull updates from the upstream project whenever I want, while
-committing my changes to my git repository. The git reset command aligns my
-branch head with a stable release before applying patches or installing the
-software.
+Upgrades:
+- git pull --rebase
+- git rebase -i  to drop commits between my patch and new stable
+- Keep only: my patches + new stable tag + old history
+- Install, commit, push
 
-If all I want to do is reconfigure the software (e.g., change key bindings),
-which is what I need most of the time, the recommended approach is to modify
-the config.h file. If the config.h isn't yet in the project, the 
-`make clean <target>` command will generate it from the defaults and compile
-the software. The `<target>` is the name of the application (e.g., dwm) found
-in the Makefile. I modify the resulting config.h file and run `make clean
-install` to install the software before committing and pushing my changes to
-the git repo.
+Example:
 
-## dwm and slstatus
+Before: [my patch] -> [6.5] <br>
+After pull: [my patch] -> [random commits] -> [6.6] -> [old stuff] -> [6.5] <br>
+After rebase: [my patch] -> [6.6] -> [old stuff] -> [6.5]
 
-Since dwm and slstatus are always running, `make install` will likely fail for
-them. The operating system may prevent the installer from replacing running
-executables with new ones. Hence, we must first stop the running instances of
-these programs (in my case, using Mod + Shift + q). Then, switch to a tty 
-(Ctrl + Alt + F1), log in, and change the directory to where dwm/slstatus is.
-We can run `make install` to install the software and switch back to the
-graphical session (Ctrl + Alt + F5).
-
-The key combinations for switching to the tty and back may differ across
-systems. The ones listed above are for OpenBSD.
-
-## Subsequent upgrades
-
-When suckless releases a new version, I run `git pull --rebase` to fetch the
-upstream changes and rebase my patches on top of them. Because I tend to use
-stable versions, I perform another interactive rebase to drop the commits
-between the latest stable version tag and my patch before installing the
-software.
-
-Commit log before upgrading:
-
-```
-dt236  My patch.
-3fkdf  Version 6.5.
-```
-
-Commit log after pulling:
-
-```
-w467d  My patch.
-gh25g  A commit.
-g525g  Another commit.
-3fkdf  Version 6.6.
-vd425  Old commit.
-q12vu  Another old commit.
-3fkdf  Version 6.5.
-```
-
-Commit log after the interactive rebase:
-
-```
-h57jh  My patch.
-3fkdf  Version 6.6.
-vd425  Old commit.
-q12vu  Another old commit.
-3fkdf  Version 6.5.
-```
-
-And finally, I commit and push all the changes to my git repository.
+Note: This keeps patch history clean while staying current.