This document is a living road map of the Adama Platform. As such, it contains the investment details for the entire vision and future products.

Developer relations & adoption

The current story for developers is "meh", so these items help improve and modernize the developer experience.

vs code extension(1.) Syntax highlighting, (2.) Language server protocol (LSP) - local, (3) LSP - cloud, (4) new ".adama.deploy" file to have 1-click shipping
sublime extensionSince sublime is so fast, try to get core Adama language support for syntax highlighting
improve command line experienceX(1) Create a new "micro-language" for defining the CLI api to leverage code generation, (2) use language to create new execution framework, (3) shell prediction and completion, (4) address issues #130, #132, #133, and #134
Android client(1) Write a simplified web-socket interface, (2) implement interface with OkHttp, (3) update apikit code generator to produce a SDK talking to the web socket interface.
bootstrapBuild a tool to bootstrap an RxHTML application from an Adama file
integrate-linterintegrate the linter to detect issues prior launch; address #62
lib-reactlibrary to use Adama with React
lib-vuelibrary to use Adama with Vue
lib-sveltelibrary to use Adama with svelte
js-client-retryIndividual retries per document


kickoff demosSee for more information
client-walkA detailed walkthough about how to use the client library, the expectations, and core APIs
improve overviewMake the overview easier to understand, more details, etc
detailed tourConvert the video to an online document
cheat-sheetdocument the vital aspects of the language and provide copy-pasta examples
micro-examplesa mini stack-overflow of sorts
tutorial-appwalk through the basics of building an Adama with just Adama and RxHTML
tutorial-twiliobuild a twilio bot as an example with details on calling services
tutorial-weba HOWTO host a static website with Adama
tutorial-domaina HOWTO use Adama's domain hosting support
zero-heroa breakdown of using the bootstrap tooling to build a complete app
feature-complexWrite about complex number support
feature-maybe(1) write about how maybes work, (2) write about maybe field deref, (3) write about math and maybe
feature-listswrite more lists
feature-mapwrite about map transforms
feature-dynamicwrite about dynamic types
feature-viewerwrite about @viewer
feature-contextwrite about @context
feature-webwrite about @headers / @parameters
map/reduce-loveXreduce love along with maps
functionsprocedure, aborts, functions, methods
enumeration/dispatchtalk about dispatch
feature-servicestalk about services and linkage to first party
feature-asynctalk about async await,decide,fetch, choose, and result
result typetalk about the result type
feature-smtalk about the state machine, invoke, transition, transition-in
web-puttalk about the web processing

Standard Library

statsbuild out a statistics package that is decent

Web management

The online web portal needs a lot of work to be useful.

render-planRender and explain the deployment plan
render-routesRender and explain the routing including both rxhtml and web instructions
better-debuggerThe debugger sucks
support fbauth
metricsA metrics explorer

Contributer Experience

If your name isn't Jeff, then the current environment is not great.

shell script loveImprove the build experience outside of Ubuntu
test MacOSWork through issues with unit tests on MacOS and any productivity issues with the python build script
local modeAdama should be able to run locally with a special version of Adama just for applications and local development
faster unit testsImprove the testing to not leverage shared resources (stdout, cough) such that testing can be made parallel
write documentation about structureWrite a document to outlining the high level mono-repo structure


The language is going to big with many features!

break-top-downXThe lexocongraphical ordering of typing is problematic, #126
index-tensorTables should be indexable based on integer tuples. Beyond efficiency, language extensions can help work with tables in a more natural array style (think 2D grids)
index-graphTables should be able to become hyper graphs for efficient navigation between records using a graph where edges can be annotated (this maps)
full-text-indexintroduce full indexing where records describe a rich query language
dynamic-orderintroduce a special command language for runtime ordering of lists
dynamic-queryintroduce a special language for queries to be dynamic
math-matrixThe type system and math library should come with vectors and matrices out of the box
xml supportConvert messages to XML
rxhtml-staticEmbed rxhtml into compile process
rxhtml-dynamicEmbed rxhtml as a first class language feature
metrics emit id;The language should have first class support for metrics (counters, inflight, distributions)
auto-convert-msgthe binding of messages can be imprecise, need to simplify and automate @convert primarily for services
bubble + privacyAdd a way to annotate a bubble with a privacy policy to simplify a privacy
privacy-policy cachinginstead of making privacy policies executable every single time, cache them by person and invalidate on data changes
table-protocolintroduce a way to expose a table protocol for reading and writing tables via a data-grid component
sum typesa sum type is going to be a special type of message

Infrastructure - Protocols

For integration across different ecosystems, there are more protocols to bridge gaps.

mqtt(1) Write design document how to adapt Adama to MQTT, (2) Build it with TLS, (3) Built it with plain-text
sse(1) Write design document how to adapt Adama to Server-Sent Events, (2) Build it with TLS

Infrastructure - Enterprise data

smaller deltas(1) Define a log format that leverages binary serialization and compacts field definitions, (2) convert JSON deltas to binary in the logger to measure impact (throughput and latency), (3) leverage format upstream to minimize future network
healing logImplement a log data structure that can heal (anti entropy) across machines using Adama's network stack
raftImplement raft leader election and log append using Adama's network stack
control plane(1) Manual definition of raft shards definitions, (2) automatic machine management

Infrastructure - Globalize control plane

design document for replacing Database with a serviceA key part of going multi-region is factoring out the database
security document for exposing the control plane to the internet

Infrastructure - Multi-region & massive scale

At some point, Adama is going to be at the edge with hundreds of nodes across the world.

diagramdiagram the usage of the database in the adama service
billinghave billing route partial metering records to billing document ( and globalize )
proxy-modeproxy the WS API from region A to region B (or global important services )
spacial-homingglobalizing biases to regions, some spaces may be regional so make their index local to that region
remote-finderextend WS API to implement a Finder for region A to do core tasks (or globalize)
finder in adamaTurn core service into a finder cache for web tier
region-isolateAllow regions to have storage for local documents
capacity-globalglobalize capacity management
test-heat-capvalidate when an adama host heats up that traffic sheds
test-cold-capvalidate when an adama host cools off that traffic returns for density
cap-configmake high/low vectors dynamic configurable
ro-replica(1) introduce new observe command which is a read-only version of connect, (2) have web routes go to an in-region replica
reconcileevery adama host should be lazy with unknown spaces and also reconcile capacity if it should redeploy (due to missed deployment message)

Infrastructure - Core Service

Adama is a service.

env-bootstrapautomatic the memory and other JVM args
third-party replicationthe language should allow specification of a endpoint to replace a piece of data to on data changes. This requires maintaining a local copy in the document along with a state machine about status. The tricky bit requires a delete notification. There is also the need to load every document on a deployment.
replication-searchprovide a "between document" search using replication tech
replication-graphsimilar to search, replicate part of the document into a graph database
metricsdocuments should able to emit metrics
fix-keysdocument keys are stored with both private and public keys, and this is really bad; we should only store the public key and version the keys along with an expiry
op-query-enginea tool to debug the status of a document live
portletsmaybe part of replication, but a subdocument that can emit messages that are independent subscriptions (for SSE/MQTT) and for Adama to consume
adama-actorimplement Adama as a special first class service
twilio-serviceimplement twilio as a first party service
stripe-serviceXimplement stripe as a first party service
BUG: doc-idsneed to make the relationship between document id and key/space ironclad on adama service; it's possible to resurrect old data due to id resurrection
results-streamfigure out how to ensure deliveries can overwrite prior entries

Infrastructure - Web

Adama is a web host provider of sorts!

web-async putXallow PUTs to contain async calls
web-async deleteallow DELETEs to contain async calls
web-async getallow GETs to contain async calls
request cachingrespect the cache_ttl_ms
asset transformsimplement some basic asset transforms
web-abort put/deleteweb calls that write should support abort
@contextensure web operations can access context
web-metricsadd an API for the client to emit metrics
add auth for webthe principal for web* is currently @no_one; it should be a valid user
build delta accumulatorslow clients may be get overwhelmed, the edge should buffer deltas and merge them together

Infrastructure - Overlord

Overlord is how the fleet is managed and aggregator.

canaryfor testing the service health and correctness; overlord should maintain a constant state of various high-value API calls
operationalize-superthe "super" service needs a secure environment
ui for querydynamic queries
billing-sendSimplify the billing engine and remove the overlord need
ntplook into time sync


RxHTML is a small set of extensions to allow HTML to be dynamic on the fly. The spiritual question is "what minimal number of things does HTML need to build apps?"

headwindcssPort tailwindcss to Java for vertical control
componentsBring clarity for single javascript extentions for new controls
timeCustom component for selecting a time of day (Blocked on components model)
dateCustom component for selecting a date or a date range (Blocked on components model)
colorCustom component for selecting a color (Blocked on components model)
graphCustom component with rich config to visualize graphs
server-sideCreate a customized shell for each page such that server side rendering allows faster presence
convert-reactConvert the RxHTML forest into a complete React app
gcfigure out if there is still a bug with "rxhtml fire delete" isn't cleaning up pubsub
remove-colremove the rxhtml column from the spaces column and move into document; #127

Roslin (RxImage)

The vision is for a runtime just for games. See this post for more information

design documentWrite a design document from Jeff's notes
runtime-androidImplement a starting runtime for web using android
gameboard demo(s)Write a game board demo of various games
runtime-webImplement runtime for web using rust
rxhtml-integIntegrate runtime-web into RxHTML as a new component

Saul (RxApp)

Similar to RxHTML, the question is how to build a minimal runtime for iOS and Android applications. Tactically speaking, we can use RxHTML with capacitor.

design documentdesign a simple XML only way to build Android applications using reactive data binding similar to RxHTML