abstract.txt

XOmB+Djehuty: A Remix OS for Computation Liberation

In the world of software, most developers are building upwards and
losing sight of the cyber-centuries worth of cruft below, which we
call the Operating System: the final arbiter of access, privilege and
resource allocation on all computers. These systems are developed by a
shrinking community that has ceded us a particular approach to
resource management that parallels the power structure present in
their community and society at large. It has been observed
(http://en.wikipedia.org/wiki/Conway's_law) that there is a strong
relationship between the communities of software creators and the
organization of that software itself.

Most operating systems are self described as a Benevolent Dictatorship
where Linus Torvalds or Steve Jobs decide on behalf of all
users. These hierarchical structures inhibit software developers'
understanding of how software can affect a diverse community of
potential users and the problems they wish to solve.

The internet demonstrates the value of organization that radically
differs from centralized models. While the open source community has
created a variety of peer-to-peer tools, organizations of developers
still practice centralized management. A truly decentralized software
infrastructure will help more communities solve problems more
effectively.

We believe that to provide an open environment conducive to all
solutions we must drastically re-envision our software
infrastructure. These sweeping changes must begin at the bottom,
framing not only all software built on top, but also the social
structures responsible for creating such software. To this end, our
small, simple and stateless XOmB kernel is merely a reflection of the
underlying hardware and it imposes no undue structure upon the
software that uses it as a foundation.

We look at the open source culture as one that is ripe for remix, but
disappointingly most code modification is done within the structures
and conventions established by the original authors. We do not want to
simply swap out the existing foundation (Windows/Linux), but to
replace the entire software stack. The prevailing fear is that this
task can only be completed by rewriting all of software, yet this is a
misunderstanding based upon a cultural refusal to remix parts of
existing code.

While it seems strange, many open source authors are very possessive
and resent radical reappropriation of their code. Authors aggressively
fight against requests for improved flexibility under various
guises. Contributors are often very respectful of the authors' bounds,
especially those enforced by copyright. Since software and
organizational bounds are difficult to overcome, users create new
projects or clone existing ones with new goals. This effort to expand
horizons should be lauded, instead the culture sees this act as
aggressive and competitive.

Djehuty is a framework for software remix atop the XOmB kernel. It
will promote radical experimentation that would otherwise require an
infeasible amount of effort to simply get to the point where the
project's efficacy can be evaluated. Djehuty is focused on minimal
computational behaviors over coarse-grained software products.

Some technical problems are really social problems, therefore some
social problems in our community have technical solutions.

tech.txt

Note: We intend to present using a hypermedia slidedeck. Considering
the strong coupling between the social and technical content, we could
make use of two projectors/screens to make this more visual, but this
is not essential.

The software project is divided into two components: a low-level
kernel and a collection of code that defines a set of computational
behaviors and their expectations. The low-level component, called XOmB
(http://xomb.org), is a small, stateless kernel that makes up initial
code your computer executes. It assumes nothing about your purpose
and exposes only the hardware that your machine has available, hence
the pronunciation of 'zombie.'

Our presentation will demonstrate the traditional expectations of such
software, in that a kernel is typically a program that is responsible
for delegation of authority for actions taken by other software. We
will take a look at how this constitutes an unreasonable lack of trust
in software and how this becomes an obstacle to experimentation with
alternative means of organizing software and driving diverse solutions
through general computation.

We will not shy from explaining the technical workings but we will do
so with the aid of illustrations that are easy for the uninitiated to
understand. Our presentation will cover the bridge between hardware
and software, the fine line between security and efficiency,
and the logical path from power-up to running a program you have
written.

Once you are at the stage where your system can run an arbitrary
program written by another, our next component,
Djehuty (http://djehuty.org), will make the most
of our existing tools in order to lower the difficulty for the average
user of finding existing code that addresses their task. To that end,
we will establish an organizational model for software that strives to
define software not by its end-goal, as it would be for a product, but
rather by the set of behaviors it uses to accomplish that goal. Our
software infrastructure is a formal language describing behavior, the
expected, and the expectation of their output.

This organization effectively separates code into its smallest
functional units. Now, useful code that typically exists within
obtrusively large codebases is available to you. In fact, initial
implementations of behaviors will be established by deconstructing
existing open source projects in a similar vein to the remix culture
in other forms of media. These large codebases can now be rebuilt using
a set of these smaller units. However, and more importantly, new large
codebases can be constructed with minimal effort by combining behaviors
from other projects.

In our presentation we will highlight both the social and technical
advantages to this organizational model. Namely, the ability to lower
the barrier of entry to computation and the excising of the traditional
role of authority over code, its use, and its influence. There will be
a focus on how to ensure security and reliability with a peer-to-peer
model of code sharing and how we can automate the building of entire
computer systems from the ground-up.