In practice, anything involving the JVM is often a heavyweight thing
Last week I asked on Twitter if anyone had a good replacement for swish-e for indexing and searching some HTML pages. Several people suggested Apache Solr; my immediate reaction was that this sounded too heavyweight for what we wanted. It was then asserted that Solr is not that heavy if you disable enough things. I had a number of reactions to that, but my instant one was 'nothing involving the JVM is lightweight'. Today I want to talk about that.
I don't call JVM-based things 'heavyweight' because Java itself can
easily eat up lots of memory (although that's certainly a potential
issue). What makes the JVM heavy for us is that we don't already
run any JVM-based services and that all too often, Java is not like
With languages like Python, Perl, Ruby, or even PHP, as a sysadmin
you can generally be pretty indifferent to the language the system
is written in. You install the system (ideally through a package
manager), you get some binaries and maybe some crontab jobs, and
you run the binaries. You're done. With Java, my impression and to
some extent my experience is that you also have to administer and
manage a JVM. A Java system is not run some programs and forget;
.jars in the right place, it's loading certificates
into JVM trust stores, it's configuring JVM parameters, and so on
and so forth. There is a whole level of extra things to learn and
things to do that you take on in order to maintain the JVM environment
for the system you actually want to run.
(One way to put it is that a JVM seems to often be a system inside your normal system. You get to maintain your normal system and you also get to learn how to maintain the JVM system as well.)
All of this makes any JVM-based system a heavyweight one, because adopting it means not just learning the system but also learning how to manage a probably-complex JVM environment. If we were already running JVM based things it would be a different issue, of course, because we'd probably already have this expertise (and the JVM way might even work better for us), but as it stands we don't.
(Similar issues probably hold for any Node-based system, partly because of Node itself and partly because Node has its own very popular package management system that we'd probably have to learn and wrangle in order to run any Node-based thing.)
It's probably possible to design JVM-using systems that are not 'JVM-based' in this way and that encapsulate all of the complexity inside themselves. But I suspect that something labeled on its website as 'enterprise' has not been designed to operate this way.
(I've mostly talked about the JVM instead of Java specifically because I suspect most of these issues also apply to any other JVM-based language, such as Scala, Clojure, and so on.)