What Happened to Ceylon Language?

The "better Java" niche was hot during Java's stagnation era (starting 2006 and lasting for almost a decade). The JVM was considered a great runtime, with a stagnant language, and lots of newer languages competed in that niche.

Scala and Clojure, and later Kotlin and others benefited greatly from that niche. The problem for the "better Java" niche was that Java never had to be the best JVM language in order to beat its JVM-based competition in the market. When Java started moving again (Java 8 introduced anonymous functions) and when the release cadence accelerated to every 6 months on 2017, the "Java is stagnant" justification for using other JVM languages lost a lot of traction.

Clojure was never really a "better Java" -- it's a JVM-based Lisp with good Java interop. Scala never leaned too much on the "better Java" niche, and the community is increasingly consolidated around FP. Kotlin still has some "better Java" ambitions, but they also have the Android community at their back. Without Android you would have seen Kotlin trying harder to differentiate itself from Java (EDIT: Google and Kotlin tied the knot in 2017, when Java moved to 6-month release cycle; probably not a coincidence).

Fairly young languages can still see rapid growth -- see Go (1.0 in 2012) and Rust (1.0 in 2015). But you are much less likely to see new languages trying to go head-to-head with Java on the JVM these days.

The details are fuzzy in my memory, but as best as I can recall Ceylon was basically created / run by some people from Red Hat / JBoss. They promoted it for a while, but eventually decided to abandon it for some reason. Again, the details are fuzzy, but I think they just decided that other languages that had also some along (maybe Kotlin?) had gotten "good enough" and that Ceylon didn't really have a niche where it was going to be highly in demand. Or something like that. Don't quote me on this, it was all some time ago.

EDIT:

Some bits and pieces of additional info:

https://ceylon-lang.org/blog/2017/08/21/eclipse-ceylon/

https://github.com/eclipse/ceylon/issues/7454

https://news.ycombinator.com/item?id=15057893

I frequently wish I had Ceylon's union + intersection types in Java. Typescript has them, but they aren't as rigorous. Also the collection classes were rethought and designed with immutability in mind (reading a list is a different interface from mutating a list).

Honestly, it was/is a pretty great language.

I think their biggest mistake was picking Eclipse as the IDE. They eventually produced an IntelliJ plugin but it was far too late. The serious JVM dev community had already picked IntelliJ. I don't know anyone who uses Eclipse anymore.

It really looks abandoned. On this page [0] there is a list of leaders and commiters. Stéphane Épardaud is on Twitter [1], as well as Gavin King [2]. I will ask them.

[0] https://projects.eclipse.org/proposals/eclipse-ceylon

[1] https://twitter.com/unfromage

[2] https://twitter.com/1ovthafew

This should tell you about the current status (which I interpret as "it's dead"): https://github.com/eclipse/ceylon/issues/7454

My impression was that it wasn’t getting much traction and thus was abandoned at some point. It was a nice “better Java”, but it didn’t have any compelling killer features and also not a lot of marketing behind it.

It was essentially killed during Google I/O (May 2017) when Google announced that it would add Kotlin as an official programming language for Android development. This gave Kotlin a huge boost in visibility at a time when a number of languages including Ceylon were competing as alternative JVM-languages. RedHat understood that and a few months later it was announced that Ceylon was being donated to Eclipse which was a euphemistic way of saying it was now abandonware.

It's too bad because I personally preferred Ceylon over Kotlin.

It's called Sri Lanka now.

Any references to its documentation?

Kotlin killed it, espceially with Google picking it for Android. I remember looking at it and it had some weird stuff and I liked Kotlin better, and Groovy was going strong.

Kotlin is a "better java" from a footgun/safety + syntax perspective, and better than Ceylon in most features and ways. So it won that war. And here is another bad idea, from Ceylon's wikipedia:

"Modularity built into the language, based on JBoss modules, interoperable with OSGi[10] and Maven[11]"

Yikes. Three very-obsolete parts of the java ecosystem, and divisive in the ecosystem community at the time of their introduction/use. Not a good strategy.

Groovy was a "better java" with lots of footguns and more-than-one-way and lots of cool features. So it won the scala/whomever war because it was a path for ruby and python people and paradigms. Most JVM evolution has been adopting groovy language features. Not that groovy did them in a revolutionary way, it just had them a lot earlier. But groovy is fading steadily as the JVM adopts its killer features. Groovy is my main programming language on the JVM.

Clojure has the inherent problems of Lisps for popularity, and Scala was possibly the most complicated language every designed. Great for the top 1% of programmers, but oh well for mainstream success.