If you’re old enough to have been around back then, you might remember Java’s early, epic peak. It left the labs, and its hype meter pinned. Everyone saw it as a revolution that would stop at nothing less than a total takeover of computing. That prediction ended up being only partially correct. Today, Java dominates Android phones, enterprise computing, and some embedded worlds like Blu-ray disks.
For all its success, though, Java never established much traction on the desktop or in the browser. People touted the power of applets and Java-based tools, but gunk always glitched up these combinations. Servers became Java’s sweet spot.
Where Java wins: Rock-solid foundation
Where Node wins: Ubiquity
Where Java wins: Better IDEs
Java developers have Eclipse, NetBeans, or IntelliJ, three top-notch tools that are well-integrated with debuggers, decompilers, and servers. Each has years of development, dedicated users, and solid ecosystems filled with plug-ins.
Meanwhile, most Node.js developers type words into the command line and code into their favorite text editor. Some use Eclipse or Visual Studio, both of which support Node.js. Of course, the surge of interest in Node.js means new tools are arriving, some of which, like IBM’s Node-RED offer intriguing approaches, but they're still a long way from being as complete as Eclipse. WebStorm, for instance, is a solid commercial tool from JetBrains, linking in many command-line build tools.
Of course, if you're looking for an IDE that edits and juggles tools, the new tools that support Node.js are good enough. But if you ask your IDE to let you edit while you operate on the running source code like a heart surgeon slices open a chest, well, Java tools are much more powerful. It's all there, and it's all local.
Where Node wins: Build process simplified by using same language
Complicated build tools like Ant and Maven have revolutionized Java programming. But there's only one issue. You write the specification in XML, a data format that wasn't designed to support programming logic. Sure, it's relatively easy to express branching with nested tags, but there's still something annoying about switching gears from Java to XML merely to build something.
Where Java wins: Remote debugging
Java boasts incredible tools for monitoring clusters of machines. There are deep hooks into the JVM and elaborate profiling tools to help identify bottlenecks and failures. The Java enterprise stack runs some of the most sophisticated servers on the planet, and the companies that use those servers have demanded the very best in telemetry. All of these monitoring and debugging tools are quite mature and ready for you to deploy.
Where Node wins: Database queries
Meanwhile, many Java developers use SQL. Even when they use the Java DB (formerly Derby), a database written in Java for Java developers, they write their queries in SQL. You would think they would simply call Java methods, but you’d be wrong. You have to write your database code in SQL, then let Derby parse the SQL. It's a nice language, but it's completely different and many development teams need different people to write SQL and Java.
Where Java wins: Libraries
Where Node wins: JSON
When databases spit out answers, Java goes to elaborate lengths to turn the results into Java objects. Developers will argue for hours about POJO mappings, Hibernate, and other tools. Configuring them can take hours or even days. Eventually, the Java code gets Java objects after all of the conversion.
Where Java wins: Solid engineering
It's a bit hard to quantify, but many of the complex packages for serious scientific work are written in Java because Java has strong mathematical foundations. Sun spent a long time sweating the details of the utility classes and it shows. There are BigIntegers, elaborate IO routines, and complex Date code with implementations of both Gregorian and Julian calendars.
null. Which is right? Well, each has its role -- one of which is to drive programmers nuts trying to keep them straight. Issues about the weirder corners of the language rarely cause problems for simple form work, but they don't feel like a good foundation for complex mathematical and type work.
Where Node wins: Speed
People love to praise the speed of Node.js. The data comes in and the answers come out like lightning. Node.js doesn't mess around with setting up separate threads with all of the locking headaches. There's no overhead to slow down anything. You write simple code and Node.js takes the right step as quickly as possible.
This praise comes with a caveat. Your Node.js code better be simple and it better work correctly. If it deadlocks, the entire server could lock up. Operating system developers have pulled their hair out creating safety nets that can withstand programming mistakes, but Node.js throws away these nets.
Where Java wins: Threads
Fast code is great, but it's usually more important that it be correct. Here is where Java’s extra features make sense.
Java's Web servers are multithreaded. Creating multiple threads may take time and memory, but it pays off. If one thread deadlocks, the others continue. If one thread requires longer computation, the other threads aren’t starved for attention (usually).
If one Node.js request runs too slowly, everything slows down. There's only one thread in Node.js, and it will get to your event when it's good and ready. It may look superfast, but underneath it uses the same architecture as a one-window post office in the week before Christmas.
There have been decades of work devoted to building smart operating systems that can juggle many different processes at the same time. Why go back in time to the ’60s when computers could handle only one thread?
Where Node wins: Momentum
Yes, all of our grandparents' lessons about thrift are true. Waste not; want not. It can be painful to watch Silicon Valley’s foolish devotion to the “new” and “disruptive,” but sometimes cleaning out the cruft makes the most sense. Yes, Java can keep up, but there's old code everywhere. Sure, Java has new IO routines, but it also has old IO routines. Plenty of
util classes can get in the way.
Where both win: Cross-compiling from one to the other
Voilà. All of the code can link to each other harmoniously and you don't need to choose.
- Free course: Get started with AngularJS
- PHP vs Node.js: An epic battle for developer mind share
- Review: The big four Java IDEs compared
- Download: Apple Swift, a programming primer
- Download: The care and feeding of a rockstar developer
- 10 capabilities we want to see in HTML6
- Attack of the one-letter programming languages
- 9 cutting-edge languages worth learning now
- 10 battles raging for the hearts and minds of developers
- 15 technologies changing how developers work
- 12 predictions for the future of programming