I'm back from a death march.

Mu is a safe language built in machine code, translating almost 1:1 to machine code. A key check is for use-after-free errors, using a second address type ("Bicycles for the mind have to be see-through", section 4.4)

I spent the last 2 months switching all of Mu's implementation to this scheme. It was a tough time. But now I know it works (with 10-15% slowdown), and Mu functions calling low-level libraries should behave unsurprisingly.

https://github.com/akkartik/mu

permalink

Mu: the movie

https://archive.org/details/akkartik-2min-2020-04-20 (2 mins)

permalink

I went through an intensive Forth phase a couple of years ago before embarking on SubX, but somehow missed this Chuck Moore talk at Strange Loop:

https://www.infoq.com/presentations/power-144-chip

I watched it today at 1.5x, and it still took me 2 hours to watch. I had to pause every couple of seconds to digest what I'd just heard. Fascinating.

Forth chips focus on power, and therefore tiny memories. It's a powerful justification for remaining in the nostalgic console aesthetic of the 80s.

permalink

Yak shave of the day

My editor shows signs on the margins to indicate changes since last commit. I wanted it to show diffs from an arbitrary commit.

This feature request had been understandably refused a year ago: https://github.com/mhinz/vim-signify/issues/232

So I fixed it for myself, in 3 easy steps:

1. Find a simpler version: 1650 => 900 lines.
2. Delete even more code: -600 lines.
3. Add the feature: +2 lines.

The final result only works for me. I believe we should share raw VimScript, not packages.

permalink

The Mu compiler summarized in one page

More details

Repo

(Brief update since there isn't much to report: I'm working on safe heap allocations as described in the paper. But it's slow going because of life and the need to unwind some past decisions.)

permalink

I'm hitting publish on my paper.

Kartik Agaram, "Bicycles for the mind have to be see-through", Convivial Computing Salon, 2020.

http://akkartik.name/akkartik-convivial-20200315.pdf [pdf; 25 pages]

Get it? When I look over at my bicycle I can see right through its frame. I can take in at a glance how the mechanism works, how the pedals connect up with the wheels, and how the wheels connect up with the brakes. And yet, when we try to build bicycles for the mind, we resort to “hiding” and “abstraction”.

permalink

Programming in 2D text

This evening I'm thinking of two ideas I've thought about several times before, but never together.

The first: Arjun Nair's IRCIS, an esoteric language (art for art's sake) that comes with a cool visualizer. Maybe all languages should.

The second is Dave Ackley's Movable Feast Machine, a tiled processor for very finely grained distributed computation. Programming it is like playing with a cellular automaton.

The two projects have very different goals. IRCIS seems to be just a fun hack. MFM explores ideas for scalable, robust, secure computation.

Today I'm wondering if putting them together might get us a way to gradually learn programming that rivals spreadsheets.

What if we expand IRCIS from 1x1 to 1x2. The cursor occupies 2 characters, one data and one code. The cursor has modes that operate on data or code, independently. The same path may do different things depending on the mode.

Another mode idea: push characters like sokoban.

The immediate goal is to do something non-trivial, like say tokenizing a string into words. Or maybe a 4-operation arithmetic evaluator? And, crucially, for the grid to go with the grain of the visual cortex. Amenable to visual inspection, encouraging self-documenting programs.

permalink

Update on the Mu computer's memory-safe language

Arrays and product types are now done. Any remaining rough edges are working as intended 😄 Only hex literals, for example.

What's left? Actually making it safe.

Complexity outlay so far: 16k lines of code, but only 6.5k if you exclude tests. Tests get _very_ repetitive in machine code. Hopefully we won't need another 15k LoC.

Example program

(More details. Repo.)

permalink

New milestone: I just wrote 150 LoC of glorified machine code (utterly unsafe; lots of magic numbers) and had it work the first time.

https://github.com/akkartik/mu/commit/c8784d1c0f0

Though to be fair I'd been planning it for 16 hours, with lots of preliminary commits that nibbled away at the edges of the problem. Still, time spent thinking before rather than debugging after.

Perhaps this is bad news. Perhaps my brain is getting so colonized by machine code that I'm losing my bearings on what is easy for others.

permalink

Lots of words in this commit message about liveness analysis, and it probably still makes no sense to anybody.

Hopefully it'll make sense to me at least in a month or two.

permalink