Slashdot Mirror
Java EE 5 Development Waiting on Vendors
twofish writes "Java EE 5 was a major update and most of the major application server vendors
do not yet have compliant versions released. Dr.
Dobb's reports that this is delaying most solution providers from developing
products based on it, as their customers are not ready for them. However there
is some significant movement among the big players. Among the major vendors,
Sun has released support, WebLogic is close with JBoss following soon after.
Oracle has not announced a road map and IBM is lagging significantly behind,
with full support not due until 2008."
Companies in the market for significant numbers of Java EE application servers and their attendant support contracts are rarely in a hurry to adopt the newest and latest technologies. Companies I work with usually lag at least a major revision - sometimes two - behind the bleeding edge.
--- These are not words: wierd, genious, rediculous
SAP released a Java EE 5 compatible application server a few weeks ago.
Why switch? If you need a feature from 1.5 or 1.6 then upgrade. Many server side applications of Java have absolutely no reason to upgrade. Most companies will be using 1.4 for many years.
There are significant upgrades on the rich client side for 1.5 and 1.6 especially in the Look and Feel area. My 1.6 apps in GTK look just like a native app, thus I use 1.6 for on the client side. I still however use 1.4 on the server side since there are no performance benefits for my applications. Nice thing about java is everything is byte code compatible downstream. I am sure there are providers out there who still use 1.3 on the server side.
Are you intolerant of intolerant people?
The architecture of Java 5 EE is unnecessarily complex.
This usually translates as "I don't understand all of the Java features - therefore it must be BAD.
No. Java is necessarily complex. The features aren't their for Sun's entertainment - they're there because certain customers need and use them. It's not the most appropriate environment to build a "little" website, but that doesn't make it "unnecessarily" complex when building big ones.
--- These are not words: wierd, genious, rediculous
I built a EJB3 set of services along with working with another group who built JSF/Seam pages (interface) and using EJB3 stateful session beans and we deployed it all on JBoss using JDK1.5.0_06. In fact we used the J2EE 1.5 - granted we had to "spoof" Eclipse/MyEclipse into using the J2EE 1.5 jars and capabilities. But JBoss worked just fine with it all. This was a company internal application but it worked just fine. We used JBoss 4.0.4 GA Patch 1. I love the JDK/J2EE 1.5 stuff. Wish my current company would move from 1.4.2 to the 1.5.
The Truth is a Virus!!!
Then there is Oracle...gads..when Microsoft finally gets SQLServer up to speed (and they will...they have a 20 year history of turning crap into gold)...Oracle is going to be standing out in the weeds wondering what the hell happened
What exactly does MS SQL Server and Oracle's RDBMS have to do with J2EE 5 and Oracle's Application server? You may or may not be right about SQL Server eventually supplanting Oracle as the big name RDBMS, but regardless, that's not what's being discussed here. The application server is completely separate from the DB server.
but having to trust IBM and Oracle to keep up is a major problem, without them showing REAL plans: I am left with Sun driving the bus ?
Hardly; JBoss and BEA (producers of WebLogic) have already released compliant servers. Given that I've only heard bad things about WebSphere (or indeed much of IBM's technology stack), I'm really not too concerned.
well we all know what can happen when you let geeks (and I am one) run free, then don't execute on what they make
What tends to happen in my experience is that they get it more or less good enough for their own use, then move on to the next thing that captures their imagination. That's all well and good, but someone needs to put in the remaining, tedious 80% of the effort to do all the boring tidying up, polishing, documentation, possibly accreditation, etc.
It's official. Most of you are morons.
I used to be very much into J2EE (even wrote a book on it), and it is great to see the platform evolve as the Java language evolves.
:-)
That said, I have "moved down the food chain", starting to favor just running Tomcat+custom tag libs+JSPs+persitence. I used to mostly use Hibernate, then simplified to using Prevaler. In the last year or two, I have favored Rails for small quick web apps.
J2EE is great for large scale projects, but for most web apps and portals there are easier to use solutions. I have even gone back to using Common Lisp for web apps and web services in the last year (that is "moving back up the food chain"
Excuse me? I develop software for a large European financial institution. I understand perfectly the complexities of enterprise development. Except that we use Smalltalk, rather than Java. Smalltalk offers many of the same OO capabilities as Java, and then some. But unlike Java, Smalltalk is about writing tight, compact class hierarchies. It's about architectures that are so simple that they naturally scale. We have Smalltalk-based financial systems that process 500000 or more transactions each hour, all running on DEC Alpha hardware from a decade ago.
And no, I don't know all the features of Java EE. Nobody does, because it's so unnecessarily complex. If somebody claims to, you know immediately that they are a liar. Ask those people if they know Smalltalk, or have even heard of it. Chances are they won't have. Thus the don't know how unnecessarily complex Java EE is for enterprise applications, as they have nothing better to compare it to.
No. Java is necessarily complex. The features aren't their for Sun's entertainment - they're there because certain customers need and use them. It's not the most appropriate environment to build a "little" website, but that doesn't make it "unnecessarily" complex when building big ones.
.invoke() a function.
I stopped J2EE at JDK 1.4 and EJB 2.0, so perhaps J2EE 5 has some useful features. However, I can say with some certainty that Sun's spec have been on the one hand grossly overdesigned and on the other hand ridiculously limited. Examples:
java.io.*
1. Why in the world should a FileInputStream/FileReader not automatically use a BufferedInputStream/BufferredReader underneath?
2. Why can't one just read a String from an InputStream by passing an encoding?
java.net.HttpUrlConnection
1. Why can't I get the actual HTTP error number and error page returned by a web site? (If you didn't already know, 404's are not returned as a generic error but rather thrown as a FileNotFoundException. But it also does it for 403, 405, and others so that you can't actually report the REAL error code. Also, in JDK 1.2.2, the function getErrorStream() returned null in all non-404 cases.)
java.lang.ref.*
1. The API to reference methods and variables is silly with all the Exceptions one must catch just to
EJB - Actually, just read Bitter EJB. There's 200 pages of complaints and solutions, all hinging on the fact that Sun pushed a standard before they had any applications out there that needed this kind of functionality.
Swing - Read Bitter Java. Another 200 pages saying that Sun made Swing without even trying to use it on an Office-like application.
The really funny part
This usually translates as "I don't understand all of the Java features - therefore it must be BAD.
Yes, it is very bad if your developers can't easily understand the tools they're working with. That directly leads to poor software systems that will often completely fail.
Look at the Java EE 5 API for yourself: http://java.sun.com/javaee/5/docs/api/
There are literally hundreds of interfaces and classes you'd need to understand to have a full knowledge of Java EE 5. Of course, that's in addition to the hundreds of interfaces and classes of the standard Java class library.
Just look at some of the class names. One particularly bad one is javax.faces.component.ActionSource2. Why the fuck is a class called "ActionSource2"? To me, that's a sign of very poor object design. Unfortunately, this is the sort of stuff we see throughout the Java world.
No, Java is often unnecessarily complex. Most languages get by with arrays; Java has arrays, Arrays, Vectors, and ArrayLists, all with subtly different APIs. Ditto Hashtable and HashMap. Mostly this explosion of APIs has happened because Sun hasn't thought through the design before adding stuff to the language.
Then there's the whole EJB and EJB QL fiasco. Massive amounts of additional complexity added for zero gain.
GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
The differences you describe are there for concurrency. A Vector is a thread-safe List. A Hashtable is a thread-safe Map.
Futhermore, you shouldn't be programming to concrete implementations like Vector, ArrayList or HashMap anyway. You should be programming to interfaces like List or Map so that implementation differences don't matter.
I.e., if it ain't broke, don't fix it.
007: "Who are you?"
Pussy: "My name is Pussy Galore."
007: "I must be dreaming..."
Yes you are right, Java is not popular at all. In fact I am always amazed at the way there are more adverts for Java jobs than just about any other skill (usually number 1 sometimes number 2) when hardly anyone uses it. I guess the companies just like paying for adverts for the fun of it.
Um. I think you're confused about the meaning of "complex". I find the JDK's collection classes to be decidedly lacking in unnecessary complexity. As a matter of fact, they reduce complexity, by hiding data structures behind generic interfaces. It's called polymorphism. In contrast, if all I had to work with were arrays, my application code would need to be much more complex.
1. Why in the world should a FileInputStream/FileReader not automatically use a BufferedInputStream/BufferredReader underneath?
Why do you assume that filereaders must be buffered? I agree that the syntax for reading files is horribly redundant, but I bet with a few static imports, I could make java file handling code look downright pythonish. Write convenience methods for godsakes, don't listen to the aescetic code monks who insist you use nothing but the standard library.
I stopped J2EE at JDK 1.4 and EJB 2.0, so perhaps J2EE 5 has some useful features.
I'll say -- EJB3 is much simpler, for one! It's not without its problems, but it actually makes a lot more sense now. I'd agree that a large number of Sun's API's are bloatastically overengineered, but EJB really has gotten its long-needed overhaul. Other than perhaps optionally dispensing with local interfaces altogether and just using the raw class, I really can't see how it can get any easier.
Sun pushed a standard before they had any applications out there that needed this kind of functionality.
This is a wholly unfounded opinion -- there were in fact plenty of apps that needed what EJB was offering, things like reservation systems that needed to coordinate across multiple vendors. Only problem was that it didn't go far enough for the shops that did need it, and that 90% of business apps were simple CRUD apps that didn't need it at all. Java's got the enterprise and embedded angles covered, but it's still not offering a whole lot toward the middle. Not that I think that offering a mediocre platform is the answer, but they could at least have offered better tooling instead of assuming you'd have a massive team of "enterprise architects" putting apps together. But go look at EJB3 -- there's some signs that they're actually catching on.
And I don't even like Java -- the language itself, that is.
Done with slashdot, done with nerds, getting a life.
I remember when Weblogic got support for EJB 2.0 (I think; it was a while ago now). They were much more prompt about that. They had it implemented and in production use before the standard was even done getting major changes. When we switched (for cost reasons) to JBoss, almost all of the porting effort was in porting from the intermediate version of the standard that Weblogic had implemented to the actual released version.
> Look at the Java EE 5 API for yourself: http://java.sun.com/javaee/5/docs/api/
Then when you're baffled by reading reference docs, go read the tutorial: http://java.sun.com/javaee/5/docs/tutorial/doc/
Done with slashdot, done with nerds, getting a life.
I agree to your accessment, however, the GP post is also correct regarding "subtly different" APIs - which is annoying.
At least, any good API designer would have named them "ReentrantList" and "ReentrantMap" other than inventing new names "Vector" and "Hashtable" out of thin air that bear no semantic resemblance to what the classes actually do.
Let the interfaces have generic names, but the concrete implementations should at least be named clearly for what it does.
I hope this would change when Java generics become powerful enough to support metaprogramming, like C++ templates do - since it would support policy-based design - so instead of Vector, ArrayList, HashMap, you'd have Map<Reentrant> or List<Reentrant>.
This is a seriously important debate.. But there is no one right answer.
On the one hand, you have the perl paragidm - keep absolutely everything in one file.. code, docs, API, meta-information.. In perl you had __DATA__ and __POD__ sections of the file for meta-data and documentation.. In Java you've almost always had javadocs, then xdoclets, and now annotations.
The advantage of this is the idea that code-changes almost always necessitates doc changes or meta-data changes.. The further away those items are from the code, the greater the probability that they'll get out of sync.
ALSO, new-commers that see the code for the first time won't have as far to go to get all the information about the code that is relevant.. If they are paging through a new project, they may not know where the associated meta-data XML files are.
Now, good annotation packages (like hibernate-annotations) allow you to override just about every possible annotation in use... And as a result, it makes the most sense to only annotate to the degree that generality necessitates.. Consider this object-oriented annotations (even though it's a hack-job on the back-end, because the code has to know to recursively check for annotations and XML in all the right places).
The other side of the story is important too... That if your code is dependent on annotations (say you're hack-job didn't facilitate XML overrides), then you reuse code in two different contexts, you're screwed, because you've historically coded to one annotation schema, but then in one or more use cases, those annotations are not correct.. This is most common in interfaced' API libraries (with little or no actual code). If say a @Transactional attribute is present in the API, but it's being deployed in a non-transactional environment (say a trivial front-end web-app that doesn't do any DB activity and thus doesn't have a registered transaction manager), then you might be in for a shock when you first deploy the code. That being said, things like @Transactional are encouraged to exist only in the class implementation code, not in the interfaces. But you might have a poor annotation package which doesn't handle this properly.
Another example is if you define schema attributes on the POJO, say
@Length(max=32) String firstName;
Then you use this Person object everywhere... Well, not every place is going to want a column length of 32 chars (though this might be a good-thing).. Again, in Hibernate at least, you can always override in XML for a particular deployment... But it violates the use-case above of a 1'st time prorammer paging through the code.. Now they have a false expectation.
I'm sure there are other pros and cons. But Annotations are far better than xdoclet.. And xdoclet as a paradigm has exploded.. For trivial one-use-case code, xdoclet and annotations are a god-send. Consider EJB2 XML files and meta-interfaces which are a nightmare. All are handled elegantly via annotations. Less code/files == less chance for error.. Concice with little revocation of flexibility. Though in huffman-coded style, that old flexibility now requires twice as much conceptual complexity (knowing to look at XML for only special cases - and thus forgetting about it).
-Michael