2001? Wow, times have changed. What was that? Java 1.3?
Firstly, the features of the language:
- Generics: Java added generics in the 5.0 release in 2004, mainly as syntactic sugar, to stop all these casts from objects from collections being stopped;
- Annotations: also in Java 5. Widely used in the framework of persistence, Spring and elsewhere;
- Type Enumerations: Java 5 adds an enumeration type, which is basically a class (sort of);
- Concurrency: Java 5 added extensive concurrency utils, so multithreading has changed a lot; and
- Claims: In Java 1.4, a very unfinished language function has been added. If this option is enabled when you start your program, assets can check various conditions and bomb if they are incorrect. The fact that you can enable or disable them when you start your program is great for diagnostics.
However, the foregoing is not even a big change. At the beginning of this decade, Java has undergone radical architectural and philosophical changes.
In 2001, the big things were EJB, Swing, and Servlets / JSPs. None of them are actually larger (at least not directly).
Perhaps the biggest thing that will happen in Java (since imho was created) - Spring and Spring, really got big about 5 years ago. Spring is a lightweight container that also tries to hide implementation differences between different providers and APIs. However, the most important thing in Spring is the principle of "control inversion" or "dependency injection". The idea is that classes ("beans") are assembled from an external configuration ("application context").
A typical pattern in previous days of J2EE was the Service Locator. It is now seen mainly as an anti-pattern. Basically you will see a code like this:
public MyClass() { this.dataMember = ServiceLocator.locate("some service"); }
If you go around such an approach these days, you will be seen as an anachronism, amateur rank, extravagant, or some combination of the three.
Dependency injection, in its simplest form, instead introduces the necessary behavior into classes without regard to the actual implementation. Such a separation is deceptively powerful and a deep shift, which the Sun (as before) does not actually have. It also greatly improves unit testing.
Swing is still around, but not so big. Sun has released JavaFX as a competitor to Flash and applet replacements in recent months. I personally don’t think that he has most of the future (as Joel did in his recent podcast, Java on the desktop is mostly dead), but others will not agree.
EJB was great in 2001. Not so much. It was (correctly) considered a nightmare of XML configuration, differences in application servers, which made them largely non-portable (or non-trivially portable, if you prefer), and they are such a heavyweight solution (pre-3.0) that they put on I really have a lot of applications.
EJB 3.0 has taken a much more Spring-like approach for dependency injection (sort of) and POJO annotations (plain old Java objects).
Servlets and JSPs were big in 2001. Struts started then or shortly thereafter and was great until a few years ago. Now it has been surpassed by other more modern web frameworks (such as Struts 2 - there is no real relation to STruts 1, despite the name - Spring MVC, Seam, etc.).
The big thing these days - not just in Java - is coruse for Web and RIA. Flash / Flex and Javascript / HTML / CSS (plus frameworks) run here these days (and yes theres GWT, but it does have a small number).
Weblogic and Websphere are not as large as in 2001. JBoss still has a big boost, but currently my choice of apps is Sun Glassfish v2 or v3 Prelude.
Environment identifiers have also changed. JBuilder was great in 2001. Right now there are only three: Eclipse, Netbeans and IntelliJ (probably in this order of popularity, but I prefer IntelliJ, which is also the only commercial one).