Rama is a testament to the power of Clojure

[metadat]

> 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.

[nathanmarz]

Check out twitter-scale-mastodon, which is an implementation of Mastodon's backend from scratch that scales to Twitter scale. It's more than 40% less code than Mastodon's backend and 100x less code than Twitter wrote to build the equivalent.

https://github.com/redplanetlabs/twitter-scale-mastodon

https://blog.redplanetlabs.com/2023/08/15/how-we-reduced-the...

[ntonozzi]

Here's an example of the backend code:

https://github.com/redplanetlabs/twitter-scale-mastodon/blob...

It certainly looks like it does a lot with their DSL, but as a newcomer it's really hard to parse.

[geodel]

Well there is whole bank transfer implementation there and thoroughly commented too. Some entrepreneur can take this and run with it to create next generation banking platform.

[kitd]

Tbf, the purpose of the blog is to talk about the power of Clojure/Lisp for defining the new paradigm, rather than the paradigm itself. Though the author then goes on to talk about "fragments" as the basis for the new paradigm.

The first sentence has a link to the project page which has most of the info you need.

[smackeyacky]

Not even a code sample in the article. You'd think if they were so convinced it was a new paradigm we'd see why. Makes me skeptical.

[cactusfrog]

The Clojure community is extremely cult like. I worked with a dev who tried to push Datomic, and despite the huge flaws with his system, and the fact that it was closed source, he would continuously tout how much better it was than a relational database. I don’t believe the hype.

[jimberlage]

Is anyone using Rama at scale? This isn't a complaint about it being closed-source, people have to make their money somehow. But I've seen a lot about Rama's scale when the only things to check the claim are a private beta and a single-process dev build.

I'm super curious to hear from people who have tried it for larger projects!

[nathanmarz]

A few of our private beta users are using Rama at larger scale (>1M appends/second). We'll be publishing case studies eventually.

[joeevans1000]

This is... closed source?

Omg. Didn't anyone learn anything from the Datomic story?

[mrkeen]

> Another example is Specter. Specter is a generically useful library for querying and manipulating data structures

> https://github.com/redplanetlabs/specter/tree/master/src

> MutableCell.Java. 8 years ago

  package com.rpl.specter;

  public class MutableCell {
    private Object o;

    public MutableCell(Object o) {
      this.o = o;
    }

    public Object get() {
      return o;
    }

    public void set(Object o) {
      this.o = o;
    }
  }

Behold the power!

[thih9]

Simple and elegant, powerful indeed.

Or did you mean something else? In which case please elaborate.

[titanomachy]

> At its core is a new programming language implementing a new programming paradigm, at the same level as the “object-oriented”, “imperative”, “logic”, and “functional” paradigms... Rama generalizes the concept of a function into something called a “fragment”... a fragment can output many times (called “emitting”), can output to multiple “output streams”, and can do more work between or after emitting.

This sounds really similar to programming with observables (e.g. RxJS), is a "fragment" an even more general concept?

I used observables when I did frontend development, I found it a useful paradigm (once I got my head around the idea).

[nathanmarz]

A fragment itself is a generic programming construct that serves the same purpose as a function (just more general). When used in Rama topologies, they serve a similar role as observables in terms of reacting to new data as it flows through and sending any amount of information downstream to any number of output streams.

[ThinkBeat]

I remember when the first time i read about Rama, with the blog post about having duplicated Twitter scale at 100x code or some such.

Which all in all, if you have built a platform/runtime/language and you pick one particular example to highlight it, being able to achieve XXXX% less than is trivial.

I was curious about all the bluster then, Seeing this post I am somewhat disappointed that there does not appear to have been a lot of visible progression.

But I guess it is still running semi stealth in private beta.

I will be interesting to see what becomes of it.

[nathanmarz]

Indeed, we're in private beta and aren't publicizing much about what we're doing. We'll eventually be releasing many case studies on how our private beta users are using Rama.

[MH15]

I think we've spent a lot of time looking at backend and frontend web app development as separate. In my work, TRPC (https://trpc.io/) solved this. I hope others in different frameworks find a similar solution soon.

[JonChesterfield]

Fragment sounds like actor to me. Stateful thing that sends messages to other fragments. Not convinced that's a generalisation of a function.

[nathanmarz]

Fragments have nothing to do with actors. Check out the doc on the dataflow language and you'll clearly see it's a generalization of a function.

https://redplanetlabs.com/docs/~/clj-dataflow-lang.html

[samsquire]

From just thinking about the architecture of Rama I feel it would scale very well.

Data parallelism and partitioning and sharding is a very effective scaling technique.

Nathan, I would appreciate writings about the mental model of mapping software to your mental model of implementing behaviours in the streaming data approach because it is a different paradigm.

I can't read the DSL yet and know what is going on!

[nathanmarz]

The best documentation on the mental model of using Rama is the last page of the tutorial, linked below. However, I would recommend going through the whole tutorial rather than starting there.

https://redplanetlabs.com/docs/~/tutorial6.html

[throwaway_fjmr]

I worked on a few OSGi projects in the early 2000s. Rama and their claims trigger funny vibes in me, OSGi meets K8s meets Clojure cult. I'm looking forward to future releases, though.

[thih9]

Rama desperately needs a better landing page and clearer docs.

[epolanski]

> Lisps have great control over what happens at compile-time, which lets you do incredible things.

> Lisp programmers have struggled ever since it was invented to explain why this is so powerful and why this has a major impact on simplifying software development

I've written some Common Lisp, Scheme, Racket.

I like them.

But what op defines as a feature is actually what kills all those lisps but Clojure where macro abuse is rare.

Everybody implementing their abstractions, every library implementing their own language, I like those features, macros are fun, but it just doesn't scale neither in open source and even less at work.

Haskell to some extent too suffers the same issue, simple Haskell is nowadays a dead project, but every single project has different language extensions, syntax, etc..

I feel like Lisp and Haskell attract people that love programming more than shipping code.

Which is why at the end of the day, php has more killer software than all those languages combined.

[fiddlerwoaroof]

This is one of those perpetual myths about macros. Ruby on Rails metaprogramming is often harder to debug than macros in Common Lisp. Flink and Spark work by generating and loading Java code at runtime (macros) but, since Java has no language-level support for macros, the generated code is very hard to inspect and debug.

What killed most lisps was the AI Winter and the concurrent drying up of DARPA funding.

[fr4nkr]

I've used Lisps on and off for a decade or so, and my experience with it is pretty much in line with the Grammarly devs' summary: misuse of macros is one of those things people just assume is a major problem, but in reality is quite rare, even in cases like Emacs Lisp where most packages are developed by just one person. Lisp is not Perl, its users do not create spaghetti mazes for fun.

[defyonce]

> I feel like Lisp and Haskell attract people that love programming more than shipping code.

this! but I find Clojure incredibly pragmatic, we grow our codebase, ship things, just the line of business work with Postgres/Clojure and Rum(React) on frontend.

We do it with super small team, where one person owns the entire sub system

[ww520]

For compile time control and meta programming, I found Zig's comptime system to be the best. It blends with the regular syntax seamlessly and solves several problems at the same time. It's one of the best things came out of language design in recent years.

[lispm]

> Everybody implementing their abstractions, every library implementing their own language

In Lisp one can extend the language syntax. One does not need to implement a new language. For example the Common Lisp Object System adds operators like DEFCLASS, DEFMETHOD, DEFGENERIC, ... in addition to already existing operators like DEFUN, DEFSTRUCT, DEFTYPE, DEFPARAMETER, ...

Thus the language can be incrementally extended, instead of using a completely new language.

The CLOS macros are used by many programmers, they were standardized, documented and implemented.

As every form of abstraction, syntactic abstraction needs to be learned and requires extra work. Lisp was from the start developed to enable such things, and its early form of that applied to Lisp itself were the Lisp interpreter evaluating s-expressions, FEXPRs (procedured receiving unevaluated arguments) and in 1962 macros.

> I feel like Lisp and Haskell attract people that love programming more than shipping code.

One of the purposes of Lisp was to implement new ideas: like computing with mathematical formulas (-> Macsyma and earlier attempts), computing theorems (-> ACL2 and earlier attempts), ... This ability to support experimentation in R&D (actors, rule-based systems, frame systems, ...) was always a part of the language community.

If we look at the surviving commercial systems (Allegro CL and LispWorks), they still support this feature set.

Clojure was developed as a Lisp-inspired functional language with deep Java/JVM integration to support enterprise programming for people who were tired of programming in Java. That's fine. But the advice then was to not utilize the full power of Lisp (syntactic abstractions), to address the fear of unmaintainable software, while at the same time not using various features of Lisp (like gradually typed implementations of Lisp like SBCL) which helps to write robust software.

Generally Lisp has a broader outlook. It ran on an experimental spacecraft, it powered autonomous robots inspecting pipelines, it was the base for early research in computing (-> Interlisp), it ran on calculators (HP RPL), it supported children education (Logo), it's used to schedule telescope operations (-> Hubble and James Webb), it is used to schedule airline/airport operations, ...

> php has more killer software than all those languages combined.

If we research for ground breaking software, then I bet over the long history of Lisp there were a lot more in many more diverse domains written in Lisp

Lisp has been applied to develop airplane parts. BOEING and Airbus used to be Lisp users (they might be still use it for older planes). ICAD was the first parametric CAD system. ICAD used macros to describe physical objects and their relationships. This was used to construct turbines, wings, and a lot of other parts of Airplanes.

If you look into the long history of Lisp, it has been successfully applied in domains PHP has never seen. Sometimes really crazy stuff, like the first virtual military troop training systems, where the US army deployed a few extensive training and simulation systems, where the virtual worlds were controlled & generated by a Lisp system and rendered by multiple graphics engines for each training simulator. In the early 80s. -> https://en.wikipedia.org/wiki/SIMNET

That's nothing like PHP, but it was ground breaking in its domain. PHP had a different purpose: it was developed to make it simple to write&generate web pages in a large scale. That's a huge domain, but that was not what Lisp was developed for.

Btw., we see a bunch of new languages which now also support some form of macros. A recent example is Rust.

[snitty]

>Rama’s language is Turing-complete…

Amazing they could accomplish such a feat.

[titanomachy]

This seems unnecessarily cynical, they're just stating one of the design decisions that they made. When you design a new DSL you could choose to make it Turing-complete (e.g. Ruby on Rails) or not Turing-complete (e.g. Terraform's HCL). The point isn't that one is more technically difficult to build than the other.

[yayitswei]

Are you a lisper?

The article is mostly about the power of a lisp dialect. It's kind of "in the tradition" of lisp to write about it in glowing terms. I myself was inspired to learn a lisp after reading several of these types of essays.

[blackeyeblitzar]

It seems really distasteful to take the name of an important religious and cultural figure from a different country and appropriate it for some pet project.

https://en.wikipedia.org/wiki/Rama

[nathanmarz]

It's named after the Arthur C. Clarke book.

[as1mov]

A genuine question, why is that a bad thing? The worst thing that could happen is someone would get curious about the word and try to learn more about it, consequently reading about Hindu mythology.

There's tons of material in Hinduism + Buddhism would be amazing if adapted in books/movies/shows/games, but it hasn't happened because everyone seems to be so touchy about it (despite the fact that the religion itself doesn't have a singular book, god or commandments specifying what's good/bad).

Also before the usual retort comes back, my family is Hindu.

[labrador]

Except it has other meanings, not necessarily the Supreme Being. From the link you shared:

Rāma is a Vedic Sanskrit word with two contextual meanings. In one context, as found in Atharva Veda, as stated by Monier Monier-Williams, it means "dark, dark-colored, black" and is related to the term ratri, which means night. In another context in other Vedic texts, the word means "pleasing, delightful, charming, beautiful, lovely"