
The Second Coming of Java - rck
http://www.wired.com/wiredenterprise/2013/09/the-second-coming-of-java/
======
theboywho
I can't figure out what the target audience of this post is.

It's without doubt not programmers, as the article tries to explain what a
programming language is "...It’s a programming language, a way of writing
software code..."

And also, who is going to be interested in a story about java if they aren't
programmers or in the IT business?

The author seems to not even know what a JVM language is. "...Originally, the
Java virtual machine — aka the JVM — only ran code built with the Java
programming language, but today, it runs all sorts of other languages..."

Another example where the author is not being consistent "...language called
Clojure to a new and increasingly popular invention known as Scala...Lisp, a
way of quickly scripting code"

So now clojure is a language, Scala an invention and Lisp, a way of quickly
scripting code.

This article is making noise without talking to anybody.

~~~
dpapathanasiou
_I can 't figure out what the target audience of this post is._

It's part of Wired's "Enterprise Technology" blog[1] so it's for CIO/CTO and
other IT consultant types who don't write any code themselves, but make "best
practice"[sic] recommendations.

[1]
[http://www.wired.com/wiredenterprise/](http://www.wired.com/wiredenterprise/)

~~~
Yhippa
"I can draw the Javas on a whiteboard but I can't actually do the Javas."

------
total__C
Calling the JVM _platform_ a relic is a major mistake - the number of
businesses that rely on the platform is massive.

However Java-the-language has been stagnant since Java 1.5 in September 2004.
The Java API has had some changes but the language has remained mostly
unchanged. The 1.8 version promises some nice improvements inspired by FP
languages. Unfortunately, 1.8 has been continuously delayed with a current
release date of sometime in early 2014. For JVM developers who care about
their productivity, moving over to languages such as Scala, Groovy, and
Clojure is the only sane choice.

~~~
jbooth
Java fills a particular niche (code with an emphasis on readability) which is
not addressed by Groovy or Clojure and arguably not addressed by Scala. I'd
say Go is the biggest competition for that niche as a language, although it's
not JVM, it does fix many warts with how Java handles inheritance/polymorphism
without sacrificing readability and simplicity.

Groovy is slow as a 1-legged dog. (we use it to fill the shell/perl niche a
lot but it is slow, effectively you're doing reflection lookups every time you
call a method in Groovy). The dynamicness makes it better for scripting or web
programming, though, where you don't care as much about performance.

Scala is the JVM's C++, a giant pile of overlapping features, supported by an
advanced and very slow compiler that yields fast bytecode. Case classes, funny
operator overloading, lots of additional syntax for collection manipulation.
They're giving you more expressiveness at a cost of readability and language
complexity. (This is an opinion, some may disagree).

Clojure is really awesome but most dev shops will have an easier time with
imperative programming models.

Ultimately, not changing in 8 years isn't fundamentally bad, and Java isn't
that bad at all as a language if you avoid things like EJB and Hibernate, and
if you're not looking for a dynamic language like Ruby and dissapointed by
Java not being Ruby. You might just disagree with the tradeoffs.

~~~
sbilstein
I'd argue Scala is much more readable than Java with some effective practices.
Type inference (where appropriate) cuts down on distracting text, operator
overloading is great when used judiciously, for comprehensions, etc are all
great features.

Just because Java requires explicit typing all over the place does not make it
easy to read, especially when I'm trying to decipher what the
ResourceBuilderFactoryFactory class is doing in my enterprise grade codebase.
There is cognitive load in parsing tons of text to express simple concepts,
just as there is cognitive load in deciphering a bunch of random symbols doing
something complex. Scala with discipline lets you choose somewhere in between;
Java gives no choice.

~~~
cgh
For startups with small, disciplined teams, Scala is manageable, sure. But
once things go "enterprise" and much of your ongoing development gets
outsourced, and it will, all bets are off. Maintainability is THE great
equalizer.

~~~
dragonwriter
> But once things go "enterprise" and much of your ongoing development gets
> outsourced, and it will, all bets are off.

That has nothing to do with language; Java for which development is outsourced
and maintenance goes in house is pretty much a nightmare, too.

But that's pretty much a "myopic development practices -- including
outsourcing development of code you are going to need to end up supporting in
house -- will blow up in your face problem", and not an issue relating to any
particular language or platform.

Chances are, if you have the authority to make enterprise-level
language/platform policies, you also have the authority to make enterprise-
level decisions on whether and when to outsource development of software, so
it makes sense to just do the latter right than to make an otherwise second-
rate choice on the former to make up for doing the latter poorly.

------
unclebucknasty
Java has steadily grown over the years as the premier choice in the
Enterprise. This is the reason that Java developers are relatively many
(though I don't believe they are falling from the sky as the article
suggests).

This article is a little strange in general. The idea that Java was ever dead
seems to be from the perspective of those who thought it was only for applets
or devices. But the author acknowledges his awareness that this is not all
Java ever was. So, to make the case that it died, he holds out a few examples
of companies that tried something else, but couldn't scale until they went to
the JVM. He simultaneously ignores the entire Enterprise Java world.

Odd.

~~~
James_Duval
From the point-of-view of a web developer, JSP is virtually invisible. For
this reason, I guess the majority of online tech magazine readers, who would
presumably be mostly ninjas, pirates and rockstars, _would_ think of Java as
dead.

I mean, it's a bit outdated as a language, definitely showing some signs of
strain, but it's still not dead - for better or worse. I've yet to come across
a more human-readable language, barring COBOL.

~~~
unclebucknasty
> _From the point-of-view of a web developer, JSP is virtually invisible._

By "invisible", do you mean that webapps that use JSP typically use URL
mapping so that you never see the .jsp extension? If not, then I'm not sure I
get your meaning.

> _I 've yet to come across a more human-readable language..._

Yeah, I think its readability leads to a verbosity that is, ironically, the
source of some complaints about Java. But, Java kind of embraces that
verbosity to some extent. I've even seen style "standards" that discourage the
use of language "shortcuts" because they are believed to decrease readability.

~~~
James_Duval
> By "invisible", do you mean that webapps that use JSP typically use URL
> mapping so that you never see the .jsp extension? If not, then I'm not sure
> I get your meaning.

Oh, I just meant that JSP is never, ever mentioned in any mainstream web
development magazine - it's absent from discussion, not practice.

Back-end programming seems to be exclusively PHP/ROR if I go from what I read
on web dev blogs, forums and news sources. I may simply be reading the wrong
sources, of course.

------
InTheSwiss
I love Java but I hate Oracle more than any other tech company. I don't refuse
to use the language but I don't like to either if I can help it. I really hope
with OpenJDK we can just forget about Oracle in the long term and have a solid
language/platform that is free from a corporate parent.

------
api
Java _applets_ are dead, and should be. Great idea poorly executed.

Java on the server never died or even coughed. It's huge. It's a very rich
ecosystem and performs very well at scale.

Java for _apps_ is IMHO underrated. The biggest foot-shooting decision Sun
made was to bundle shitware like the ask.com toolbar with the JRE, and never
to solve the JRE deploy/update problem that requires that every Java app
bundle its own JRE. Solve that and java apps on desktop computers will make a
comeback.

~~~
huherto
> Java applets are dead, and should be. Great idea poorly executed.

I think Microsoft killed the applets when it stopped upgrading the java plugin
in IE. Applets were challenging MS dominance on the desktop. They kept it that
way until java script came along.

------
skwirl
Java never really went away. This article to me is really more of an attack on
the recently/currently trendy technologies like Ruby on Rails than anything
else.

~~~
cliveowen
As long as companies and organizations will have legacy code, not a single
language will ever be considered dead.

~~~
jheriko
so very true

------
arel
The article is terrible when read from the perspective of a developer. But it
does touch on something - often here on HN, start up culture and wider tech-
centric sites if a technology is mainstream, not release 0.001 its not
considered worthy of attention or praise and gets an unhealthy amount of sour
grapes. Java/JVM is ubiquitous in our field and has been quietly getting the
job done for over 15 years in that sweet spot of fast, server-centric
applications. I'm looking forward to v1.8 where it will pick up the features
needed to keep it an essential tool.

------
tootie
I think that saying it's the second coming is misleading. It was no longer
considered sexy and cutting edge by the startup community, but as the web
spread to every corner of every industry it was by far the language and
platform of choice for thousands of IT departments. The result is an unmatched
galaxy of scalable products that can be dropped in to any web application.

------
Zelphyr
Some of this article reads as if it were a "Special Advertisement Section"
paid by Oracle to fend off the negative press Java has been getting from the
recent spate of security exploits.

Its good that it mentions the JVM-based languages though. I know many "Java"
programmers who hate Java proper but love languages like Groovy, Scala, etc...

------
gbaygon
_" Java is really the only choice when it comes to the requirements for a
company like ours — extreme performance requirements and extreme scalability
requirements. There is no viable alternative"_

What about C#?

~~~
edwinnathaniel
C#, clearly, did not meet their expectation.

~~~
pjmlp
Some people like to earn money, but avoid paying for developer tools.

~~~
throwaway1979
It has nothing to do with dev tools costing money. It has everything to do
with Windows costing money.

~~~
pjmlp
It is the same thing.

------
noir_lord
> The best way was a brand new architecture based on Java, a programing tool
> that grown more powerful than may expected.

Kudos on the proof reading.

~~~
RBerenguel
Well, you can't expect the editor to ask june, july and august, too.

------
latchkey
With the 1.0 beta release of Ceylon, it is pretty clear the JVM is still a
pretty useful basis for new languages... [http://ceylon-
lang.org/blog/2013/09/22/ceylon-1/](http://ceylon-
lang.org/blog/2013/09/22/ceylon-1/)

------
eccp
Neal Ford said: "In a keynote address that I once co-presented with Martin
Fowler, he made a perceptive observation: The legacy of Java will be the
platform, not the language."

------
drderidder
The performance metrics for some JVM-based technologies are really impressive
but I continue to see performance problems with Java (the language) based
software. In my field, very high speed network data processing work is done
with C/C++ out of necessity.

~~~
cgh
You are correct. Java's niche is servers that need to accept a lot of
concurrent connections and middleware that can shove data around via a set of
standard protocols. Outside of those enterprise-centric areas, it's not a
great fit for much else (fast data processing, embedded, games, etc.) I say
this as someone who has worked with server-side Java since 1999.

------
mring33621
Never left, actually

------
brown9-2
The idea that Java is a "Clinton-era relic" is pretty ahistorical when you
consider that Google and Amazon have been using Java on the server side since
their early days - it never went away. The tech press just didn't pay
attention to it.

------
drags
This article makes it sound like an either-or, but JRuby is a mature
alternative that allows you to pair Ruby's excellent web tools ecosystem
(Rails foremost within it) with the ability to shunt off expensive tasks to
Java or another JVM language.

------
jheriko
isn't this just a single example of 'right tools for the job' and the common
sense that ruby has abyssmal performance owing to /its/ architecture compared
to java and so simply can not scale as well as a like for like implementaton
in java (which can be said to have abyssmal performance compared to /good/
native bytes, C or C++ [although that gap is narrowing significantly in many
areas - especially when sloppy code is involved]).

------
alasdair_
Even Groupon, arguably one of the largest Rails-based sites still out there,
is moving away from Rails. (Mostly to Node.js although again, with some Java).

(And yes, obviously Ruby != Rails.)

~~~
camus
Yeah,like "Enterprise" Node.js projects are managable with a team of hundred
of developpers... they are not.

Node sucks at database interaction, sucks at performance(computation) , the
only thing that nodejs does well is concurrency ( handling concurrent
connections ) but it doesnt make the js code running inside nodejs
fast(computation).

In fact it is not. Your server wont die fast because Nodejs can handle a lot
of connections , but the end users will wait a very very long time for a
response. that's the truth about NodeJS.

------
dmiladinov
The second coming of Java the platform (the JVM), at any rate.

------
the_watcher
I'm just a novice programmer, but it is my understanding that Clojure is a
Lisp dialect, it doesn't just feel like Lisp. Am I correct?

~~~
jbooth
It's got some differences, notably a vector type with square [] brackets that
is differentiated from homoiconic function calls in normal (), and also some
hacky stuff with (recur) that they had to do to deal with the JVM's lack of
tail call optimization.

~~~
j_jochem
Isn't [...] just syntactic sugar for (vector ...)?

The point about tail call optimization is interesting though. I wonder what it
would take to implement that on a JVM.

~~~
jbooth
I'm not enough of an expert on Clojure or Lisp to answer (my lisp knowledge is
extrapolated from scheme in college).

I believe that Rich Hickey said that having special notation for vectors (and
for maps, I remember now) was about, basically, yes, that syntactic sugar. He
was specifically comparing to lists in () which are somewhat indistinguishable
from function calls in (), hence an example of overloaded parentheses.

------
aa0
Java is slow. It's going nowhere fast. LLVM on the other hand...

------
teach
"In the summer of 2011, Bob Lee - the [CTO] at Square and a former engineer at
Google - announced... that the web was 'on the cusp of a Java renaissance.'"

I'll bet he wouldn't make that same announcement today.

