AI as a cheat code for the universe... A bummer indeed!

A few years ago, I wrote a small program to convert binary files into a text string of bytes (codify.c). I was fed up with trying to send binary files through Gmail, only to have Google's servers block them.

As it happens, I still had one of those text files lying around: a string of numbers containing the original binary of Microsoft's 1995 MS-DOS editor, edit.exe.

(edit.dec) 77.90.-2.0.-119.0.0.0.-51.1.-6.4.-1.-1.88.15.-128.0.0..... etc

With the help of generative LLMs, AI agents and their recent leaps in reverse-engineering capabilities (99.2% accuracy!), I encouraged my brother to use his ChatGPT Codex subscription and its coding agent to try to reconstruct the source code of Microsoft's classic editor in C, this time for Linux.

The very first interaction produced a version that was remarkably faithful to the original. It needed a bit of steering to iron out a few details, but after a handful of feedback comments and corrections, we had a perfectly functional program in barely ten minutes. A genuine replica of the original.

It felt like magic.

I'd actually tried to develop a similar editor myself (c-edit), so I know how much work it takes. Years. And I also know how buggy the end result can be when you're an amateur programmer, as I am.

But this is something else. This is magic. No, actually, it's more like activating a cheat code in a video game: AI feels like a cheat code for the universe itself.

But how boring is it to play a video game with all the cheat codes enabled! It's just not the same anymore. Some of the challenge, the effort, the meaning of it all, simply disappears.

The only silver lining in all this is the thought that this same capability, this kind of magic or universal cheat code, might lead to extraordinary breakthroughs in other fields, such as medicine and biology. Perhaps, that's where having all the cheats enabled may actually be worth it.

TIL - Horner's method: An algorithm for reading a number written in any positional numeral system.

There is a universal algorithm for evaluating numbers written in any positional numeral system. Once you know the base and can convert each symbol into its corresponding digit, the algorithm is simply:

result = result * base + digit;

Suppose you are reading a number in base 10 say 1234:

Let's decompose in exponentials from left to right:

1234 = 1*10³ + 2*10² + 3*10¹ + 4*10⁰

Now we factor 10:

10(1*10² +2*10¹+3)+4

And again:

10(10(1*10+2)+3)+4

Finally:

10(10(10(1) +2)+3+4

Alternatively:

((1×10+2)×10+3)×10+4

This works for any positional numeral system. Changing 2 to 10 parses decimal numbers, changing it to 16 parses hexadecimal numbers (after converting A–F to 10–15) and so on.

Newton's Binomial Theorem

I stumbled upon this formula in a book the other day and set about coding it in C from scratch. At the end of the day any summation can be easily turned into a for loop.

I also wrote my own functions for exponential, combinatorial numbers and factorial.

[fread]: An old-school text file viewer for the modern terminal (GNU/Linux)

Last month I came across an old gem: PC Game Programmer's Encyclopedia, a DOS-era program built with the Pascal TUI Vision library. It’s a collection of docs about assembly and game programming compiled by Mark Feldman.

These files were originally stored in old MS-DOS encodings. Luckily, thanks to the dos2ansi project I was able to convert them into a more UTF-8-friendly format, making them readable on modern systems.

That got me thinking: why not create a modern TUI version for GNU/Linux to display these texts?

The first step was building a text file viewer that supports modern Unicode encoding. That’s how fread was born.

You can see it in action in this demo video.

The project has a modular approach:

• openfile.c handles opening and reading files.

• viewer.c takes care of displaying the contents, with both horizontal and vertical scrolling, screen resizing, and even binary file detection.

I'm quite happy with how it turned out and it is a marked improvement on my previous attempt at coding a textfile reader fw, which only supported ASCII characters. I like how you can keep writing the same style of program and still learn something new each time. I have quite a collection of TUI programs now :D

The next step will be to create a mock-up of the original DOS program with the dro-down menus at the top linking to the documents.

Dictionary Apps: Terminal and Web-Based

I set about coding a TUI dictionary program for the Linux terminal in C to help me expand my vocabulary in English using the interface I had made for HIS (TUI history command). The dictionary is stored in a CSV file with 4 fields (ID, WORD, TRANSLATION, COMMENT). You can add words from the program, edit specific fields.  The feature I'm definitely most proud of is the built-in game to guess words from your dictionary.

You can try it out here: https://github.com/velorek1/dict

It's fun to play it on Termux on an Android phone. The downside is that the dictionary is stored locally and cannot be accessed from any other device. 

Another approach I explored was reusing the previous work I had done with Google App Scripts , Javascript, Google sheets and the recently discovered, amazing hosting service of Netlify. Thanks to Claude (AI) I was able to deploy a fully developed APP that mimicks and more than exceeds the  features of my terminal program. I will definitely be using Netlify in future web-based projects! :)

Full version here : https://regal-sawine-d63fb6.netlify.app/

Art - Exploring objects in the computational universe

Fractals are characterized by self-similarity and recursive patterns at various scales. Sometimes this complex behavior can be achieved from simple rules which typically make use of loops, recursion, or even modular arithmetic in conjunction with bit-wise operations (XOR; AND, ETC).

I had found this example a while ago and I'm still amazed at how such a complex pattern like the Sierpinski fractal can emerge in only 14 bytes of assembler code!? Truly mind-boggling.

The second example uses modular arithmetic to create a maze-like fractal pattern.

REPOSITORY FOR ART 

[keyc] : A proof-of-concept Linux Keylogger in C

[keyc] : KeyCapture

A simple keylogger for Linux using evdev. This program captures keyboard input. I

t requires root privileges to run. Keyboard device file defaults to event0. 

If different, check /proc/bus/input/devices and run with paramater specifying device file number (X) as in ./keyc X

Key chars are stored in .capt.dat

Compilation

Compile the program with GCC:

• gcc keyc.c -o keyc

Link to repository