stacyprowell.com – Ugh. Stacy's writing something.

Artificial Something

Learning is fun!

I think we all know about the problems that large language models (LLMs) have with counting the number of occurrences of the letter r in strawberry. Modern LLMs have that fixed.

Now, how about a different test? Aspartyltryptophan is a word I did not make up. It’s the name for a compound, and you can find out more about it here. Why do I bring it up? Well, it has a lot of consecutive consonants: 9 of them.

aspartyltryptophan –> a sp a rtyltrypt o ph a n

You will note that the longest block of consonants is 9 letters in length. (Is y a vowel here? Don’t think about it too much; that’s not the point.)

Let’s ask ChatGPT about this.

Collections

You can’t have everything, but given enough time and space you can generate everything except more time and space.

Relision has hit version 0.6.0, meaning that collections are implemented. The collections model for Relision is pretty much the same as it was for Elision, with a few tweaks.

Turing Complete

P = computability is the cornerstone of P

The Relision system is now Turing complete. This is a good thing, but there is a crazy amount of work left to do. Right now only the simplest matching is performed to allow somewhat trivial lambda expressions to work.

The screenshot is probably not that impressive. What is going on?

Haunted by Errors

That which does not kill you may still haunt you forever

Just a two or three years ago (no need to check) I was in college taking computer science courses, and I encountered CS 375 (I think). This was the undergraduate computational mathematics course, and it was taught by a doctoral student.

A large part of the class was about how to calculate (or bound) the errors in computations. It involved things like the condition number of matrices, and I recall thinking the material was so boring!!! In fact, I had a really hard time getting into the class… and got the only bad grade I ever got in a computer science course (but I did pass).

Too Many Projects

Work expands to fill the lack of personal discipline

As I have reduced the number of projects I am working on in my day job (down from ten to just… less than ten) I have compensated by raising the number of projects I am working on at home. These range from cleaning up the flowerbeds to updating and revising the Markov chain computations book. The term rewriter has, again, moved to the back of the queue.

The Long Road

Life is short, and the world is wide

When I started work on rewriting the term rewriter I thought “Here’s a fun project I can work on occasionally.” That turned into almost never, thanks to a number of factors.

Picking Apart the Legion PowerShell

Kindred Security does a great job of pulling apart the Legion PowerShell credential stealer on YouTube, but I thought I would do a little more work to break down the PowerShell commands used in all their gory detail.

If you haven’t watched Kindred Security’s video, go do it now. It should be linked above. I’ll wait.

Documentation

Documentation is a story about the past. Usually fictional.

A job is not done until you have bragged about it. Let’s call that “documentation.”

I’ve created a wiki to host this documentation, and you can find it here.

One of the magical things about creating user documentation is that you quickly realize what a horrible user experience you have created, and the code starts changing (and improving, one hopes). “Just create a FooFactory instance from the AbstractFooFactoryGenerator, after initializing the configuration system and creating a Context object with your custom Frabulator.” Madness!

In any case, user documentation is now materializing on the wiki, and the code is changing in response. Let’s hope this is a positive development. Feel free to constructively criticize.

Trivial Recursive-Descent Parsing

Adding a tiny parsing module to Relision

Having gotten the basic REPL working, I needed to begin building the parsing stuff. For that, I decided on porting my idiotically simple recursive-descent parser library to Rust because that seemed like a thing I might do, and I’m nothing if not me.

The Relision REPL

Putting the REPL before the horse

I’ve made a few starts at a rewrite of Elision focusing on implementing the terms, but I have been much too busy to make much progress. One of the issues is that as the terms are implemented I need to write a large number of tests. That’s okay – testing is good – but I end up with a lot of code that gets thrown away at some point.

Instead, I decided to write the read, evaluate, print loop (REPL) first this time, followed by iterative implementation of the parser and terms. This means that I can write the tests in the rewriter’s language and just modify the plumbing as I make changes. It also means I can “prime” the system by writing the bootstrapping library as I go.

So that’s the plan. The REPL is now done, complete with configuration, history, command line processing, etc

So now it is on to implementing the terms.