Hyperfiddle update Q2 2018

Sometimes, markdown plus a database is enough.

Hyperfiddle is Nginx for CRUD: infrastructure for making CRUD APIs and dashboards really fast without needing to know web development. Really shines at back-of-house UIs.
You specify your API as data (like Swagger), we serve it. You specify your frontend with markdown and some ClojureScript, we serve it. The frontend stuff is completely optional, you can bring your own, but ours is what you need to move fast in the beginning.

Here are pictures of the product evolving in first half of 2018.

Where we are today: July 2018, hyperfiddlin' the docs app

Hyperfiddlin' the docs app with markdown and a database. No Clojure code to be found! (That's a lie, there's a little bit for the nested sidebar rendering)

Where we were six months ago, Janurary 1, 2018 ish

Semantic options renderer. The :db.type/ref renderer uses :options as a rendering hint. Userland provided widgets can respect the hints, or implement new hints, or ignore them. So for example you could code up a paginated grid that looks for [:link/rel :next-page] and [:link/rel :prev-page]. 2017'Q4
In Jan we tried to do an open source release and found that the concerns were still too complected in subtle ways we hadn't realized. The fiddle-graph (API as a graph) is a critical primitive for performance. "API as a function" is still an internal primitive, but it is at a lower layer abstraction than the I/O runtime which needs to inspect the fiddle-graph to achieve reasonable performance. For example, the I/O runtime knows that it can lazy load popovers separately from the main page in some circumstances, and popover-ness is defined at the fiddle-graph layer. So we have to backtrack on the "API as a function" abstraction highlighted on our github.

Feb – First serious app

Cryptocurrency merchant invoicing app commissioned by a client. It has multi users, onboarding workflows, admin dashboards for account approvals and customer support dashboard. The right hooks for integration with blockchain and identity verification APIs.


Man we were so proud of this and it never saw the light of day. At the time it took about 2-3 man-weeks? Probably about a day now if 100% focused, we should time it.
The crypto startup went under over the course of a weekend. If you are a bitcoiner, TLDR is that Tether has become a huge problem. It's not the worst thing ever, because we learned a lot, proved out a revenue model and bought some time to fill in some potholes.
We also finally got rid of the base64 router, which broke our URLs with each evolution of the routing code, and was preventing us from blogging.

April – Hyperfiddle Markdown

The crypto dashboard taught us that when you want to stay scrappy and fast, thinking in HTML is the bottleneck. 90% dashboard work is about formatting information cleanly. What you need is text, very basic css classes, tables and forms, and take away all surface area for fiddling with little things that don't matter.


This particular example shows some of the limits of markdown. TodoMVC needs code reuse and thus is better done in ClojureScript. Basically, if you're building rectangular tables and forms, markdown lets you think less and code sleepy, but if you need code reuse or recursion, you want ClojureScript.
This is "Hyperfiddle Live", the embeddable editor for the tutorials. Here you also see controlling how the field value renderers with a cljs one-liner.
Markdown API wraps the ClojureScript API. The ClojureScript API is strictly more powerful, because it has a strong composition story for nested and recursive data. The Markdown API is simpler and faster, and encourages inline documentation.
Security: We model database ownership now so only authorized clients can transact. We don't yet have read side security yet, though it is coming. The simplest way to do security is to do what you would do with REST: authenticate fiddle endpoints and "bake" the fiddle-graph so e.g. all queries are fixed. There are much more interesting things we can do, such as provide Sharepoint/ActiveDirectory user-role-permission as an abstraction. Datomic database filters are an interesting opportunity to secure a database yet also allow unrestricted query access.
full page domain panel
First beta


hyperfiddle.data is the Data API. It is CLJC and used by both frontend (view) and backend (computing data dependencies). If you pass it a Reagent component, it accumulates up a view (and is fully reactive Reagent context!). The backend passes it a "request function" which accumulates up a bunch of Datomic queries. Pretty amazing that it works tbh. Most client/server architectures make you code data logic twice (once in the UI and once in the API), though people don't seem to recognize that for what it is, due to the frontend/backend dichotemy caused by team structure and language. For two years we maintained parallel data implementations, until finally we achieved enough clarity to unify them. Hi-five!
table implemented in terms of form, this is huge, because it's true composition with higher order functions. You can pass the view in from above. 2018'Q2
UI reified with core.match. You can provide your own. Just function composition
semantic css
fix reactions, codemirror etc
docs app, sidebar
user analytics
This is pretty much what hyperfiddlin' feels like, here I am live migrating my beta database. The clojurescript in the middle is building up a datomic transaction, which I copy/paste into the staging area to try out. 2018'Q2
Cross database query, with attribute renderers from markdown, and queries the active user from datalog 2018'Q2


Hot off the press and landed in master yesterday, July 16, automatic recursive/relational forms. This is SO important and proves that the composition story is true. The render function is fully abstract and composable, and you can fully control the view from above, for example pass a new field with your own core.match with your own semantic renderers. In one little expression.
Past updates:



Get in the beta: http://www.hyperfiddle.net/