
Java tools and technologieslandscape for 2014 - lukaseder
http://zeroturnaround.com/rebellabs/java-tools-and-technologies-landscape-for-2014/
======
checksum404
Looks like Scala is widening its adoption lead over Clojure. I think the
latter is going to become a niche language for large-scale data processing,
while the former takes its place as the next enterprise language.

~~~
drcode
Same old story: Developers aren't interested in it if it isn't friendly to the
old school OOP + MVC approach. If you give most professional developers
something like Clojure, their first thought is "How do I architect a large
application this way?" and they don't know the answer.

(This is speaking as someone who thinks Clojure is the best language on the
planet right now...)

~~~
bdavisx
So it sounds like Clojure needs a really comprehensive guide/book on how to
architect a large application.

~~~
dominotw
I think it needs a 'killer app' like rails/hibernate etc which are compelling
enough for me to look at a new language.

------
virtualwhys
How on earth does Scala garner nearly 50% developer interest in the survey??

That's quite a surprise given the bashing Scala has taken of late (AKA the
Paul Phillips Scala "tribute" tour), and the general thumbs down that Scala
receives on HN, Reddit, etc.

Kotlin should pick up some steam once a stable release comes around, they've
done a good job cherry picking the best of Scala while avoiding the kitchen
sink baggage that Scala hopes to shed somewhere down the road (with Scala 3
backed by Dotty[1]).

Not sure about Clojure, certainly has a following, but is probably not going
to appeal to the enterprise crowd, whereas Scala, Kotlin, Ceylon, etc. type
safe and familiar-ish syntax languages will.

Java 8 (and 9 to come) is the elephant in the room, hopefully won't crush
alternate JVM language adoption, diversity's a good thing.

[1] [https://github.com/lampepfl/dotty](https://github.com/lampepfl/dotty)

~~~
DCKing
I don't get the equation of Scala and Kotlin and Ceylon.

Ceylon and Kotlin grab the low-hanging fruit. They are better Javas. These
languages bring nothing new to the table at all. They will actually suffer
from Java 8, because Java 8 itself is a better Java like they are. People
write Kotlin and Ceylon because they need to write a Java app but they don't
want to write Java.

Scala is not meant to be a better Java. It can be used in that way, but it's
not meant to be. It has a vastly richer set of features, probably one of the
most sophisticated type systems of any language, and a growing number of
Scala-specific libraries. In addition to people writing Scala because they
don't want to write Java, there exist many people that want to write Scala
_because of Scala_.

The same general argument seems to apply to Clojure. Just because your
language runs on the JVM doesn't mean it's just an alternative for Java.

(This is not to say that I don't think Kotlin at least is shaping up to be a
beautiful language.)

~~~
pron
The question is one of numbers. How many Scala developers use it as a better
Java, and how many use it for its "richer set of features". The first group
would likely benefit more from Kotlin (as those other features are, IMO,
Scala's Achilles heel), and if that group is the larger one (and I suspect it
most certainly is), then Kotlin is in direct competition with Scala.

As to "bringing nothing new to the table at all", I'm not sure about that. It
depends on your definition of "nothing" and "something". I think they
certainly bring convenience, and their[1] switching costs are orders of
magnitude lower compared with Scala's. The question is, then, is the
"something new" Scala brings worth the price. Again, the answer to that
depends on the user. Some will think it most certainly is; others will find
the cost way too high.

[1]: Well, Kotlin's; not Ceylon's

~~~
DCKing
It's maybe even wrong of me to lump Ceylon and Kotlin together. Kotlin
definitely is richer (and closer to Scala in features) and can also compile to
JavaScript, which puts it in a different boat.

As a straight and immediate Java replacement, I'd definitely recommend Kotlin
as well. If you want to switch over existing Spring apps, you will not get the
best out of Scala. Scala, in my experience, is most effective when written
without Java goggles on. But Scala definitely has large advantages for new
projects or broad refactorings.

~~~
lmm
Ceylon also targets compile-to-javascript. (I thought Kotlin kept the standard
Java library - have they compiled a version of that for javascript or what?)

~~~
pron
I'm not sure about Kotlin's plans re Javascript standard libraries, but I
guess the approach is similar to Clojure, i.e. being a "hosted language" aimed
at easy integration with the host environment (plus a very basic "common"
standard library).

~~~
lmm
If anything that makes it less reliable for compile-to-javascript than Ceylon,
no? (AIUI Ceylon abandons the Java standard library in favour of its own,
partly so that you have the same standard library for either target).

------
applecore
It's interesting to see the popularity of testing frameworks, continuous
integration, and static code analysis in the Java community.

What do people think about Gradle as a build tool (versus Maven)?

~~~
lmm
Maven is wonderful because it means I can pick up any Java project and there
will be no surprises in how it builds; it simply won't allow your project to
be a special snowflake with its own weird rules. I wish the community would
cherish this and stop writing tools that make it possible to set up more
complicated builds.

~~~
vorg
From the article...

> In the past, Maven (64%) and Ant + Ivy (16.5%) have been more or less neck
> and neck. Indeed, we believe that many developers often use both in
> different ways on complex projects – in 2012, 67% of respondents used Maven
> and 48% used Ant. [...] Ant with or without Ivy is only one-third as
> commonplace as it was reported in 2012. The rapid increase of Gradle (11%)
> is also interesting to witness. Since 2012, Gradle use has more than doubled

The 2014 question was what build tool is used most often, whereas the 2012
figures are for what build tool was used, with some overlap.

So Maven use has stayed high for those using it, whereas Ant users have either
given up on it, use Maven more often, or have switched to Gradle (which is
still Ant).

I wouldn't trust the download numbers given by the Gradleware CEO, though. The
Groovy ecosystem has a long history of fabricating numbers, e.g. look at
[https://bintray.com/groovy/maven/groovy/view/statistics](https://bintray.com/groovy/maven/groovy/view/statistics)
and see 865,000 downloads of Groovy in the past month, then click on _country_
and see 822,000 of them are from China, and only 17,000 from the US.

------
thescrewdriver
Also interesting to see Java apps by type according to the survey:

Web applications: 71%

Libs and frameworks: 15%

Desktops: 11%

Mobile: 3%

I'm surprised mobile is so low given that Java is what's used to write Android
apps.

~~~
pron
I think that's more of a reflection of the RebelLabs blog readership than the
Java developer community at large. Their products as well as their blog, are
geared mostly to web developers.

------
heterogenic
I'd love to see a comparison among the same sample set between Java8 & Scala
as the next environment they're likely to use.

Scala has been "the next big thing" for a while now, but I'm just not
convinced that the Java ecosystem is looking for a next thing at all.

To be clear: I absolutely agree that we can do better than Java, and though I
prefer Clojure, Scala is certainly a step up. I'm just not convinced that the
practical realities of its user base are enough to drive that change, which
limits my willingness to move my organization in that direction.

------
yawz
Am I wrong in assuming that the responders are JRebel users? I'm asking this
question because I wonder how representative is this sample compared to the
industry in general (I know, this could be asked about any survey, really).

For instance, use of MySql with 32% seems too high to me, this, compared to
what I've seen around. The main persistence solution of 1 out of 3 of my
connections is not MySQL.

~~~
benjaminpv
That's a great point. JRebel's the kind of tool I imagine a lot of middle-
sized (not startup sized, not yet enterprise) codebases probably haven't
evaluated, so I'd imagine it's tied to MySQL being a frequent choice for new
apps and the quick choice for a one-off internal app in the enterprise.

While this is anecdotal, like you I've find the DBs most of the Java apps I
encounter aren't MySQL, but a mix of Postgres, MSSQL and Oracle.

~~~
ekabanov
Unfortunately this is exactly the kind of anecdotal which just doesn't work.
Popularity of tools and technologies varies greatly between geographies,
industries and maturity. E.g. English-speaking world and German-speaking world
value tools and techs in entirely different ways.

------
jebblue
Slide 3 doesn't speak for me except for Java 8. I've looked at Scala, don't
like the syntax, give me heartburn like trying to look at Lisp, Smalltalk,
Ruby or Haskell. Eclipse so totally rocks, it beats the $1000+ cost of Visual
Studio and Intellij isn't even in my rear view mirror. Gradle, syntax does not
work in my brain, I get the same feeling as when looking at the languages I
mentioned earlier. Give me make, Ant and/or Maven (though you have to be
careful to keep Maven on a short leash).

------
vorg
_From the end of the article..._

The TL;DR version for efficient readers

Java versions – Adoption since 2012 of the newest Java versions has been
strong, namely growth in Java SE 7 and Java EE 6…the fact that certain older
version of Java SE and EE still command decent minorities is a bit odd, but
nothing to fear.

IDEs – Eclipse is a very stable market leader, but increasing favor and
interest in IntelliJ IDEA may eventually equalize things.

Alternative JVM languages – Scala is the most interesting, enterprise-ready
language on the JVM, and Groovy & Clojure play a great counterpart to the non-
Java coding movement.

Build tools – Maven’s dominance is now unquestioned with Ant’s decline from
previous years, although fast-growing Gradle is extremely interesting to
respondents.

Application servers – Open-source players like Tomcat, JBoss, Jetty and
GlassFish dominate both production and development environments, which use the
same technology for 81% of respondents, although it’s clear that development-
only app servers in the highest favor are Jetty, Tomcat & TomEE.

Web frameworks – A mature and fragmented market, over 1/3 of developers use
more than 1 web framework, and here Spring MVC is still king in this area,
with stable JSF and growing Vaadin following

Object-relational mapping frameworks – When it comes to ORM, Hibernate takes
the cake, although other technologies are available and in common use in
parallel.

Code analysis tools – Although nearly 1/3 of developers don’t use these tools
(big mistake), the market is rich with complementary technologies like
FindBugs, CheckStyle and a platform to bring it all together, SonarQube.

Continuous Integration (CI) servers – Jenkins’ dominance here is stronger than
ever, yet 1 in 5 developers still don’t use CI as a practice.

Databases: SQL and NoSQL – The mature SQL is dominated by Oracle, but the
market has a good mix of free/open-source and proprietary offerings from long-
time players. NoSQL is a maturing segment that is mainly driven by MongoDB.

Version Control Systems (VCS) – Git, supported by the headline-worthy GitHub,
is finally reigning supreme over Mercurial as a distributed VCS, and is often
used in parallel with the legacy Subversion (SVN).

Repositories – A maturing market that still needs a lot of adoption by
developers, the legacy market leader Nexus is losing ground to JFrog’s
Artifactory.

Testing frameworks – In this area, complementary technologies work better
together rather than competing, with unit testing, mocking and browser testing
all highly practiced using strong tools like JUnit, Mockito and Selenium
respectively.

Priorities for 2015 – Java 8 (obviously), Continous Delivery / Deployment and
Non-Java programming using alternative JVM languages are the 3 top priorities
for the next year according to respondents.

------
thescrewdriver
It's very interesting to see the data for what technologies Java developers
are "really interested" in:

Scala: 47%

Java 8: 35%

[http://zeroturnaround.com/wp-content/uploads/2014/05/what-
te...](http://zeroturnaround.com/wp-content/uploads/2014/05/what-technologies-
are-developers-interested-in.jpg)

Java developers seem really interested in Scala (more so than Java 8). I think
the distinction which will come in when comparing technologies that developers
want to use and are really interested in vs those that they will actually use
given inertia of existing code and corporate adoption.

~~~
pron
Those are answers to two very different questions, and the percentages aren't
comparable. The Scala one asked what JVM language would you learn next, if you
were to learn one, while Java 8 is the answer to the question: what is your
top new-tech priority for 2015?

~~~
randomsearch
> Those were two different questions. The Scala one asked what JVM language
> would you learn next, if you were to learn one

Indeed. I wonder if the result is a bit misleading, because many Java
developers may not really have considered other languages, and Scala is the
most well-publicised. So the question may just translate to "name another JVM
language." Kinda reflects with Groovy too, which has been around quite a while
now and does well in this question, despite not being very "popular" in the
various language league tables.

~~~
thescrewdriver
The results for that question are very interesting too (although perhaps not
that surprising). There was virtually no interesting in Xtend.

~~~
lukaseder
Can Xtend even be compiled to Java outside of Eclipse? I haven't been
following recent improvements, but when I last checked, that wasn't possible.
So it was essentially an in-IDE-only language, nice for little scripts, but
completely useless for larger applications (or teams)

