XOmB+Djehuty: a Remix OS for Computation Liberation

XOmB+Djehuty: a Remix OS for Computation Liberation

Presented with wolfwood - The open source world has been built on the promise of easier access to improvements, however code has not seen the type of remix culture one would expect to have naturally occurred. We present a design for a new system that encourages remix over reinvention.

45cf72d0b5611b4372b8367759882b93?s=128

wilkie

May 23, 2013
Tweet

Transcript

  1. 2.

    Look. Open source is amazing. • the most important idea

    in software development • results in not just tools, but a shared understanding of how they work, how to improve them • the fruits of open source run the internet
  2. 3.

    UNIX: the first Remix OS • the oldest OS design

    still in widespread use (40+) • highly influential in the design of all subsequent OSes (files, anyone?) • the first major open source project • a series of unfortunate events... then, Linux!
  3. 4.

    UNIX-style Remix wolfwood@valkyrie ~ (valkyrie ) $ ps PID TTY

    TIME CMD 25135 pts/2 00:00:00 zsh 27949 pts/2 00:00:00 emacs 28038 pts/2 00:00:00 ps wolfwood@valkyrie ~ (valkyrie ) $ kill 27949 • if you do something twice, Script It!
  4. 5.

    UNIX-style Remix, Cont'd wolfwood@valkyrie ~ (valkyrie ) $ ps |

    grep emacs 28816 pts/2 00:00:00 emacs wolfwood@valkyrie ~ (valkyrie ) $ ps | grep emacs | awk '{print $1}' 28816
  5. 6.

    UNIX-style Remix: Putting It All Together wolfwood@valkyrie ~ (valkyrie )

    $ ps | grep emacs | awk '{print $1}' | xargs kill [1] + 28816 exit 15 emacs wolfwood@valkyrie ~ (valkyrie ) $ pkill emacs [1] + 31376 exit 15 emacs • but, pkill was so useful it got rewritten in C instead of a script... no more reuse/remix
  6. 7.

    However... • Linux is just a reimplementation of UNIX •

    Linux "evolves" only by adding layers on top of a rather large foundation decided upon 40 years ago • Can Linux be guided by the needs of individual users, or only large organizations due to its size?
  7. 8.

    The Failed Democratization of Computing • remember that awesome internet?

    why aren't we (systems programmers) modelling it?
  8. 9.

    Redesign the Stack! • make the foundation as small as

    possible • allow finer grained control: reduce control -> increase possibility (aka flexibility) • enable replacing of components over layering abstractions
  9. 10.

    UNIX: its all about lying • processes live in an

    imaginary computer ◦ virtual memory ◦ illusion of continuous execution
  10. 11.

    Interrupts • interrupts are how computers handle changes to external

    state (key presses, incoming network traffic, etc) • the UNIX model is that all device interaction is managed in the OS and fed to applications only incidentally through abstractions (read data from disk, get suspended, get woken up when data is ready)
  11. 12.

    Foundation: XOmB Kernel • kernel does as little as possible

    • kernel attempts to push device arbitration to applications • kernel gets out of the way of application developers and lets them make decisions about their stack • trust non-kernel things when safe to do so, don't hoard power
  12. 13.

    What Comes of Flexibility? • UNIX has to save and

    restore all CPU state when an interrupt occurs to preserve The Lie • XOmB merely informs a process when an interrupt occurs ◦ process can make better decisions, perhaps saving less state • the system can only get faster due to cooperation
  13. 14.

    Building upon a new platform Anything not performed by the

    kernel will be implemented by application developers. They have full control. Given that, we must build an OS that allows each individual the most power.
  14. 15.

    Djehuty: A platform for the public domain Goals: • Federated

    • Individual has influence • Good ideas propagate, bad ideas don't
  15. 16.

    Breaking Things Down Modern Open Source is about implementing what

    already exists. It should be about refactoring for reuse. (code remix) You can build more with smaller blocks. So, break big things down to small things.
  16. 17.

    Let's Sort Example! Let's teach a computer how to sort:

    We describe an interface You start with a name: "sort" You tell it what information it needs: "a list" You tell it what information it represents: "a list" sort(list) -> list
  17. 18.

    Specifications Well, it could... give us any list. So, let's

    tell it what the result should look like. Give it rules that describe its behavior: • Every item should be at least as large as the item that precedes it Computer now knows: Ascending order!
  18. 19.

    Implementations Now somebody can write the code sort(list A) ->

    list { for i ← 1 to i ← length(A)-1 { valueToInsert ← A[i] A[i]=A[holePos] is now empty holePos ← i while holePos > 0 and valueToInsert < A[holePos - 1] { A[holePos] ← A[holePos - 1] holePos ← holePos - 1 } A[holePos] ← valueToInsert } return A }
  19. 20.

    Federation Distribute the system as a cooperative mesh: Each node

    is equal Social network? Share data, code, configurations, performance information
  20. 21.

    Adding Rules Absolutely anybody could come along and add a

    new rule: • Items of equal value maintain their original position This limits what implementations are deemed acceptable. This change may propagate if it is advantageous.
  21. 22.

    This system... Has a foundation that gives power to applications

    (XOmB) Has an OS that gives that power to the individual (Djehuty) Everyone has equal power to change the API, the rules, and implement something new Every individual has control
  22. 23.

    The result of which... Will remove much of the human

    opinion that impedes progress. Will aid in diversity by opening up control to those underrepresented in the open source world. Lower the barrier of entry and cost of owning and maintaining a system for developing cultures.