Actually, they've moved beyond that now. The trend in high speed trading is towards FPGAs. "Java don't play that." (not in any serious way).
Java in finance is actually slowly eroding overall. Performance-critical logic is being moved into Python modules written in C. "That's how we do it" anyway. The trouble is that Java code development is too slow and just getting your code deployed into a test environment is often ridiculously complicated (lots of middleware) whereas with Python "you write, you run, you're done."
It's still popular. For example, LMAX still uses Java. There were a number of things you needed to avoid if you wanted to use it where latency mattered though. GC pauses are fairly detrimental.
Where latency is really critical, things are implemented in FPGA though.
Even before 0x, a there was definitely a genuine performance need that drove a lot of stuff from Java to C++. A lot of people I know would write Javaish code with Boost.
A lot of the stuff that makes Java great for building high level systems quickly is still kind of missing from formal C++ though (IoC, JMX, etc...), and it would have been nice to see some of the internal stuff get open sourced.
I wonder if people are starting to avoid Java because of Oracle (e.g. vs Google).
Before 0x, Java didn't matter for production code as the 1.3 with JIT came later than that.
But in those days it was a big mess to write portable C++ code, given the discrepancies between compilers.
I don't miss those CORBA and DCOM libraries, but I miss OWL and VCL.
Java is still quite strong in the Fortune 500, and most managers don't care about Oracle vs Google, as it was caused by Google trying to avoid to pay Sun anyway.
However I sense some signs similar to when CA started loosing CLIPPER's direction, or when Borland attitudes started scaring people away from Delphi and C++ Builder.
On the other hand, Java is just too big and it will take generations to replace all those systems.
The earliest version of Java I worked with in production was 1.5, but the group I was working with had been using it in production a long time before that. There were other groups using Java for a lot of other things (JDBC, JMS, etc...). All the stuff I worked with relied on core Java and NIO though, which I'm not entirely sure how a lot of things were done before 1.5.
Java is definitely still really popular for development overall (TIOBE 2015 #1). My personal concern with Oracle vs. Google though is that Oracle does not own the language, and the copyright claim on APIs seems pretty aggressive. The JVM and Java have open specifications which in theory anyone should be allowed to implement (practice is admittedly a bit different). Even the official JDK was open source, which Oracle seems a bit hostile toward considering what they've done with purchases like MySQL and how the community largely responded.
Claiming copyright on an API seems somewhat akin to Keurig 2.0. Although, I think courts are having trouble keeping pace with technology.
I have been using occasionally Java since it was made available in 1996.
Our university adopted it right away and made it in 1997 the official language for compiler development and distributed systems classes.
Without bothering to search the Internet, NIO was either introduced in 1.4 or 1.5.
Yes they have open specifications, but they also have trademarks and compliance certifications.
The JDK was open source, but the license prevented its use for mobile devices without a Sun approved license, that Google didn't want to pay for.
So now Google has actually created a fork in the Java community.
Just imagine when you have Java 9 with modules, or Java 10 with reiffied generics, value types, JNI replacement, official unsafe package, among many other roadmap features, how to keep the code portable between Android Java and the real Java.
edit: The article does state at the end that google will still modify OpenJDK for their own needs, but that still means that the vast majority of the implementation will be the same, so this seems to avoid most incompatibility issues.
Thanks, I actually missed this. The difference with modifying OpenJDK is that it's a common codebase as opposed to a language fork.
I know Redhat is one of the other major OpenJDK contributors, and a lot of distributions are relying on IcedTea. It will be interesting to see how this develops.
NIO was 1.5. Before that, a lot of network programming wasn't practical where performance was a concern. I would guess it was the same with Linux before 2.6.
Java in finance is actually slowly eroding overall. Performance-critical logic is being moved into Python modules written in C. "That's how we do it" anyway. The trouble is that Java code development is too slow and just getting your code deployed into a test environment is often ridiculously complicated (lots of middleware) whereas with Python "you write, you run, you're done."