rama-demo-gallery

Well, this article is to help people understand just Rama's dataflow API, as opposed to an introduction to Rama for backend development. Rama does have a learning curve. If you think its API is "clunky", then you just haven't invested any time in learning and tinkering with it. Here are two examples of how elegant it is: This one does atomic bank transfers with cross-partition transactions, as well as keeping track of everyone's activity: https://github.com/redplanetlabs/rama-demo-gallery/blob/mast... This one does scalable time-series analytics, aggregating across multiple granularities and minimizing reads at query time by intelligently choosing buckets across multiple granularities: https://github.com/redplanetlabs/rama-demo-gallery/blob/mast... There are equivalent Java examples in that repository as well.

The examples in this repository are representative of what it's like to use Rama for different kinds of use cases: https://github.com/redplanetlabs/rama-demo-gallery

It's an article about Clojure's influence on Rama, not an introductory tutorial on Rama. But we have plenty of code samples elsewhere: https://github.com/redplanetlabs/rama-demo-gallery https://github.com/redplanetlabs/twitter-scale-mastodon https://blog.redplanetlabs.com/2023/10/11/introducing-ramas-... https://redplanetlabs.com/docs/~/tutorial1.html

I suggest starting with the tutorial and the heavily commented examples in rama-demo-gallery, linked below. https://redplanetlabs.com/docs/~/tutorial1.html https://github.com/redplanetlabs/rama-demo-gallery

> Rama can build end-to-end backends at any scale on its own in a tiny fraction of the code. At its core is a new programming language implementing a new programming paradigm.. Grand claims, but where are the super powerful demo apps? The getting started docs are a trickle of info.. https://redplanetlabs.com/docs/~/operating-rama.html#_access... The "demo gallery" has a few cherry picked examples, but I don't see how this fulfills the claim of a "new paradigm". I wanted to be blown.. but this ain't it. https://github.com/redplanetlabs/rama-demo-gallery Oof.

FYI, in case you're unaware the rama-demo-gallery repo has a bunch of short, self-contained, thoroughly commented examples of applying Rama towards different use cases https://github.com/redplanetlabs/rama-demo-gallery

This is the bank transfer example we show in rama-demo-gallery. There's both Java and Clojure versions of that example. https://github.com/redplanetlabs/rama-demo-gallery The atomic bank transfer is done as part of function(data). The data record contains fromAccountId, toAccountId, and amount. The function applies the transfer if it's valid (fromAccountId has at least that amount of funds), and no-ops otherwise.

Rama supports very strong transactions actually. Besides being able to do arbitrary atomic updates across multiple indexes on a single partition, you can also do distributed transactions. Our bank transfer example in rama-demo-gallery demonstrates this. https://github.com/redplanetlabs/rama-demo-gallery

Those questions are all answered in the documentation, which we spent a ton of time on. Some available resources: - Public build that you can download and run yourself locally https://redplanetlabs.com/docs/~/downloads-maven-local-dev.h... - rama-demo-gallery, containing short, thoroughly commented examples in both Java and Clojure https://github.com/redplanetlabs/rama-demo-gallery - Gentle six-part tutorial introducing the concepts and API, including how to run stuff locally https://redplanetlabs.com/docs/~/tutorial1.html - Introduction to the first-class Clojure API https://blog.redplanetlabs.com/2023/10/11/introducing-ramas-... Here are a few pages related to fault-tolerance: - https://redplanetlabs.com/docs/~/replication.html - https://redplanetlabs.com/docs/~/microbatch.html#_operation_... - https://redplanetlabs.com/docs/~/stream.ht

Yes to both. Our bank transfer example in rama-demo-gallery is a good example of this. https://github.com/redplanetlabs/rama-demo-gallery

True, Rama does have a learning curve. It's easier to explain why its indexing capabilities are so powerful, as data structures vs. data models is fairly relatable to most devs. But I actually consider its dataflow API to be the bigger breakthrough. Our Twitter-scale Mastodon implementation and examples in rama-demo-gallery are demonstrations of this. Also, Rama has a first-class Clojure API (I should probably update the website). https://github.com/redplanetlabs/twitter-scale-mastodon https://github.com/redplanetlabs/rama-demo-gallery

We've released many examples. The first is our Twitter-scale Mastodon implementation, which is 100x less code than Twitter wrote to build the equivalent at scale (just the consumer product). It's also more than 40% less code than Mastodon's official implementation (which isn't scalable). https://github.com/redplanetlabs/twitter-scale-mastodon The rama-demo-gallery repo also contains many short, self-contained, thoroughly commented examples of applying Rama towards very different use cases. These include user profile management, time-series analytics, atomic and fault-tolerant bank transfers, and more. https://github.com/redplanetlabs/rama-demo-gallery

It's a backend development platform that can handle all the data ingestion, processing, indexing, and querying needs of an application, at any scale. Rather than construct your backend using a hodgepodge of databases, processing systems, queues, and schedulers, you can do everything within Rama within a single platform. Rama runs as a cluster, and any number of applications (called "modules") are deployed onto that cluster. Deep and detailed telemetry is also built-in. The programming model of Rama is event sourcing plus materialized views. When building a Rama application, you materialize as many indexes as you need as whatever shapes you need (different combinations of durable data structures). Indexes are materialized using a distributed dataflow API. Since Rama is so different than anything that's existed before, that's about as good

The bank transfer module is particularly neat: https://github.com/redplanetlabs/rama-demo-gallery/blob/mast...