mu/index.html

<title>Mu</title>

With apologies to <a href='http://en.wikipedia.org/wiki/Mu_%28negative%29#In_popular_culture'>Robert Pirsig</a>:
<p>
<div style='font-style: italic; margin-left:2em'>
Is it a language, or an operating system, or a virtual machine?
<p>
Mu.
</div>

<p>
Mu's code is structured in an unconventional manner, requiring editors to be
specially configured to colorize it in a sane manner. Here's how it currently
looks in my <a href='https://github.com/akkartik/mu/blob/master/mu.vim'>custom setup</a>.

<p>Whetting your appetite: some example programs.

<ul>
<li><a href='html/x.mu.html'>x.mu</a>: a simple program to add two numbers
together. Shows that at bottom mu is a simple VM bytecode designed to convert
directly to machine code.
<li><a href='html/factorial.mu.html'>factorial.mu</a>: everyone's favorite
example, showing how mu supports conditionals and loops without any special
syntax, using the special labels '{' and '}'.
<li><a href='html/tangle.mu.html'>tangle.mu</a>: another (contrived) version
of factorial showing mu's ability to 'tangle' code from multiple places into a
single function or 'recipe'.
<li><a href='html/counters.mu.html'>counters.mu</a>: lexical scope
<li><a href='html/callcc.mu.html'>callcc.mu</a>: first-class continuations. Mu
also supports first-class functions and delimited continuations.
<li>simple examples showing off support for concurrency: <a href='html/fork.mu.html'>fork.mu</a>,
<a href='html/channel.mu.html'>channel.mu</a>
<li>simple examples showing off hardware control: <a href='html/display.mu.html'>display.mu</a>,
<a href='html/keyboard.mu.html'>keyboard.mu</a>.
<li><a href='html/screen.mu.html'>screen.mu</a>: example program showing
print primitives that inject a screen <em>dependency</em> which can be faked
for testing.
<li><a href='html/chessboard.mu.html'>chessboard.mu</a>: putting it all
together, the big kahuna: a complete console program along with thorough tests
of its behavior including both screen and keyboard handling.
</ul>

<p><b>Part I</b>: basic infrastructure
<p/><a href='html/000organization.cc.html'>000organization.cc</a>: the basic
skeleton program. Compiles and runs but doesn't do much. Later <em>layers</em>
hook into this skeleton to add functionality. Mu's guarantee: you can <a href='http://youtube.com/watch?v=c8N72t7aScY'>load
features</a> up until any layer, and it will compile and pass all tests until
that point. <a href='http://akkartik.name/post/wart-layers'>More details &rarr;</a>
<br/><a href='html/001help.cc.html'>001help.cc</a>: just a simple test layer
to show how to hook into the skeleton. Also summarizes how to invoke mu,
behaviors that later layers will be providing.
<br/><a href='html/002test.cc.html'>002test.cc</a>: mu's minimalist test
harness, relying on a couple of one-liners in the makefile to autogenerate
lists of tests to run.
<br/><a href='html/003trace.cc.html'>003trace.cc</a>: support for logging
facts about our program, and for <a href='http://akkartik.name/post/tracing-tests'>checking the facts logged in tests</a>.
(<a href='html/003trace.test.cc.html'>tests for the test harness</a>)

<p><b>Part II</b>: the mu virtual machine, designed to compile easily to
machine language.
<p/><a href='html/010vm.cc.html'>010vm.cc</a>: core data structures: recipes
(functions), instructions and reagents (operands).
<br/><a href='html/011load.cc.html'>011load.cc</a>: the textual representation
of recipes and how it's turned into the data structures.
<br/><a href='html/012transform.cc.html'>012transform.cc</a>: after mu
programs are loaded but before they are run they can be transformed in an
extensible manner akin to lisp macros. Think of this as the core of mu's
&lsquo;compiler&rsquo; for providing high-level features atop the core.
<br/><a href='html/013literal_string.cc.html'>013literal_string.cc</a>: extend
the loader to support literal strings in various instructions.
<br/><a href='html/014literal_noninteger.cc.html'>014literal_noninteger.cc</a>:
extend the loader to support non-integer numbers.
<br/><a href='html/020run.cc.html'>020run.cc</a>: executing mu recipes by
executing the list of instructions they contain.
<br/>Various primitive operations: on <a href='html/021arithmetic.cc.html'>numbers</a>,
<a href='html/022boolean.cc.html'>booleans</a>, for <a href='html/023jump.cc.html'>control flow</a>,
and <a href='html/024compare.cc.html'>comparing values</a>.
<br/>Primitive operations to help with testing: <a href='html/025trace.cc.html'>tracing/logging</a>, 
<a href='html/026assert.cc.html'>assert</a> and
<a href='html/027debug.cc.html'>debug by print</a>.

<br/><a href='html/030container.cc.html'>030container.cc</a>: compound types
akin to records, structs or classes.
<br/><a href='html/031address.cc.html'>031address.cc</a>: adding and removing
layers of indirection to mu data.
<br/><a href='html/032array.cc.html'>032array.cc</a>: all mu data structures
are <a href='html/033length.cc.html'>bounds-checked</a>.
<br/><a href='html/034exclusive_container.cc.html'>034exclusive_container.cc</a>: tagged unions or sum types.
<br/><a href='html/035call.cc.html'>035call.cc</a>: calls to recipes look
just like primitive operations.
<br/><a href='html/036call_ingredient.cc.html'>036call_ingredient.cc</a>: how
recipes pass arguments or 'ingredients' without introducing any syntax and
breaking the metaphor of recipes as lists of instructions.
<br/><a href='html/037call_reply.cc.html'>037call_reply.cc</a>: recipes can
return arbitrary numbers of values to their callers.
<br/><a href='html/038scheduler.cc.html'>038scheduler.cc</a>: running multiple
recipes concurrently using <em>routines</em> that might execute in interleaved
fashion.
<br/><a href='html/039wait.cc.html'>039wait.cc</a>: primitives for
synchronization between routines.

<p><b>Part III</b>: transforms to provide 80% of the benefits of high-level
languages.
<br/><a href='html/040brace.cc.html'>040brace.cc</a>: how mu provides
structured goto-less programming without introducing the syntax of
conditionals and loops other languages require.
<br/><a href='html/041name.cc.html'>041name.cc</a>: how mu transforms variable
names to raw memory addresses.
<br/><a href='html/042new.cc.html'>042new.cc</a>: rudimentary memory
allocator that is aware of all global types in any mu program.
<br/><a href='html/043space.cc.html'>043space.cc</a>: how variables in
different routines are isolated from each other using <em>spaces</em>. Mu
&lsquo;local variables&rsquo; are allocated on the heap.
<br/><a href='html/044space_surround.cc.html'>044space_surround.cc</a>:
Chaining spaces together to accomodate variables with varying lifetimes and
ownership properties.
<br/><a href='html/045closure_name.cc.html'>045closure_name.cc</a>: how spaces
can implement lexical scope.
<br/><a href='html/046tangle.cc.html'>046tangle.cc</a>: support for layers in
mu programs. They've been so good to us.
<br/><a href='html/047jump_label.cc.html'>047jump_label.cc</a>: since we have 
<br/><a href='html/048call_variable.cc.html'>048call_variable.cc</a>:
higher-order functions.
<br/><a href='html/049continuation.cc.html'>049continuation.cc</a>:
first-class and delimited continuations, primitives for yield, exceptions and
much else besides.
<br/><a href='html/050scenario.cc.html'>050scenario.cc</a>: mu's first syntax
&mdash; not for code but for tests. (<a href='html/051scenario_test.mu.html'>example</a>)

<p><b>Part IV</b>: beginnings of a standard library
<p/><a href='html/060string.mu.html'>060string.mu</a>: bounds-checked rather
than null-terminated. Unicode-aware.
<br/><a href='html/061channel.mu.html'>061channel.mu</a>: channels are mu's
only synchronization primitive, queues that can cause the routine reading or
writing from them to stall without taking up CPU resources.
<br/><a href='html/062array.mu.html'>062array.mu</a>
<br/><a href='html/063list.mu.html'>063list.mu</a>
<br/><a href='html/064random.cc.html'>064random.cc</a>

<p><b>Part V</b>: Nascent tools for browsing mu codebases, and for teaching
programming to non-programmers by getting them hooked on the value of tests.
The eventual goal is an environment that watches the programmers try out the
code they write, and turns the interactive sessions into reproducible test
scenarios.

<p/><a href='html/070display.cc.html'>070display.cc</a>: primitives for using
the keyboard and screen.
<br/><a href='html/071print.mu.html'>071print.mu</a>: helpers that can swap
the real screen with fake ones for testing.
<br/><a href='html/072scenario_screen.cc.html'>072scenario_screen.cc</a>:
writing tests that check what is printed to screen.
(<a href='html/073scenario_screen_test.mu.html'>examples</a>)
<br/><a href='html/074keyboard.mu.html'>074keyboard.mu</a>: helpers that can
swap the real keyboard with fake ones for testing.
<br/><a href='html/075scenario_keyboard.cc.html'>075scenario_keyboard.cc</a>:
writing tests using a fake keyboard.
(<a href='html/076scenario_keyboard_test.mu.html'>examples</a>)
<br/><a href='html/077trace_browser.cc.html'>077trace_browser.cc</a>: a
zoomable UI for inspecting traces generated by mu programs. Allows both
scanning a high-level view and drilling down into selective details.

<p/><a href='html/999spaces.cc.html'>Epilogue</a>: maps summarizing various
address spaces, and the conventions that regulate their use in previous
layers.

<p style='margin-bottom: 2em'/>