Advent of code in Mu

Day 2 solutions (spoiler alert): 2a 2b.

40 minutes. No new Mu bugs found, no machine-code hacking was needed.

Day 3 solution

60 minutes. Lost 11 minutes debugging a silly mistake (see commit log)

No new Mu bugs found, no machine-code hacking was needed.

Project page: https://github.com/akkartik/mu

permalink

Advent of code in Mu

http://akkartik.github.io/mu/html/linux/apps/advent2020/1a.mu.html Day 1 part 1 solution (don't click if you don't want to be spoiled):

Took me about 40 minutes. In the process, I had to:

• Fix a bug in reading lines from stdin into streams
• Start trailing newlines when parsing ints from streams
• Implement `find` in an array

We'll see how long I can keep this up. Linear scans will soon not cut it.

Day 1 part 2 (same deal, same spoiler alert, just more brute force): http://akkartik.github.io/mu/html/apps/advent2020/1b.mu.html

Part 1 took 40 minutes and part 2 took 18. Therefore I'm getting better at this.

Project page: https://github.com/akkartik/mu

permalink

I'm trying to come up with a notation for the rotate (circular shift) operation:

https://stackoverflow.com/questions/32785998/symbol-for-bitwise-circular-shifts

Kinda surprising that there isn't a standard answer yet, given how common it is in cryptography, and how much of a workhorse it is in the ARM instruction set.

permalink

The Mu shell, compiling down to a subset of 32-bit x86 machine code, then to a Linux ELF binary, packaged up with just a Linux kernel and nothing else, running on a Linux console emulated on Qemu, on a Thinkpad T420s running 64-bit Linux.

Just another 27 million lines of C to take out (Linux kernel), and I'll have a decent computing stack.

---

I'm also thinking today about what it would take to fork Mu for the Raspberry Pi. It uses ARM processors, a 64-bit instruction since the Pi 3 which was released in 2015. The 64-bit ISA looks quite nice, but it's incompatible with the Pi 1 and Pi 2. Contrast x86, where 64-bit is quite compatible with 32-bit, but grotesque as a result, with bits for a register scattered across multiple bytes. So I might make the opposite choice to x86 and support just the 64-bit ISA. Thoughts?

https://developer.arm.com/documentation/den0024/a

permalink

Screenception

Visualizing programs with side-effects in a postfix shell with a live-updating text-mode environment. Built all the way up from machine code without any dependencies (except an x86 processor and Linux kernel).

https://archive.org/details/akkartik-2min-2020-11-12

Project page: https://github.com/akkartik/mu

More context

permalink

In the last 3 days I've written 68 tests for error messages in the Mu compiler, adding up to about 4.5k lines of machine code. Utterly tedious, mind-numbing work with lots of copy-pasta. Just what the doctor ordered.

(https://github.com/akkartik/mu)

permalink

For a couple of years I've been building up a computing stack without metacircularity, where complex languages are consistently implemented in simpler languages.

For several months now I've been wrestling with a thorny problem in one corner of the core compiler which converts a safe language into unsafe machine code. Today I finally decided to stop agonizing over it, and write up the idea maze to the extent I've explored it.

https://github.com/akkartik/mu/issues/45

Comments and suggestions most appreciated! This is a fairly simple compiler as these things go, and I'd be happy to engage with anyone who wants to learn about these beasts in a realistic setting.

permalink

My little prototype is starting to look like a shell

https://archive.org/details/akkartik-2min-2020-10-27

Promising in some ways, but I'm not sure how to support concurrency. Currently each operation completes before the next. I could allow "pipe stages" to continue to share data after they drop file handles on the stack, but there are problems: how often we refresh, how we kill processes from past refreshes, how we visualize file handle contents.

(More details: https://github.com/akkartik/mu)

permalink

Beginnings of an experimental fork of Mu for 64-bit x86

Built in collaboration with @tekknolagi.

https://git.sr.ht/~akkartik/mu-x86_64

I'm not sure this is going to work out. Mu's syntax for 32-bit x86 machine code doesn't map cleanly to x86_64, for reasons outlined in the Readme. But the emulator works, and it has a nice regular subset of x86_64 including floating-point instructions. Comments and suggestions most appreciated.

Main project page: https://github.com/akkartik/mu

permalink

This week in my postfix language and live-updating environment, I worked on a way to start from a raw computation, and extract functions from it as naturally as possible.

https://archive.org/details/akkartik-2min-20201020

(More details: https://github.com/akkartik/mu)

permalink