# #nocode #title Fargo #/ #/

It’s been a long journey—three years in the incubation process, but I’m finally ready to start implementing “fargo”—the no-code platform I started researching years ago (before it was the trendy thing to do). In a sentence, Fargo is a programming language, platform, and a hybrid network, with three top priorities:

1. No BS, first-class, cost-free debugging—all processes are cached in a small JIT control plane, and when the program finishes, what I call a “process container” (not a debugger) is compiled in the background; since all procedure calls are networked and all arguments passed are semantically Golang-like channel types, it’s very easy to enter an interactive replay of your process (with guards for non-idempotent calls) and introspect the state of your container process, pause it, rewind it, execute steps from the CLI (process containers have a generated Ansible-like YAML playbook file), or even share a single file process container with a coworker (all network and I/O is inspired by Rx concepts, ZMQ, Tailscale, standards, etc, so it just works on a different network).

2. Fargo is a WASM first language, to be built on Rust on Gluon and is a pseudo and light weight OS/VM that works with a docker-like API. You can run a Fargo container anywhere any time—except in the browser because that’s not a goal, tough love -_-.

3. The IOTAP (Interplanetary Orthogonal Telepathy) protocol is what I call an L8 networking protocol transported over HTTP/2 (and one day H3) that is semantically just HTTP/1.1 and can have arbitrary multiplexed layers—where instead of code integrating with code with APIs—data just automatically integrates with data instead on request (how this works is beyond the scope of this message, ha). This means that you end up writing 90% less code and what would be otherwise a hoard of complex inoperable protocols magically know how to speak to each other. 100% of I/O is factored out of your business logic code, on both peer sides (client and server). Fargo uses the HCL2 DSL (developed by HashiCorp) to declaratively build new L8 protocols in a rather simple and hassle free way. In Fargo land, a peer negotiates and requests session WASM layer files (protocoled with Dat on the wire and a virtual transport and internally with IPFS) and the requester is the one whom executes the request—not the server (in some cases session image conjugates are made though for both). All requests are distributed and transactional and network partitioned by default (offline) by means of a few simple new HTTP methods such as STAGE, COMMIT, ROLLBACK, etc and a fancy way of figuring out how to magically go back in time i.e. collapse superimposed states—but no new funny concepts on either peer’s side to deal with—business code is just another day at work with tools you’ll learn to take for granted hopefully. Also, IOTAP is lazy and asynchronous, and works on a PULL/PUSH system where request images have web hooks—this allows for massively parallel requests and work is done when and as needed and only when needed. Data never leaves the network so to speak—it is stored locally in repos and virtual WASM containers but with remotes like in Git. The datatore control plane will be based on HashiCorps MemDB (but ported to Rust) and will use CSSQL (a slightly modified CSS query selector language) I designed so it’s as easy as JQuery in a sense (minus a stupid ORM—queries are compiled and live in one of possibly thousands of micro DBs locally) but offers an impressive graph store API with GraphQL views—but remember, everything in Fargo is just a eat-your-dogfood L8 way of life—so there will be a cssql:iota:// protocol which is adaptable. ASML (Atypical Semantic Markdown Language) is a data exchange format I’ve been drafting that you may have noticed in the title to this post—it’s that simple! It’s serializable to both JSON and XML and has three concepts: 1. Hypertags (a RFC 6920 inspired URI digest, with ASML record data, and a MIME hyper-workflow block, where the atomic unit of a datum is the hypersheet—all in one compact form, serializable to binary. The mystery of how these hyper-workflows is not exposed to the developer and are compiled from HCL2 much like a Dockerfile, but how you structure and represent your data is up to you! Most of the mystery of how this orchestra works is thankfully managed for you—all you need to learn is what you already know which is a docker-like API minus the daemon and special hardware virtualization that comes with it.

Farcry (the Fargo programming language) is not going to be mommy’s little boy—it’s mostly a subset of Rust and Gluon minus what is not necessary—but a little hard can be a lot good some times, like with Rust’s ownership model. It will be both procedural and functional minus the glue to make it work. Wasmer has been doing some great work and it is Fargo’s package manager, but Cargo will be used as well in tandem. All data is persisted to single file volumes (like SQLite) making exporting a project a breeze—and the Fargo CLI toolkit will be a single binary, yea!

Did I mention that all data is actually programmed to die? Yes, you heard right—all datums have vector clocks and JWT self-certifying block receipts, where an owning network agent decides the decay rate TTL or lease to a requester and eventually after N transmissions, the data scrambles and becomes worthless. Why? Because all information has entropy—it corrupts absolutely—just like power, like it or not given enough time—so I embraced that as a policy, plus no data leaks, DB crashes, and everything runs in a WASM sandbox. You can think of all datums as flowing from higher sources of truth, witch lattices of workflow processes, on the given network, where trust is determined based on the measure orthogonality and measure of entropy of the data—along with entity level encryption, based on topological, number and representation theory techniques I won’t bore you with here. What you should take away is that great care has been given to spare developers the time to get to work, without compromising the joy of building great new things.

By the way, what’s with the name “Fargo”? Fargo is derived from PHP’s Phar system, and the hidden goal of the project is to relieve PHP developers from their misery and occasional mild happy surprises. Fargo will make a great effort to offer an unparalleled toolkit built on the shoulders of giants and recent developments with PHP over the years. I have a decade of experience battling PHP and due to PHP 7.4’s new FFI and PHP 8’s JIT compiler and the nature of Fargo, PHP developers will be able to move on from these ridiculous MVC frameworks and over engineering in a what is basically an HTML templating language that grew up to be just like daddy Java (yes I had my own Java years way back when). I won’t go into too much detail here, but Composer projects will be supported, and interfacing with Fargo probably with stream wrappers—one of PHP’s better features—and of course Phars will be used to build apps in a virtual environment, no server needed, a la the lovely folks from phpbrew. Source code will be opcached and any data will be serialized when compiled using a parity of ES7’s syntactic import/export sugar (much like how babel works without the bazaar). Other than a static analysis tool, a la Phan, and a proper standard markdown documentation tool and auto-formatting, that will be my swan song to PHP, it’s the least I can do, ha. If it worn’t for PHP I would never had the courage to stay focused working on preparing Fargo all these years for development. However, Fargo is just one stop on my journey in life—hopefully not my last.

FAR-0A-01 will be amiss some features—such as the “Mother” control plane—which may be the ML ring, but I like to keep things “dumb” if at all possible, and that plane need not exist in the beginning—but Farcry will come with Rust’s large module ecosystem available within the Farcry VM. I haven’t decided whether I’ll attempt writing Farcry’s compiler from scratch or go with a generator or not. Fargo is actually an experiment I thought I would do as part of the larger “Campar” project I will not discuss at this moment since it’s light years ahead of the game and is actually pretty dangerous to even publish should I finish my paper on it 🤞(and yes I just impulsively bought campar.dev just now). What I will say is that I’ve made some recent breakthroughs in my research focusing in prime number theory and it’s exciting stuff (thank goodness for the Ramanujan’s of the world)—I hope I don’t get renditioned, ha.

I currently have no website to visit for Fargo nor Campar, most of my work is buried deep in my notes and research material. So I guess I’m petitioning interest form the #nocode community here on what I’ve talked about to share and get early feedback before I go official with it. What did I miss?