351 lines
20 KiB
HTML
351 lines
20 KiB
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>
|
|
|
|
Read these first: <b><a href='http://akkartik.name/about'>problem statement</a></b>,
|
|
<b><a href='http://github.com/akkartik/mu#readme'>trying out Mu</a></b>.
|
|
(Mu requires minimal dependencies.)
|
|
|
|
<p>
|
|
Mu's code looks quite alien, requiring editors to be specially configured to
|
|
colorize it in a sane manner. So this page provides links to the source files
|
|
showing 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 <em>recipe</em>.
|
|
<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/console.mu.html'>console.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/filesystem.mu.html'>filesystem.mu</a>: example program
|
|
showing file primitives that inject a 'filesystem' dependency which can be
|
|
faked for testing.
|
|
<li><a href='html/http-client.mu.html'>http-client.mu</a> and <a href='html/http-server.mu.html'>http-server.mu</a>,
|
|
examples of Mu's testable high-level interfaces to the network.
|
|
<li><a href='html/static-dispatch.mu.html'>static-dispatch.mu</a>: example
|
|
program showing Mu's ability to define recipes with headers, and thereby to
|
|
allow functions with the same name but arguments of different types to
|
|
coexist.
|
|
<li><a href='html/counters.mu.html'>counters.mu</a>: lexical scope
|
|
<li><a href='html/chessboard.mu.html'>chessboard.mu</a>: a little program for
|
|
2 people to play chess, with thorough tests of its behavior including both
|
|
screen and keyboard handling.
|
|
<li><a href='html/nqueens.mu.html'>nqueens.mu</a>: a solution to the <a href='http://rosettacode.org/wiki/N-queens_problem'>N queens problem</a>.
|
|
<li>Example programs using delimited continuations:
|
|
<a href='html/continuation1.mu.html'>1</a>,
|
|
<a href='html/continuation2.mu.html'>2</a>,
|
|
<a href='html/continuation3.mu.html'>3</a>,
|
|
<a href='html/continuation4.mu.html'>4</a>,
|
|
<a href='html/continuation5.mu.html'>5</a>.
|
|
<li>A code essay: <a href='http://akkartik.name/coroutines-in-mu'>“Coroutines in Mu”</a>
|
|
<li><a href='html/same-fringe.mu.html'>same-fringe.mu</a>: a solution to the
|
|
<a href='http://wiki.c2.com/?SameFringeProblem'>‘same fringe’</a>
|
|
problem, demonstrating Mu's coroutines and generic functions.
|
|
<li>Two klunky ways to build exceptions out of continuations in Mu:
|
|
<a href='html/exception1.mu.html'>1</a>,
|
|
<a href='html/exception2.mu.html'>2</a>.
|
|
Since Mu is statically typed, there's no way to implement a <tt>try</tt>
|
|
primitive that can wrap arbitrary functions.
|
|
</ul>
|
|
|
|
Now a listing of every layer in Mu. Recall that you can <a href='http://akkartik.name/post/wart-layers'>stop
|
|
loading at any layer and get a valid program to run with a subset of features,
|
|
that passes all its tests</a>.
|
|
|
|
<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 →</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 <tt>build</tt> script to
|
|
auto-generate 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 tracing system</a>)
|
|
|
|
<p><b>Part II</b>: the core Mu virtual machine, designed to compile easily to
|
|
machine language.
|
|
|
|
<p/><a href='html/010vm.cc.html'>010vm.cc</a>: core data structures:
|
|
recipes, instructions and <em>reagents</em> (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
|
|
‘compiler’ for providing high-level features atop the core.
|
|
<br/><a href='html/013update_operation.cc.html'>013update_operation.cc</a>:
|
|
our first transform: check for unknown recipes before the program runs.
|
|
<br/><a href='html/014literal_string.cc.html'>014literal_string.cc</a>: extend
|
|
the loader to support literal strings in various instructions.
|
|
<br/><a href='html/015literal_noninteger.cc.html'>015literal_noninteger.cc</a>:
|
|
extend the loader to support non-integer numbers.
|
|
<br/><a href='html/016dilated_reagent.cc.html'>016dilated_reagent.cc</a>:
|
|
allowing whitespace in reagents.
|
|
<br/><a href='html/017parse_tree.cc.html'>017parse_tree.cc</a>: a new syntax
|
|
for representing complex types as trees using whitespace and parentheses
|
|
(s-expressions).
|
|
<br/><a href='html/019type_abbreviations.cc.html'>019type_abbreviations.cc</a>:
|
|
the core types of Mu are designed to be fully explicit and familiar to
|
|
non-programmers at the cost of some verbosity: <tt>number</tt>,
|
|
<tt>character</tt>, <tt>boolean</tt>, etc. Once learners get acclimatized,
|
|
we can teach them abbreviated forms that are familiar to veteran programmers:
|
|
<tt>num</tt>, <tt>char</tt>, <tt>bool</tt>. Mu's facility for type
|
|
abbreviations is extensible: learners can abbreviate <tt>number</tt> to
|
|
<tt>n</tt> if they so choose, thereby exploring such trade-offs. You can also
|
|
create abbreviations suitable for a specific program, like abbreviating
|
|
<tt>address:array:address:array:character</tt> to <tt>board</tt> for say a
|
|
tic-tac-toe or chess program. Think C's <tt>typedef</tt> statement.
|
|
<br/><a href='html/020run.cc.html'>020run.cc</a>: executing Mu recipes by
|
|
executing the list of instructions they contain. Future layers will define
|
|
more primitive operations that can be used in instructions.
|
|
<br/><a href='html/021check_instruction.cc.html'>021check_instruction.cc</a>:
|
|
harness for adding per-primitive checks to run before running a program.
|
|
|
|
<p/>Various primitive operations: on <a href='html/022arithmetic.cc.html'>numbers</a>,
|
|
<a href='html/023boolean.cc.html'>booleans</a>, for <a href='html/024jump.cc.html'>control flow</a>,
|
|
and <a href='html/025compare.cc.html'>comparing values</a>.
|
|
|
|
<p/>Support for <a href='html/026call.cc.html'>defining new recipes</a>. In
|
|
Mu calls to functions look just like primitive operations, with the ability to
|
|
<a href='html/027call_ingredient.cc.html'>pass in ingredients</a>, and to
|
|
<a href='html/028call_return.cc.html'>return products</a>. In particular, Mu
|
|
supports returning multiple values, and uses this ability far more pervasively
|
|
than high-level languages can.
|
|
|
|
<p/>Support for various data structures: heterogeneous compound types called
|
|
<a href='html/030container.cc.html'><em>containers</em></a>, akin to records
|
|
or structs, homogeneous <a href='html/032array.cc.html'>arrays</a> of a single
|
|
type of value (type <tt>array</tt> conventionally abbreviated as <tt>@</tt>),
|
|
and <a href='html/033exclusive_container.cc.html'><em>exclusive containers</em></a>,
|
|
akin to C unions but with a tag so each value knows its ‘kind’.
|
|
Out of these primitive types, Mu builds the usual and growing menagerie of
|
|
data structures: <a href='html/064list.mu.html'>linked lists</a> permitting
|
|
fast insertion and deletion and unidirectional scanning but slow search;
|
|
<a href='html/065duplex_list.mu.html'><em>duplex lists</em></a> that permit
|
|
bidirectional scanning; <a href='html/070table.mu.html'>associative arrays or <em>tables</em></a>
|
|
for fast insertion, deletion and search using <a href='html/069hash.cc.html'>hash</a>
|
|
functions; <a href='html/066stream.mu.html'><em>streams</em></a> for scanning
|
|
through strings incrementally; and <a href='html/061text.mu.html'><em>buffers</em></a>
|
|
for gradually constructing long strings in a piecemeal fashion.
|
|
|
|
<p/>Dynamic memory management: Mu supports <a href='html/034address.cc.html'>allocating</a>
|
|
space at run-time as pointers or <em>addresses</em>. All Mu instructions can
|
|
dereference or <a href='html/035lookup.cc.html'><em>lookup</em></a> addresses
|
|
of values in addition to operating on regular values. These addresses are
|
|
manually managed like C, and can be reclaimed using the <a href='html/037abandon.cc.html'><tt>abandon</tt></a>
|
|
instruction. To ensure that stale addresses aren't used after being
|
|
abandoned/reused, each allocation gets a unique <em>alloc id</em> that is also
|
|
stored in the address returned. The lookup operation ensures that the alloc id
|
|
of an address matches that of its payload. This eliminates a whole class of
|
|
undefined behavior and security vulnerabilities that plague C. Compared to
|
|
Rust, Mu pays some additional runtime cost in exchange for C-like flexibility
|
|
(you can copy addresses around all you like, and write from any copy of an
|
|
address) and simpler implementation (no static analysis). Mu by convention
|
|
abbreviates type <tt>address</tt> to <tt>&</tt>.
|
|
|
|
<p/>Support for higher-order recipes that can pass <a href='html/072recipe.cc.html'>recipes</a>
|
|
around like any other value.
|
|
|
|
<p/>Support for running multiple functions concurrently using <a href='html/073scheduler.cc.html'><em>routines</em></a>,
|
|
for communicating between routines using <a href='html/075channel.mu.html'><em>channels</em></a>,
|
|
and for <a href='html/074wait.cc.html'>synchronizing</a> between routines.
|
|
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.
|
|
Mu provides safe concurrency by forbidding routines from sharing addresses;
|
|
writing to a channel always performs a <a href='html/071deep_copy.cc.html'>deep copy</a>
|
|
that preserves all internal aliasing.
|
|
|
|
<p/>Support for <a href='html/076continuation.cc.html'>delimited continuations</a>
|
|
that let one pause and resume sub-computations.
|
|
|
|
<p><b>Part III</b>: transforms to make Mu a little more expressive, and give
|
|
it some of the benefits of a high-level language.
|
|
|
|
<p/><a href='html/040brace.cc.html'>040brace.cc</a> and
|
|
<a href='html/041jump_target.cc.html'>041jump_target.cc</a>: how Mu provides
|
|
structured goto-less programming without introducing the syntax of
|
|
conditionals and loops other languages require.
|
|
<br/><a href='html/042name.cc.html'>042name.cc</a>: how Mu transforms variable
|
|
names to raw memory addresses.
|
|
<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
|
|
‘local variables’ 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/046check_type_by_name.cc.html'>046check_type_by_name.cc</a>:
|
|
a transform to deduce missing types in instructions on the basis of
|
|
previous instructions in the same function.
|
|
<br/><a href='html/050scenario.cc.html'>050scenario.cc</a>: Mu's first syntax
|
|
— not for code but for tests. (<a href='html/051scenario_test.mu.html'>example</a>)
|
|
<br/><a href='html/052tangle.cc.html'>052tangle.cc</a>: support for layers in
|
|
Mu programs. They've been so good to us.
|
|
<br/><a href='html/053recipe_header.cc.html'>053recipe_header.cc</a>:
|
|
a new syntax for summarizing the number and types of ingredients and products
|
|
a function expects at the top next to its name, in a <em>header</em>.
|
|
<br/><a href='html/054static_dispatch.cc.html'>054static_dispatch.cc</a>:
|
|
allowing multiple variants of a function to coexist as long as each has a
|
|
unique header.
|
|
<br/>Support for generic or <em>shape-shifting</em> <a href='html/055shape_shifting_container.cc.html'>data structures</a>
|
|
and <a href='html/056shape_shifting_recipe.cc.html'>recipes</a>, containing
|
|
wildcard type ingredients that start with an ‘_’. Everytime you
|
|
use a shape-shifting recipe with a new set of ‘concrete’ types
|
|
for its type ingredients, it creates a new variant of the recipe for you
|
|
matching those types.
|
|
<br/><a href='html/057immutable.cc.html'>057immutable.cc</a>, a static analysis to
|
|
ensure that functions never modify anything but their products.
|
|
|
|
<p><b>Part IV</b>: Miscellaneous.
|
|
|
|
<p/><a href='html/061text.mu.html'>061text.mu</a>: strings in Mu are
|
|
bounds-checked rather than null-terminated. They're also unicode-aware (code
|
|
points only; no control characters, no combining characters, no
|
|
normalization). Mu recipes that take strings can take literal strings thanks
|
|
to a <a href='html/060rewrite_literal_string.cc.html'>transform</a> that
|
|
allocates them on the heap.
|
|
<br/><a href='html/062convert_ingredients_to_text.cc.html'>062convert_ingredients_to_text.cc</a>:
|
|
a convenience transform primarily intended to provide the illusion of dynamic
|
|
typing when adding to the trace. The <span style='font-family:courier,fixed'>stash</span>
|
|
command can print any number of ingredients of any type into the trace. Its
|
|
default output format is fairly simplistic, but it can be overridden for
|
|
arbitrary types by defining a variant of the <a href='html/058to_text.cc.html'><span style='font-family:courier,fixed'>to-text</span></a>
|
|
function with an ingredient of the appropriate type. For example, see
|
|
<a href='html/064list.mu.html'>064list.mu</a> which defines how we trace
|
|
lists.
|
|
<br/><a href='html/067random.cc.html'>067random.cc</a>: a random-number
|
|
generator with a <a href='html/068random.mu.html'>testable</a> interface.
|
|
|
|
<p><b>Part V</b>: Primitives for interfacing with hardware.
|
|
|
|
<p/><a href='html/080display.cc.html'>080display.cc</a>: primitives for
|
|
accessing the keyboard and screen.
|
|
<br/><a href='html/081print.mu.html'>081print.mu</a>: helpers that can swap
|
|
the real screen with fake ones for testing.
|
|
<br/><a href='html/082scenario_screen.cc.html'>082scenario_screen.cc</a>:
|
|
writing tests that check what is printed to screen.
|
|
(<a href='html/083scenario_screen_test.mu.html'>examples</a>)
|
|
<br/><a href='html/084console.mu.html'>084console.mu</a>: helpers that can
|
|
swap the real keyboard and mouse with fake ones for testing.
|
|
<br/><a href='html/085scenario_console.cc.html'>085scenario_console.cc</a>:
|
|
writing tests for keyboard and mouse using the fakes.
|
|
(<a href='html/086scenario_console_test.mu.html'>examples</a>)
|
|
<br/><a href='html/087file.cc.html'>087file.cc</a>: primitives for accessing
|
|
the file system.
|
|
<br/><a href='html/088file.mu.html'>088file.mu</a>: helpers that permit
|
|
swapping a fake filesystem or <tt>resources</tt> object for testing.
|
|
<br/><a href='html/089scenario_filesystem.cc.html'>089scenario_filesystem.cc</a>:
|
|
writing tests for filesystem using the fakes.
|
|
(<a href='html/090scenario_filesystem_test.mu.html'>examples</a>)
|
|
<br/><a href='html/091socket.cc.html'>091socket.cc</a>: primitives for
|
|
accessing the network.
|
|
<br/><a href='html/092socket.mu.html'>092socket.mu</a>: helpers for the
|
|
network. In Mu you create a fake network ‘neighborhood’ the same
|
|
way you create a fake local file system.
|
|
|
|
<p/><a href='html/029tools.cc.html'>029tools.cc</a>: various primitive
|
|
operations to help with testing and debugging.
|
|
<br/><a href='html/100trace_browser.cc.html'>100trace_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><b>Part VI</b>: An environment that watches programmers as they
|
|
manually test their code, and turns these interactive sessions into reproducible
|
|
test scenarios. The <a href='https://github.com/akkartik/mu/blob/master/edit/Readme.md'>readme for the app</a>
|
|
contains instructions for running it. Stop loading after each of these layers
|
|
to get a working version with just fewer features.
|
|
|
|
<p/><a href='html/edit/001-editor.mu.html'>edit/001-editor.mu</a>: data
|
|
structures for a text editor widget. Load just this layer to see just the
|
|
rendering and line-wrapping at work.
|
|
<br/><a href='html/edit/002-typing.mu.html'>edit/002-typing.mu</a>: support
|
|
for moving the cursor anywhere with the mouse and typing text in there.
|
|
<br/><a href='html/edit/003-shortcuts.mu.html'>edit/003-shortcuts.mu</a>:
|
|
support for various keyboard shortcuts for manipulating text you've typed in.
|
|
<br/><a href='html/edit/004-programming-environment.mu.html'>edit/004-programming-environment.mu</a>:
|
|
combining two text editor widgets, one on the left, one on the right.
|
|
<br/><a href='html/edit/005-sandbox.mu.html'>edit/005-sandbox.mu</a>: support
|
|
for running Mu code in the right-hand widget using code from the left, and
|
|
displaying results in a <em>sandbox</em> below on the right. You can have
|
|
multiple sandboxes, and hit F4 to rerun them all at any time with the latest
|
|
version of the code on the left side.
|
|
<br/><a href='html/edit/006-sandbox-copy.mu.html'>edit/006-sandbox-edit.mu</a>:
|
|
click on the 'copy' button in each sandbox to duplicate its contents.
|
|
<br/><a href='html/edit/007-sandbox-delete.mu.html'>edit/007-sandbox-delete.mu</a>:
|
|
support for the 'delete' button in each sandbox.
|
|
<br/><a href='html/edit/008-sandbox-edit.mu.html'>edit/008-sandbox-edit.mu</a>:
|
|
click on the 'edit' button of each sandbox to pop its back into the sandbox
|
|
editor. Basically like copying and then deleting a sandbox.
|
|
<br/><a href='html/edit/009-sandbox-test.mu.html'>edit/009-sandbox-test.mu</a>:
|
|
click on the results of a sandbox to turn them green and save the output as
|
|
golden/expected. Any future changes to the output will then be flagged in red.
|
|
<br/><a href='html/edit/010-sandbox-trace.mu.html'>edit/010-sandbox-trace.mu</a>:
|
|
click on code in a sandbox to open up a drawer containing its trace. The trace
|
|
can be added to using the <span style='font-family:courier,fixed'>stash</span>
|
|
command, which can be extended to render arbitrary data structures by creating
|
|
new variants of the <span style='font-family:courier,fixed'>to-text</span>
|
|
recipe for the appropriate types.
|
|
<br/><a href='html/edit/011-errors.mu.html'>edit/011-errors.mu</a>:
|
|
support for rendering errors on both the left and in each sandbox.
|
|
<br/><a href='html/edit/012-editor-undo.mu.html'>edit/012-editor-undo.mu</a>:
|
|
support for undo in the editor widget.
|
|
|
|
<hr>
|
|
|
|
<p>
|
|
The zen of Mu:
|
|
<ul>
|
|
<li>traces, not interfaces
|
|
<li>be rewrite-friendly, not backwards-compatible
|
|
<li>be easy to port rather than portable
|
|
<li>global structure matters more than local hygiene
|
|
</ul>
|
|
|
|
<p>
|
|
Mu's vision of utopia:
|
|
<ul>
|
|
<li>Run your devices in 1/1000th the code.
|
|
<li>1000x more forks for open source projects.
|
|
<li>Make simple changes to any project in an afternoon, no matter how large it is.
|
|
<li>Projects don't slow down with age, they continue to evolve just as fast as
|
|
when they were first started.
|
|
<li>All software rewards curiosity, allowing anyone to query its design
|
|
decisions, gradually learn how to tweak it, try out increasingly radical
|
|
redesign ideas in a sandbox. People learn programming as an imperceptible side
|
|
effect of tinkering with the projects they care about.
|
|
<li><a href='http://akkartik.name/post/habitability'>Habitable</a> digital environments.
|
|
<li>A <em>literate</em> digital society with widespread skills for
|
|
comprehending large-scale software structure and comparing-and-contrasting
|
|
similar solutions. (I don't think anybody is literate by this definition
|
|
today. All we can do easily is read our own programs that we wrote recently.)
|
|
</ul>
|
|
|
|
<p style='margin-bottom: 2em'/>
|