Features for a Future Anoma

Preamble

I was asked for what features I want to see to see in a future Anoma. This list is not comprehensive by any means but covers the general direction I believe Anoma should evolve towards.

I’d be curious if there are any key features I’ve missed in these posts

An Initial List

  1. Objects
    • Meta Object Protocol with a proper meta layer (see Brancha’s work
      cc @christophe)
  2. Event system, and how messages play with events and how does the
    system interact with events (Urbit is an event based system… what
    does this mean for them and us?)
  3. Consensus in system
    • Protocols around consensus to make every event timing programmable
      (on tx verify, on block creation, etc etc etc.)
  4. Hot code upgrading for any user code (this includes consensus)
    • An upgrade protocol for how code reacts to new code being pushed,
      along with potential mechanisms in consensus that can dictate if
      updates get through
    • A protocol for how Objects react to hot code upgrading
  5. Identities
    • Needs to be in system
    • They should be an important mechanism on how trust etc etc
      works… I want plans around all of this and to understand it.
  6. Mechanisms for discovery of peers and services
    • This may be more useful in the networking section below
  7. More clear stories on how shared computation can be had (my idea
    of consensus and making machines proof of resources is one way and
    probably slow, is there a better way we can agree to having all
    machines work together?)
    • We should have very clear ideas on how people can share
      computation or discover themselves, I think these are all
      important for us to refine.
  8. System Privacy
    • Data is open within my local domain… how do we stop other
      programs from seeing certain data…
    • Do we have a lattice permission system?
    • We should allow local domain programs to share data, but we
      should be able to have security over it.
  9. Limited functionality interpreters… If Ι get data off the web
    I’d like to deserialize it safely (jam and cue are good!), however
    I’d like to also run the object code potentially in a sandboxxed
    interpreter with certain features cut.
    • This gets into security as well and how and where should we
      design it into the system.
  10. Engines in system.
    • A protocol like how Genserver is a protocol around Engines. Also
      Supervisors.
  11. Anoma Level
    • A condition system for Anoma Level, generally every single thing
      that can error on the system the user can fix himself (they don’t
      have to!), it doesn’t segfault like *nix.
    • An in-house GUI tool, we can start off using GT and make our own
      in system later
      • I want to visualize how our topologies look like, how our code
        looks like, write system monitors in this. It’s an important
        part for making the system shine like a real system.
  12. Global namespace
    • What is the path that we scry to get data from this global namespace?
    • How do we query across the network for who has what data?
    • How do I trust the answers I get? Are there any recourse
      (reputation loss?)
  13. What are our networking semantics like?
    • Urbit has once only delivery semantics, which is nice meaning on
      a shaky connection a file can still download… do we have
      anything like this? Users don’t have to write any exponential backoff
    • What networking facilities can we make life easy for users? Can
      we make good APIs that remove the annoyances people have to deal
      with global networks… I’d argue we have to do this as part of
      our semantics, so let us make this a good API for in system
      networking!!!
  14. Resource Machine
    • Is it possible to simplify it further? (the OO investigation
      will see if we leave any fields blank and we can argue why later)
    • How does “mutable” data references work and verifying data we
      put it in is the “latest”, does this even matter?
  15. Controllers
    • Can a controller subscribe to other controllers?
    • Can a controller be a validator to other controllers?
    • How do these kinds of computations work?
    • How would we register engines to run with a controller? Would
      every validator must run the engine and at specific timings can
      those processes run? (our fastest consensus will have no
      overloaded times for maximum throughput but most controllers
      will not care about being that fast.)
  16. A compelling narrative on distributed computation
    • I want to shuffle computation between all my computers in an simple way. We should probably combine our custom consensus system with our engine model of computation and give a way out of the box to easily do this and allow users to customize it for their needs.
    • In general I want to think about easy way to share resources of machines with each other, which I’m currently unsure of with my current understanding of the system.
2 Likes