Rama is a testament to the power of Clojure

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.

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

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

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

> Until Rama is publicly available, the only way to get access to the full Rama release is by applying to our private beta.

I thought it was coming out last August? What happened?

(As per your link, https://blog.redplanetlabs.com/2023/08/15/how-we-reduced-the...)

Edit: @nathanmarz that's cool you have enough interest to keep things moving with it being private. I'm only interested in open solutions for this domain, though. IMO, accepting lock-in is a lot to ask. Best wishes ~ MD

https://redplanetlabs.com/docs/~/downloads-maven-local-dev.h...

Huh. I haven't written myself a twitter, but I've always assumed that this problem is solved by a mix of fan-on-write and fan-on-read. Most people are fan-on-write, but those with a follower count > $THRESHOLD are fan-on-read.

The fan-on-read set is small enough to be easily cacheable, so the extra reads required to service a follower's feed are more than compensated for by the fact that the content is in RAM in a cache.

Sounds like RedPanda went exclusively with fan-on-write. I'd be surprised if Twitter does the same - but it sounds like OP has more knowledge about this than me, so I'm happy to be educated!

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.

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

https://github.com/redplanetlabs/rama-demo-gallery

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

Amazing they could accomplish such a feat.

I'm surprised that someone with, say, a Twitter problem and tens of millions of followers - the two seem to go hand-in-hand - drives tens of millions of writes every time they post. But there you go, learned something today.

Also, contrary to popular opinion, we didn't go down when Justin Bieber tweeted, but we did have elevated error rates when large quantities of Justin Bieber followings put pressure on the MySQL row lock of his following count. In retrospect, lock striping would have helped, but the migration would have been horrific.

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

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

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.

When I say software at scale I mean:

- going on GitHub opening a file and understanding what's happening

- reviewing a PR and figuring out stuff without requiring an ide

- having easy onboarding with devs already accustomed to a base language and its patterns

Java, C, TypeScript, Scala, Kotlin, etc. Pretty much all major languages offer this: less power but much less ambiguity and mental overhead.

Lisps (with a minor exception for clojure) and Haskell are just not those languages.

Which, again, is why all of those languages produced very little software worth of mentioning for decades.

https://blog.redplanetlabs.com/2023/10/11/introducing-ramas-...

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

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.

It's just that there's a lot of empirical evidence that these grandiose praise is just praise, but not a lot of shipped software, compared to the 'worse is better' languages such as php, javascript or c.

However, this might be due to the fact that in order to write something in lisp, the author has to be pretty clever, but in order to crap out something in php, you don't need very much cleverness and just need grit/effort. And there are many more people who are not clever, but has grit and effort.

Quantity of "shipped software" depends on many factors. Quality of the language is pretty far down the list. Take Javascript. It's usage numbers might have something to do with it being available in every browser on the planet.

The language that never met an abstraction it didn’t immediately incorporate into itself?

For obvious reasons (syntax) Clojure gets lumped in with the other lisps but Clojure is really intensely practical. It makes a number of choices to that effect. The most of important of which is being a JVM language, so you get access to basically all Java code ever written. The builtin collections are very high quality. It's incredibly stable, so the code you write just keeps working regardless of whatever new features they add in the newest version of the language. There are a lot of high-quality libraries that are "done". The immutable-by-default thing makes writing concurrent code much, much easier. Being on the JVM means you don't have to fuss around with cross-compilation. It's fast enough that you rarely need to mess with optimizing it until you reach real scale. I could go on.

I don't even do much Clojure anymore, but when I did, it was hands down the best thing I ever used for work where the main tasks involved moving lots of data around, filtering it, reducing it, etc. Of course Clojure does tend to attract a lot of clever people, but it also attracts a lot of people looking for the tool with the most leverage to get their work done. There is a lot of Clojure out there, just quietly running the back offices of small/medium sized businesses.

but clojurescript is available, so if clojure is truly as superior as javascript, it would make a lot of sense to use this. And indeed there are apps that do, but overwhelmingly more apps just use plain javascript. But when typescript came along, a lot of people switched to it. So it cannot be just merely compiler/build friction imho.

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

Javascript in the browser is actually an interesting case here. (And after Javascript spralwed out... ClojureScript is the nicest way to write React apps)

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"

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.

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

> 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;
    }
  }

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

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.

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

The "Figma OSS Alternative" post that's also on the HN homepage right now doesn't mention Clojure anywhere (no comments about it either!), but Penpot is clearly also yet another app successfully shipped using Clojure: https://github.com/penpot/penpot

That's like saying world hunger does not exist because you had lasagna for dinner.

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!

It's easier to call others out when they aren't in the mainstream, but I'd say that there are way more mainstream cult members than these niche communities. For instance, HN itself can feel a bit cult-like. The greater tech culture feels similarly.

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

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

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

I think basically no languages have failed or succeeded for technical reasons: generally, marketing and inertia explains the tech stack better than DX or theoretical superiority.