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
- Objects
- Meta Object Protocol with a proper meta layer (see Brancha’s work
cc @christophe)
- Meta Object Protocol with a proper meta layer (see Brancha’s work
- 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?) - Consensus in system
- Protocols around consensus to make every event timing programmable
(on tx verify, on block creation, etc etc etc.)
- Protocols around consensus to make every event timing programmable
- 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
- An upgrade protocol for how code reacts to new code being pushed,
- 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.
- Mechanisms for discovery of peers and services
- This may be more useful in the networking section below
- 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.
- We should have very clear ideas on how people can share
- 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.
- Data is open within my local domain… how do we stop other
- 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.
- This gets into security as well and how and where should we
- Engines in system.
- A protocol like how Genserver is a protocol around Engines. Also
Supervisors.
- A protocol like how Genserver is a protocol around Engines. Also
- 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.
- I want to visualize how our topologies look like, how our code
- A condition system for Anoma Level, generally every single thing
- 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?)
- 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!!!
- Urbit has once only delivery semantics, which is nice meaning on
- 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?
- Is it possible to simplify it further? (the OO investigation
- 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.)
- 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.