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...
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!
> 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://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.
The first sentence has a link to the project page which has most of the info you need.
https://github.com/redplanetlabs/rama-demo-gallery
https://github.com/redplanetlabs/twitter-scale-mastodon
https://blog.redplanetlabs.com/2023/10/11/introducing-ramas-...
I'm super curious to hear from people who have tried it for larger projects!
Omg. Didn't anyone learn anything from the Datomic story?
> 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.
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.
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!
> 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.
What killed most lisps was the AI Winter and the concurrent drying up of DARPA funding.
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.
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
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.
Amazing they could accomplish such a feat.
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.
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"