The current story for developers is "meh", so these items help improve and modernize the developer experience.
project
IP
milestones/description
vs code extension
X
(1.) Syntax highlighting, (2.) Language server protocol (LSP) - local
sublime extension
Since sublime is so fast, try to get core Adama language support for syntax highlighting
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.
iOS client
(1) Write a simplified web-socket interface, (2) implement interface with ?, (3) update apikit code generator to produce a SDK talking to the web socket interface.
capacitor.js template
A template to turn an RxHTML project into a mobile app with deployment pipeline
integrate-linter
integrate the linter to detect issues prior launch; address #62
The online web portal needs a lot of work to be useful.
The web portal should be upgraded to provide a manager view along with tools to get started along with steps to make progress.
project
IP
milestones/description
render-plan
Render and explain the deployment plan
render-routes
Render and explain the routing including both rxhtml and web instructions
better-debugger
X
The debugger sucks
support fbauth
metrics
A metrics explorer
service calls
A way to explore which documents are making which service calls and the results
Tables 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-graph
Tables should be able to become hyper graphs for efficient navigation between records using a graph where edges can be annotated (this maps)
full-text-naive
X
string =? string is a full text operator that is naive
full-text-index
introduce full indexing where records describe a rich query language
dynamic-order
introduce a special command language for runtime ordering of lists
dynamic-query
introduce a special language for queries to be dynamic
math-matrix
The type system and math library should come with vectors and matrices out of the box
2d-primitives
circle, rectangle
xml support
Convert messages to XML
metrics emit $num;
X
The language should have first class support for metrics (counters, inflight, distributions)
metrics emit $string;
The language should support emitting tags with metrics to help shred and classifiy metrics
auto-convert-msg
the binding of messages can be imprecise, need to simplify and automate @convert primarily for services
bubble + privacy
X
Add a way to annotate a bubble with a privacy policy to simplify privacy logic
privacy-policy caching
X
instead of making privacy policies executable every single time, cache them by person and invalidate on data changes
table-protocol
introduce a way to expose a table protocol for reading and writing tables via a data-grid component
sum/bag types
a sum type is going to be a special type of message
auto-convert
auto convert messages to dynamic
normalize messages
messages of the same structure should auto convert
proper-lambdas
X
I should be able to accept functions as argruments to other functions
extension methods
Extend every message/record based on a structural pattern
message filtering
Apply rules for parsing messages like "trim/lowercase" to help ensure only valid data enters system
message aborts
Apply simple rules to reject messages that are invalid
enum E {Aa, Ab, B, C}
bag<E> B {
A* {
int x;
}
B {
int x;
int y;
}
C { }
}
The bag creates a record with the union of all fields along with various along with a virtual type for each instance which maps to the appropriate subset.
We can derefence it via a match
B my_bag;
#sm {
match B as o {
A* {
o.x = 123;
}
B {
o.x = 42;
o.y = 7;
}
C {
}
}
}
Implicitly a bag has a type of the enumeration, and ingestion would be the way to set the type along with parameters.
my_bag <- {type: E::Aa, x: 42};
This will typecheck that the bag has everything needed and will clear other fields out. This is all sketch work, but the key design goal is to provide some degree of compact representation of data based on the kind of a thng.
(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 log
Implement a log data structure that can heal (anti entropy) across machines using Adama's network stack
raft
Implement raft leader election and log append using Adama's network stack
the 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-search
provide a "between document" search using replication tech
replication-graph
similar to search, replicate part of the document into a graph database
metrics
X
documents should able to emit metrics
fix-keys
X
document 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 (core work done, need to remove old code)
op-query-engine
X
a tool to debug the status of a document live
portlets
maybe part of replication, but a subdocument that can emit messages that are independent subscriptions (for SSE/MQTT) and for Adama to consume
adama-actor
X
implement Adama as a special first class service
twilio-service
implement twilio as a first party service
stripe-service
X
implement stripe as a first party service
discord-service
implement discord as a first party service
slack-service
implement slack as a first party service
http-service
study postman and design a generic HTTP service for third party integration
results-stream
figure out how to ensure deliveries can overwrite prior entries
portlets - passive net
if we express the desigre for a result to hold the stream results for a foreign document's portlet then this creates a graph such that documents need to be reloaded. that is, we need a persistent subscription
firebase - notifications
we should be able to send notifications
document filter
X
instead of relying on privacy and wasting compute, a viewer should be able to opt into which fields to view.
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?"
project
IP
milestones/description
headwindcss
Port tailwindcss to Java for vertical control
components
X
Bring clarity for single javascript extentions for new controls
time
X
Custom component for selecting a time of day (Blocked on components model)
date
X
Custom component for selecting a date or a date range (Blocked on components model)
color
X
Custom component for selecting a color (Blocked on components model)
graph
Custom component with rich config to visualize graphs
server-side
Create a customized shell for each page such that server side rendering allows faster presence
convert-react
Convert the RxHTML forest into a complete React app
gc
figure out if there is still a bug with "rxhtml fire delete" isn't cleaning up pubsub
remove-col
remove the rxhtml column from the spaces column and move into document; #127
auto-ids
A big pain point in HTML is the pair bonding of label to input via id.
typechecker
A tool to validate an RxHTML forest doesn't have issues
ai-tester
A browser extension to walk and validate a site is working and collecting tracking tokens
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.
project
IP
milestones
design document
design a simple XML only way to build Android applications using reactive data binding similar to RxHTML