September 2, 2023

/stream /colophon /programming /linux

After spending a few hours this week trying to build a CLI that replaces my jnl shell-alias tool and allowed it to publish my website, I spent a few more hours today really thinking about the difference between a shell script and a program binary, and if I wasn't creating unecessary complications. This project of porting a shell script to a Rust binary taught me a lot of things about the nature of the shell as a computing environment, and pushed me to try to keep these tools as shell scripts for now.

I ultimately don't feel like the scripts I have now are the best version of this tool, but I also don't think that the compiled binary I was building was any better... and it was going to take an order of magnitude longer. I'm going to sit in the discomfort of these unfinished tools for a while as I continue to shape the /coalescent computer environment, and at least enjoy the fact that it's much faster to add entries to my website logs now.

July 10, 2023

/stream /technology /programming

A few days ago I watched this video about the performance differences between stack machine VMs and register machine VMs (when running on a physical register machine). The takeaway was that due to pipelining, a stack machine VM runs slower since it is always reusing the top of the stack, and none of the work can be done in parallel. For example, the equation ( 1 + 2 ) * ( 3 + 4 ) on a stack machine could be 1 2 + 3 4 + *, but all 7 instructions have to be run sequentially; on a register machine ( 1 + 2 ) and ( 3 + 4 ) can be decoded and prepped at the same time, since there is no dependency on those calculations (only the '*' must wait).

This, for some reason, made something click about Interaction Nets, in a way that didn't resonate with me the first time I started reading about them. It might have just been because lambda-calculus feels so opaque to me and I didn't have a good visual model in my head, and that this concept of dependencies in calculations gave me that visual. From there, I revisited HVM's github and Devine's interaction net page (linked above), and found myself thinking about rewriting rules again too.

Either way, this all got me thinking about how you might be able to declare "dependencies" for calculations in a stack machine. Could you maybe "branch" a stack into parallel computations with different memory addresses? Could you use that for SIMD operations? Would this be a great way to increase real world performance, or would it make writing code unecessarily complex? Am I just reinventing an obvious idea from a part of computer science that I don't know about?

July 2, 2023

/stream /technology /programming /collect

Spent a good chunk of time today revamping a community website to add a blog, and part of that meant figuring out how to implement a "dynamic root path" for URLs. I had to make some changes to 'collect' for it to work, but I think it's more robust now: it should more fully be able to recurse through contexts looking for objects of a certain name (which in this case is the "root-override").

Adding this feature has made me feel a little bad about 'collect', since with only four months having passed it feels quite sloppy and difficult to reason about the source code. It's definitely not worth rewriting again any time soon, but it's worth keeping in mind as my web projects that rely on it continue to grow.

May 30, 2023

/stream /reading /merveilles /programming

I read Situated Software, by Clay Shirky which seemed to be bubbling up in conversation around Merveilles today. It elaborated on some of the ideas I've been playing with lately, specifically around offloading the social aspect of computing networks to the humans in the loop instead of strict algorithms. This note on payment in small scale networks was particularly in line with that:

The possibility of being shamed in front of the community became part of the application design, even though the community and the putative shame were outside the framework of the application itself.

May 24, 2023

/stream /technology /programming /collect /colophon

As I started fleshing out components of this site, I wanted to add some new features to /collect. I added the ability to reuse the name of a @map as a value using "$NAME", and it can also be interpolated in strings with "@name". I also exposed a list of the @group objects on a @map using the value "@groups" on a @map. The first change reduced redundancies when writing new stream events, and the second made it possible to render all of the groups for each stream event.

May 23, 2023

/stream /technology /programming /colophon

Built out the rough framework for this website, settling on the complimentary "garden" and "stream" metaphors.

Start