Slashdot Mirror

Try Ceylon instead of Scala. It's significantly simpler and cleaner, it's modern, and it has perfect Java interoperability. It's actively developed by RedHat's enterprise Java team.

Java is ugly. It is not complex by any reasonable definition, unless you're comparing it to BASIC or something. Part of the reason Java is ugly is that it's so simple, in fact - it eschews syntax sugar and various conveniences that'd make the code shorter and prettier.

I tend to feel that Java is on the wrong side of programming language trends here: there's a lot to be said for simplicity, but some languages are showing that you can add a lot of convenient and helpful features to Java-like languages without exploding the language's complexity budget. C# for instance is widely agreed to be more pleasant to use than Java (at least, widely agreed by most devs with experience in both that I've met).

On the JVM unfortunately we've been kind of limited until now in the "simple, beautiful yet performant" space. There are languages like Scala that are static enough to be reasonably fast, but there seems to be a growing consensus that Scala is very complicated. I've seen it be called the C++ of the JVM. There are lots of dynamic languages like Ruby, Python, Groovy, Clojure etc that gain simplicity and terseness by abandoning static typing entirely but sacrifice maintainability and performance. There's Frege, a Haskell dialect that I have no experience of, but lazyness-by-default seems a controversial choice at best.

Lately there's also Ceylon and Kotlin, which seem to be exploring a new space in PL design that can be summed up as Scala but made a lot simpler. The syntaxes are terse and compact, the typing is static, the IDE support is developed alongside the language, and they compile to both the JVM and Javascript. Kotlin is my personal favourite. The feature set eliminates much of the tedious boilerplate in Java without adding much potential for code maintenance disasters or excessive complexity. It also increases safety, like by making nullability a part of the type system.

It's worth mentioning that Ceylon (Red Hat backed) is pretty sweet:

http://ceylon-lang.org/

Developer adoption is moving slowly, though.

Java is moving into archaic irrelevance faster than ever. That is, the language itself.

The JVM, however, is now more useful and relevant than it ever was. It used to be naught but an implementation detail. Now, rather, it's central to an entire ecosystem of languages that will inevitably send Java the way of C: used only when the greatest speed is necessary.

Scala is basically a next-generation Java. Java with functional programming, or really, vice versa. JRuby make Ruby actually scalable, given the presence of native threads and interoperability with existing enterprise libraries that commonly only ship in the form of Java or C# libraries. Clojure enables LISPers of yore and Schemers of new import explore functional programming as it used to be, without having to drop the wealth of Java libraries available. Ceylon, Groovy, Jython, and dozen of others are paving a way to give the JVM much more to do after Java becomes obsolete.

Java will never die - it'll just become like COBOL, Fortran, and C before it: used in enterprise software, operating systems, and outdated educational assessments.

Because it runs on both the JVM and JS VM and is, for all intents and purposes, a dramatically improved version of Java.

http://ceylon-lang.org/

Have you had a look at http://ceylon-lang.org/ ?

I've been tempted to get into Ceylon, it runs in both the JVM & JavaScript Engines.

I think Red Hat are positioning it to replace Java in the long term...