Building Java Enterprise Applications, Volume I

David Kennedy writes: "This is a review of Brett McLaughlin's new O'Reilly title, Building Java Enterprise Applications. Volume 1: Architecture, subtitled Designing with EJBs, Databases, and Directory Servers." Read David's in-depth review, below. Building Java Enterprise Applications, Volume I: Architecture author Brett McLaughlin pages 300 publisher O'Reilly rating 9 reviewer David Kennedy ISBN 0596001231 summary Practical guide, with examples, for building a J2EE application from scratch.

Summary: Building Java Enterprise Applications is an excellent book, and ought to be on the bookshelf of every J2EE programmer working on the mid- and back-tier. If you are like me, then you then have a series of books on various parts of the J2EE alphabet soup -- a few on EJB/JNDIs, one on JMS, one on RMI, one on JDBC, a database/SQL primer, a J2EE patterns book (I recommend Depur et al. by the way), maybe even some hyped-up case studies from Sun's press etc -- but nothing on how to design an entire J2EE application from scratch. There is nothing scarier than a blank piece of paper at the beginning of a project -- this book provides a combination of a tutorial and worked example, along with an insight into the thought processes of the designer.

There are not enough books of this type for the J2EE platform; the emphasis on tying together disparate technologies to build a coherent system is exactly what I need at this stage of my career, and I found the author's constant revisions and tweaking of his design fascinating and reassuring. I'm going to pre-order Vols. II and III.

Check your sources.

You might recognise the author's name -- Brett McLaughlin is the author of another O'Reilly title, Java & XML*, and writes for flashline.com, IBM Developer Works, JavaWorld and others. You can either Google for these or visit the web-site newInstance. In my opinion he knows his onions, is aware of what other root vegetables are out there, and, most important, he can communicate well.

What's the book about? I'll give you a bit of the blurb first, as it's a fair description of the material:

"Java has many enterprise APIs: JNDI, EJB, JMS, JAXP, and the other XML APIs, JDBC and more. But how do you as a developer put the pieces together and build something that works? How do these components integrate with back-end servers (databases and directories) and with front-end platforms (web servers and web services)?"

"[This] is Volume I of that series; it covers the business logic and back-end of an enterprise system, including entity EJBs, JDBC, JNDI (...), and JMS. Volume II will discuss architectures for web applications; Volume III will venture into the still-uncharted territory of web services."

That's quite an ambitious series; and something of a departure in style for O'Reilly, who have built their enviable reputation by providing definitive titles on one technology at a time. This more a book on when to use a tool, and which tool to use, rather than how to use a tool. I think it's good to see O'Reilly branching out in this way, but it brings them into the preserve of other publishers. It might be interesting to see how this new type of title does.

So what is covered in detail? Let's have a detailed look at the contents:

1. Introduction
2. Blueprints
   This chapter outlines the case study that the author uses for the remainder of the book. This takes the form of a simple, but not trivial, financial-services tool. The blueprints are high-level sketches of the business need, the Data Layer, the Business Layer, and the Presentation Layer.
3. Foundation
   This covers designing the data stores, databases and directory servers.
4. Entity Basics
   Basic design patterns, coding and deploying beans.
5. Advanced Entities
   IDs and CMP, data modeling and the nasty details.
6. Managers
   Managers, in the facade sense, for entity beans and the LDAP directory.
7. Completing the data layer
   Nasty details, populating the data store.
8. Business Logic
   The facade pattern and stateful/stateless design.
9. Messaging and packaging
   JMS on the client and server. Packaging.
10. Beyond flexibility
    The wrap-up chapter, covers the major design points, discusses adapting the material to your own projects, and hints and what presentation layers may be added as a teaser for Vols. II and III.

As you can see there are no surprises in the contents. Once the high-level problem and solution is laid out, there's just a sensible progression through the layers. I particularly liked the practice of stopping and reviewing at regular checkpoints -- it helped tie the material together and emphasize the layering in the design.

There are some detailed appendices giving vendor specific instructions for databases, containers etc. This section also contains all the non-unique code for each layer, e.g., all the entity beans that weren't discussed in detail.

• SQL Scripts
  Cloudscape, InstantDB, MySQL, Oracle, PostgreSQL.
• SQL Deployment
  Ditto.
• Directory server setup
  iPlanet, OpenLDAP.
• Application server setup
  BEA Weblogic only.
• Supplemental code listings
  All code also available in completed final form on the associated web-site.

Sounds wordy... It's not. This is a short book, only about 300 pages including appendices and index. (Compare that to something like Roman's classic EJB book ...) Chapter content is only 200 pages. Fully a third of the content of the book is code; this is definitely one for the programmer, those of you who delight in detailed breakdowns of requirements, user stories, schedules, etc will find little or nothing of interest here.

Equally, there is little in the way of explicit (non-coding) high-level design discussion -- all the code is evolved directly from the well-written text. This is not a bad thing at all -- the design seems sensible and straightforward, always a good sign, and mostly presents an admirable example to any young programmers watching.

All this doesn't mean you are reading a listing though. As on any project involving EJBs, there is a lot of more-of-the-same code between beans -- most of this code is concentrated in the appendices, and only the material under discussion is presented. New code is always presented in full, from package declaration to closing brace. This is refreshing and permits you to actually get something working as you read through the text, although you'll need to be prepared to set up app servers, databases etc to get maximum benefit.

Target audience? Experienced Java programmers who have started using the J2EE platform and are fairly comfortable with all the bean types, JMS, JNDI etc. This book states several times that it is not a primer on any one technology, and provides ample references to more detailed texts when appropriate.

This is very much a book for a wannabe J2EE developer who can't quite figure out how to fit the pieces together, or, like me, just has a gap in his/her skillset when it comes, to, say, LDAP.

What's good? Lots of it. Mainly, the best thing is the clear presentation of a LOT of code via a well partitioned example application (which will also be re-used in Vols II and III). The code is of good quality too, and presents several idioms that while obvious now, were unknown to me when I started EJB work... with the usual reworking-over-a-weekend later on. In particular, there are some commonsense pieces of code -- like a nested exception class for those of us still using pre-1.4 (and remember, you're tied to what your app server supports), some simple session and entity bean Adapter classes, simple Value Object classes etc. As I said, nothing earth-shatteringly novel, but it's nice to see a lot of these idioms used together to simplify the code.

Another admirable thing about the book is the handling of the detail. I've read several books which follow the practice of putting in Gotcha! box-outs, and to be honest, few of them are that useful unless you are a novice. I'm been programming for a few years now, and was amazed at the silly difficulties I've had with my first EJB project -- as a result I'm pleased to say that the box-outs indicating problem areas sound like the voice of bitter experience. For example, there is discussion on following the correct style for accessors/mutators under CMP (getId works, getID cheerfully fails), advice on the very fixed order in the deployment descriptor XML, problems with case-sensitive searches in JNDI, etc. Those of you who've worked with, particularly, EJB1.0/1.1, will undoubtedly have groaned as you realised the problem de jour was something simple-but-outside-your-code like those examples.

Admittedly it's not my area really, but I also found the whole treatment of directory servers very clear and useful. For the first time I understood (a) how they work (b) when they complement databases (c) how to use them easily from my code. Again, I admire the level of detail achieved without being confusing -- I don't see many introductory books include things like the default port number for directory servers using SSL (636 - well, I didn't know that!).

What's bad?

Not much. By nature of the book it doesn't go into huge detail on all technologies used -- there were a few areas where I wanted more. In particular I would have liked to have seen more on testing; now that XP is pretty much mainstream, no one can deny that unit testing is vital on production projects. (When I started using EJBs I had to kludge together a nasty version of JUnit which fitted into the sub-optimal build and client-server framework we were using. I've since found that there are better ways to test EJB layers, but I can still only think of one book, by Richard Hightower, which walks you through examples.) Although the build files in the example use Ant, which makes JUnit and other tools very easy to integrate, there is no mention of unit testing. This is a pity.

The only other things that caught my eye were minor -- coding style in particular. The coding style in the book is very straightforward and Sun-standard, but I have to admit that I'd have liked more JavaDoc'ed code. The code on the website is much more fully commented. I understand that printing this means more paper, and thus a thicker and more expensive book, but on some of the custom methods it would have clarified things for me.

In particular, and I'm being picky here, I didn't find that the authors practice on handling nulls and errors fitted with my own -- admittedly I don't so much practice "defensive coding" as "paranoid coding." Most methods were not null safe, and that can be a nightmare to debug in an n-tier system. Also, he took the line of returning null to indicate failure or error. I understand it's a valid design decision -- my experience says to go with more explicit errors in a larger project, and I would have liked a page or two on the choices here.

Another area where I feel there is room for improvement in the presented style is in the use of hard-coded Strings for lookups - for example, in the AccountManager object there are several lookups of the AccountHome, e.g.:

    AccountHome accountHome = (AccountHome)context.lookup(

        "java:conp/env/ejb/AccountHome";  // Whoops, finding this can be tough!

From experience code reviewing EJB based projects, it's going to save a lot of pain looking for typos if this repeated hard-coded String is (a) extracted as a constant so it can only be mistyped in one place and (b) refactored into a lookup method. It's a fairly minor point, but useful to do right from the start on an EJB project and worth pointing out to someone starting their first one. (Mis-typed meta-data like this is a bit of a weakness in the J2EE framework in my opinion - I always feel that I'd save a lot of time if the compiler or some J2EE aware verifier could check over those Strings to see if they match anything else in the build... I've used vendor tools which claimed to do so, but as they didn't even check that methods/lookup names were in the bean source I wasn't sure what was being verified!)

One last thing: I know it's minor, but why the insistence on importing explicitly? I feel it makes maintenance more difficult -- change one LinkedList to an ArrayList and you're off fiddly with minor imports again. I also didn't find this:

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.Topic;
import javax.jms.TopicConnection;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;

as appropriate for a printed book as this:

import javax.jms.*;

It would have been nice to trade those 10 lines wasted for some custom JavaDoc. However, all told there is remarkably little to grumble about in this book -- I couldn't even spot the obligatory editorial mistake. (That really annoyed me.)

Alternate titles?

Can't think of a good one. (Either a sign that this book is one you might want to look at or else so completely specialised as to be of use to only one person in the world, and that person is probably the author. Luckily, I think it's the former in this case.)

It is however worth a trip to the bookstore for companion, as opposed to alternate, titles before reading this - it assumes detailed knowledge of several J2EE areas, but provides suggested (O'Reilly) titles for reference.

Sounds good -- but what do you know anyway?

Time for the disclaimers. Some material in the book I found useful because I lack experience -- in particular, some database and LDAP stuff.

However, 5 years of getting paid to play^H^H^H^Hcode, and a personal reference library of some 120+ books has made it easier to spot the rare decent title! Most of my J2EE books are from my experience of EJBs for the last year or two, so I know what mistakes are easy to make, as I've made 'em. [I'm actually catching up on my reading, and hence reviewing, due to the Great Telecomms Downturn finally affecting me - anyone want a J2EE developer? :-) ] Finally, I paid for this book (which isn't the case for some of my other reviews).

You can purchase Building Java Enterprise Applications, Volume I from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.

(* Bonus mini-review: a useful book, but not easy reading, I found it hard to slog through, but managed my first XLST work in about 10 minutes using it.)

Comments

Re:Why all this talk about Java?

[Angry White Guy]

Only if you made so much money that you have to dump it back into infrastructure without increasing physical assets.

i'm wondering ...

[dlasley]

what's the subtle message in the exclusion of iPlanet, WebSphere, JBoss, etc. with the summary line: "Application server setup - BEA Weblogic only"

no doubt in my mind BEA makes a helluva product, but i'm surprised the king of the open source publications doesn't have an entire section devoted to Building Enterprise Java Applications with _______ (insert your favorite jakarta packages here)

I prefer that style of import statement

[infinii]

For the person who is learning, it's beneficial to see exactly which package a particular class belongs to. Obviously in this code example it didn't matter but if you were dealing with 4 different packages all added using a *, then one might be hard pressed to find a class.

Considering it's a book on Java, being specific suits it's audience. The author isn't worried about code maintenance issues here.

Re:I prefer that style of import statement

[cpfeifer]

For the person who is learning, it's beneficial to see exactly which package a particular class belongs to.

I agree completely, but in a printed book paper costs money. An entire page of imports in a code sample doesn't help the reader at all and simply wastes trees.

I'm def in the "start importer" camp. The only time you really need to explicitly import individual classes is to resolve a class name conflict (e.g. org.cpfeifer.ListItertor and java.util.ListIterator).

In the past I have used individual imports if I was using an external library and wanted to make the dependancies explicit. But in 1.4 they through in the kitchen sink (60% more classes than 1.3), so it's not as big of deal as it used to be. And I'm lazy.

Re:I prefer that style of import statement

[frodo from middle ea]

The only time you really need to explicitly import individual classes is to resolve a class name conflict (e.g. org.cpfeifer.ListItertor and java.util.ListIterator).
Nope , you still don't need to import classes individually. but you must specify the full class name where u use one.e.g.
import org.cpfeifer.*;
import java.util.*;
and then
org.cpfrifer.ListInerator iter1 = new org.cpfeifer.ListIterator();
java.util.ListIterator iter2 = new java.util.ListIterator();
Or it you are using a returned value, just typecast it to the fully qualified class name

Re:I prefer that style of import statement

[smagoun]

The fact that 1.4 is 60% bigger than 1.3 is a reason *to* use individual imports, not a reason not to. That's what, 1000 new classes to keep track of? How do I know that the Document in your file is an XML document + not a swing text one? It's a lot easier to grep for "Document" and have it pop up in the import statement then have to play guessing games about which classes are in which packages. (Yes, I know that you'd have to be explicit if you have 2 classes with the same name in different packages. That's not my point).

Individual imports are a real pain in the butt to code. They're a huge help for the next guy, though. Maintenance programmers usually don't know the modules they're working on well. This means they're not sure whether your JPanel is really a javax.swing.JPanel, or the custom com.foo.JPanel that's buried in an inner class 3000 lines into your file. They're often not familiar with APIs, either (senior guys usually write new code, they don't maintain it).

I agree that for a book maybe individual imports aren't the best idea, but in the Real World they're incredibly useful. Remember, it's not for you - it's for the other guy.

Re:Wha?

[mborland]

I thought this whole "New Economy" was dead & buried.

A lot of people seem to equate EJB/J2EE with dot-bombs. I think that's unfortunate, because it can be a really useful framework for development. Certainly there are times when people have overapplied EJB (used it where they shouldn't have) and there are also organizations whose projects get mired when trying to work in such a framework (but they are usually mired because they're sprawling projects, not because of the framework).

I tend to use 'slimmer' solutions than a full-blown framework like EJB (yes, I like 2- and 2.5-tier applications). ;-) But I would like to caution those who strike out at Java/EJB/J2EE as though it's just marketing speak. It ain't all a crock, and like anything that achieves some popularity it will attract idiots who will give others a bad impression.

Book Code != Professional Code

[ChimChim]

When I was growing up, and wanted to learn how to program, I did it mainly through books I could buy each month at the local bookstore. So it took me awhile to figure out why real code didn't look like it did in books. Here's my answer to soem fo the author's complaints:

Another area where I feel there is room for improvement in the presented style is in the use of hard-coded Strings for lookups - for example, in the AccountManager object there are several lookups of the AccountHome, e.g.: AccountHome accountHome = (AccountHome)context.lookup( "java:conp/env/ejb/AccountHome"; // Whoops, finding this can be tough!

Yeah, but reading it is easier, especially if you're skimming through or haven't read a particular chapter where they introduce all their constants. Obviously, good practice differs.

One last thing: I know it's minor, but why the insistence on importing explicitly?

So that readers can see the exact dependencies of the class you're writing. In fact, I often write imports explicitly in production code as a form of documentation, but usually not for packages like java.io or packages where nearly every class is needed.

I didn't find that the authors practice on handling nulls and errors fitted with my own

Handling nulls is crucial, but it also clutters the example and makes it longer (somewhat). I would look at it (if they'd included it) and known they were being defensive, but I could see another reader possibly mistaking it for a special case? But i assume page length was [probably the main reason.

Books can strive to give you as much code as possible, but really, you shouldn't use it (and many books have such disclaimers). You're not buying code, you're buying the ideas behind it, so code should be explanatory and descriptive rather than production ready. Some books come with utility libraries or include code from popular, well-used libraries, but even then never cut and paste book code into a production project!

Re:java?

[joib]

people still use java?

http://www.biker-needs-a-harley.org


Bikers still want harleys? sheesh...

Re:Wha?

[oops]

Since when was 'J2EE' marketdroid speak? J2EE specifies a set of APIs that Java serverside people can all speak (or at least they're familiar with a subset of these). If I'm talking J2EE, then I know I'm talking about the servlet API, the JNDI API etc.

Furthermore if you talking about J2EE 1.3 vs. J2EE 1.2, I then know about the capabilities of those sub-APIs, and the containers.

excelent book

[ragnar]

I've read the book and eagerly await volumes 2 and 3. It is one of few comprehensive approaches at building serious software. If you learn by example, this is a good book for you.

Trashed on Amazon

[tkrotchko]

I usually pay attention to their reviews, particularly when you can get at least 3 people responding.

http://www.amazon.com/exec/obidos/tg/detail/-/05 96 001231/qid=1033485007/sr=1-1/ref=sr_1_1/103-198980 7-1175041?v=glance

Not a great review; the primary complain is too many mistakes and typos.

Re:Trashed on Amazon

[tmark]

I wonder...what's the point of book reviews on /., when you know that almost every reader will turn from the /. review to Amazon to read a larger body of opinions - and with no vested interest in boosting the book, to boot ?

Re:Trashed on Amazon

[SirSlud]

I'm not one to bite the hand that feeds me, but I agree. /. is many things, but a source of useful reviews, it is not. I'm not sure why they continue to publish book reviews .. I mean, I'm more interested in the Jon Katz articles.

okay, I have to go take a shower now.

Re:Trashed on Amazon

[dylan_-]

Well, it wasn't trashed on Amazon. The last three reviews were bad, but if you look at all nine, they were mostly good. Average rating, 3.5 stars.

The mistakes in the text were certainly the most noted point.

Wrong Enterprise

[Maran]

"Building Java Enterprise Applications"

Enterprise uses Java for it's computer systems? No wonder it can't go faster than warp 5...

On the other hand, it does make their system portable to other races' ships.

AM

Re:Wha?

[ashultz]

I like two tier applications too... it seems that often people put in a middle tier just to have 3. You can often combine the logic and the webserver on the same box (running Apache + a JSP engine, for example). Unless you've got weird load issues, forcing another level of boxen isn't useful, and slows things down.

But then it's not "3 tier" and therefore must not be scalable. Or something.

Re:Wha?

[FortKnox]

Do my a favor. Go do a search on your favorite job-market search engine for J2EE jobs.

You'll find more than most any other language.

Java != dot-com

Companies (not dot-coms, but companies like insurance and non-web based) still make websites (internal and external). Java is the answer for enterprise size sites.

Safari?

[MSBob]

Is this book, or will this book, be available through the Safari subscription programme? I'm considering subscribing and this book would certainly be a candidate subscription for me. Anyone from O'Reilly care to answer?

Re:Everyone should remeber that...

[BitwizeGHC]

Seeing as how God wrote in LISP code, that is hardly surprising.

Re:Wha?

[mborland]

I like two tier applications too... it seems that often people put in a middle tier just to have 3.

My feelings as well. Unless you're actually going to use the middle-tier as such, it's probably not worth it. Usually I try to use functions/stored procs as a pseudo-middle-tier. This helps with basic DB security (by removing direct access to tables) and also helps enumerate and optimize queries/actions, for ease of development and faster responses, respectively.

I used to get into battles over 2- vs. n-tier solutions (for simple apps) but now it seems that the battle has quieted, as people are more versed with the pros and cons of either approach.

Re:Wha?

[kisrael]

But then it's not "3 tier" and therefore must not be scalable. Or something.

Yeah...stuff like medium-heavy use of EJBs, esp. Entity Beans, lets you scale...and makes sure you need to.

Seriously, I think so many EJB projects are way over-engineered anyway. I've been on a project that went down this path. Then they gave the bulk of it to a buch of Indian consultants who took a much more conservative J2EE approach. Jury's still out, but I'm putting my money on the simpler approach.

I'm a Safari subscriber, I'm reading it now.

[SuperKendall]

It looked like a great book and I had some free slots left, so I just added it to my bookshelf - very good so far.

This sort of book is exactly why I subscribed to Safari. It's very handy but I'm not sure I want a physical copy, I can read through the whole thing to decide that.

One warning though, I think the book was three points!! Safari subscriptions work by using a fixed set of points to put books on your "bookshelf", which then must sit there for about a month before you can replace it with another book. Very fair and ten points are $14.95 a month, most books are only one point.

BTW, you should be able to see for yourself what books are on Safari, it lets you browse and see excerpts I beieve. It's only when you try to read a book that you need the subscription.

A side note, I'm also evaluating the online book site "books24x7" for work and I like Safari quite a bit more,both in terms of site usability and quality of books.

Brett McLaughlin/Java & XML

[Martin S.]

Brett McLaughlin is the author of another O'Reilly title, Java & XML ...

I have to say this is not a good exultation for this book.

Brett McLaughlin Java & XML* book is the weakest book in the O'Reilly stable by a considerable margin. It has a very babbled writing style and lacks clarity, it is poorly structured/organised and very disjointed, being neither reference or tutorial. I suspect that he learnt XML as he wrote the book. The Index is useless, the topics show little natural progression and many XML related topics lack proper explaination.

he can communicate well.

I have to strongly differ.

Re:Brett McLaughlin/Java & XML

[Martin S.]

I think you haven't read the MySQL/mSQL book from O'Reilly then.

You're right. I initially had the word Java, between O'Reilly and stable, but edited it out.

I have most of the O'Reilly Java books, which are excellent, some of the best books I have, and the Brett McLaughlin Java & XML book is not close to being in the same league as any of the rest.

I know Brett

[MarkWatson]

Brett and his partner hired me to add SOAP and UDDI support to a commercial app server. He is extremely knowledgeable, and was great to work with.

I have not read the book in question, but I did find another poster's comment amusing about basing the book on Weblogic instead of open source - grin .

Almost all of my Java consulting involves small or medium scale deployments, so open source solutions like Tomcat/JSP or Tomcat/JBoss/JSP (if transactions required) is all I really need.

re: posts on why use Java at all:

There is also great support for doing web services in Smalltalk, Python, etc. (i.e., support for light weight HTTP service, SOAP, etc.). That said, Java with great tools (like Tomcat, JSP, etc.) is a great platform. Really, language is not so critical, but good design is.

-Mark

import statements

[dobratzp]

Explicit import statements are generally preferred for a number of reasons. Consider the following:

import java.io.*;
import java.util.*;
import java.sql.*;
import javas.jms.*;

If you see a reference in the code to Session, you will either

1. know exactly that they are referring to javax.jms.Session and either know its API or be able to look it up in the docs. In this case, you don't care about the import statements.
2. or have never heard of Session, and decide to look up its documentation. If you see at the top of the file import javax.jms.Session, then you know exactly where to look. If you just have a bunch of wildcard import statements, you have to check through potentially all the packages for java.util.Session, java.sql.Session, etc.

Also, when someone reads your code, they can browse the imports to check for specific classes you use that they are unfamiliar with. No one is going to read the entire documentation for all the packages you may have used if they only need to understand a few classes.

The gripes about typing are somewhat unfounded. Any reasonable java-aware editor will be able to automatically manage you import statements.

Remember: "Any fool can write code that a computer can understand. Good programmers write code that humans can understand." (Martin Fowler)

Fundamental flaw of most J2EE apps

[smagoun]

Most J2EE apps are terribly flawed from a maintenance and flexibility standpoint.

Why? There's a fundamental issue at stake that Sun has partially solved, but not completely: What your application does should have nothing to do with how it does it.

For example, take the "bank account" app that I've seen used as a tutorial in many places. Customers can have one or more accounts, and they can perform operations on those accounts (deposit, withdraw, transfer). The code necessary for those operations is trivial. It's the support code that makes writing enterprise apps so difficult. At the minimum, you need:

• A database schema
• Code to read/write the DB in a transaction-safe manner
• Presentation code (webapp, could be something else)

You'll probably want to expose a few other interfaces, like an API for your app to be used on a message bus so other apps can access it.

It sucks to have to write all of that extra code. It gets even worse if you have to modify your app (add/delete fields, features, etc). Sun is slowly chipping away pieces of the problem (EJB sort-of makes persistence easy, unless you need stored procs, etc), but they haven't solved one of the big the underlying issues:

The application has data that can exist in multiple representations. Each representation requires work to make sure it's always in sync with the rest of the representations.

There's an easy way out - define your data, and let the computer generate the different representations for you. While you're at it, have the computer write the code that can convert data in one format to another format. This is obvious for things like going from one XML format to another, but not so obvious when trying to convert a web form into a java object, or a java object into a database record.

By defining your data and using code generators or other automation techniques (reflection) to create those different representations, you can slash maintenance costs, time to add new features, etc. Want to add a new field to an object? Update the canonical representation of the object, and presto, your entire app supports it, from the web UI down to the DB schema. Want to add a new data format? Write a generator for it, and all of your objects automatically support that new format.

The overhead is higher at first, but it pays off incredibly quickly. On my last project we saved many many man-years by doing this. Check out thesandbossproject for an LGPL set of tools to help out with this, based on the SAND architecture.

(Yes, I've glossed over about a zillion issues. It's not that I havent thought of them, it's that the problems are solvable. The main point is that your data representations should always be in sync with each other, without your lifting a finger. And no, UML doesn't quite get you there yet).

Re:Fundamental flaw of most J2EE apps

[Tablizer]

The application has data that can exist in multiple representations. Each representation requires work to make sure it's always in sync with the rest of the representations.

I find this a flaw of many OOP methodologies in general. They end up mirroring the "noun model" in programming code. This not only ends up duplicating the relational schema, requiring synching up upon change, but bloats up the code to high heaven.

Relational thinking and OOP are at odds on many things and the industry has not settled this. Heavy OO fans would prefer OODBMS's, but the market has pretty much pissed on them (beyond small niches). Thus, they try to force OO and relational together, and they make lousy bed buddies, fighting over terrority and design approaches. The approach that Sun appears to have taken is to *duplicate* the same or similar info in both the relational DB and the programming code, making the kinds of messes you talk about.

I prefer to store UI field info in tables (AKA "data dictionary" or "field dictionary".) These tables then generate the UI's as needed. You simply fill in the needed cells instead of setting a boatload of code attributes (set/gets). A good table browser makes such a table far easier to view, navigate, and filter for your needs than programming code. Code is a horrible place to manage wods and wods of attributes IMO. Perhaps your head is different, but code just sucks eggs IMO for such for the way my head works.

By defining your data and using code generators or other automation techniques

IMO, code generators are evil. You are going from a compact representation of attributes to a less compact representation (code). IOW, bad information factoring. It is like entering and management spreadsheet data via XML instead of a grid.

I cannot believe the market-place tolerates such shit. It must be job security or contractor security. I don't get it.

Sample data dictionaries:

http://geocities.com/tablizer/ddsamp.htm

More about data-centric philosophies:

http://geocities.com/tablizer/whypr.htm

Re:Fundamental flaw of most J2EE apps

[JohnnyCannuk]

Foxpro music seqwuencer? Xbase apreciation? God, no wonder you don't like Java...you don't like OOP.

Well fine, don't use it. For those of use who have done both and believe OOP is superior we will read this book and use these hints to create great software...you may continue living in the 80's

Re:Fundamental flaw of most J2EE apps

[smagoun]

I prefer to store UI field info in tables (AKA "data dictionary" or "field dictionary".) These tables then generate the UI's as needed.

IMO, code generators are evil. You are going from a compact representation of attributes to a less compact representation (code). IOW, bad information factoring. It is like entering and management spreadsheet data via XML instead of a grid.

Um. So is it good or bad to generate stuff? You can't have it both ways. Your compiler is a code generator, like it or not. You go from a compact representation of information (C, Java, whatever) to a less-compact version (asm/0s and 1s) that the computer can understand.

Furthermore, the compact representation of the information that's provided as input to the generator is the goal! It sounds like we agree - compact good, big piles of code bad. The code generator lets you make one tidy little file - your data definition - that the generator then blows out into the various APIs that other components need. You still have the piles of code, but you don't have to think/worry about them, because they're always there and they always "just work.".

Sure, it would be nice if we didn't need to generate any code and we could just operate on the data itself, but there are real-world considerations that make that difficult. RDBMSes talk SQL, browsers talk HTML, and there's a bunch of stuff in between. You still have to get from the UI to the DB, and you can either write that code yourself, or have the computer do it for you. By defining the data and then transforming the data definition (via code generation or other method), you can have your cake and eat it.

(And yes, I hate getters/setters too, but they're only about 1% of the stuff you can actually generate)

Re:Fundamental flaw of most J2EE apps

[Fnkmaster]

You make some good points - smagoun's methodology is a solution to a problem that doesn't have to exist, but in practice, it does exist in most companies and enterprise software being built today.

Also, your solution isn't quite well fleshed out enough for me to buy into whole hog. A pure meta-data model (sorry, I know that's not precise terminology, but I think I am using it in the same way you are using the term data dictionary) is well suited to data that you only need to take from a form field, stick into a particular DB table and field, and retrieve and display later.

If your application needs any particular logic to be based off of some fields, metadata models fail - you need semantic knowledge of field's meaning and associations in the application code.

Unfortunately, many enterprise applications have a lot of data they just need to shuffle around and pass along to somebody else farther downstream, and a lot of data they actually need for application manipulation. In my experience, if you try to handle complex data types with a data dictionary-style mechanism, your dictionary ends up with so many damned parameters it becomes unmanageable. If the data is handled in code, you will just have more code for complex data, and less code for passthrough or simple data.

Also, I should point out that in general, code generators keep data in MORE COMPACT form, not less compact - I believe that smagoun is referring to a build system that uses generated source code files as intermediates in the build process, not as verbose files that are to be edited manually. The advantage this provides is that you can get compiled code performance out of data manipulations that would otherwise require semi-interpreted performance if they actions are all determined at runtime (example - autogenerated externalization methods in Java vs. default object serialization - huge performance difference in performance critical apps).

Re:Fundamental flaw of most J2EE apps

[smagoun]

IOW, the generated code is not used by humans. If so, then why use Java as the info transfer mechanism? (This question is raised in a nearby reply.)

I'll answer the other reply here, too.

The generated code IS used by humans. Perhaps more importantly, the generated code is used by other systems that speak a certain format, like SQL.

For example, start with a simple chunk of data: a "user." It has a username and a password. Your data definition might look like this:

user {
String username
String password
}

That's about as concise as I can get without losing human readability (which is a requirement for the data definition). Now, you probably want to manipulate that data at some point. Say you want to manipulate it in Java, because you're stuck with a shop full of Java engineers. You need a java class file:

public class user {
private String username;
public getUsername() {return username;}
public setUsername(String u) {username=u;}
[...]
}

You also want to store that data in an RDBMS from Java. Assume you want to do it simplistically, no EJB or anything:

public class UserPersister {
public storeUser(User u) {
connection c = getDBConnection();
c.execute("insert into user username=" + u.getuserName() + ", password=" + u.getPassword());
}
}

Of course, your object isn't much good unless you can display on a screen somewhere (say as part of a webapp). You need a servlet or a JSP or something (I don't care what) to display that object:

<html>
<body>
username="${user.getUsername()}"<br>
password="${user.getPassword()}"<br>
</body>
</html>

Writing all of that stuff by hand sucks. So I make the computer do it for me, based on my data definition. I never have to touch the generated code (in fact, it's not allowed). That doesn't mean it's useless, though - the generated stuff still does things, and it gives other programmers familiar and always-up-to-date tools to work with.

It sounds like your approach is to make tools that understand the data definition directly, which is a valid approach. They're just two different solutions to the same problem. I like code generators because they spit out stuff that other people can work with without any understanding of the data definition, or how to use/abuse it. As you said, the tools just aren't there for table-driven code right now. And what happens when you have to switch DBs/storage paradigms?

Re:Fundamental flaw of most J2EE apps

[JohnnyCannuk]

Ooooo.....

Well I quite aware of databases, etc. and I was a darn fine procedural programmer. And I've have NEVER run into any of the so-called tree - hand indexing problems of which you "speak".

I have been using OO for about 5 years now, making some pretty sucessful business applications.

Now, what exactly does OO design of software have to do with the database, or any other datastore, anyway? Storage and management of data is completely separate from the design and operation of the software (ever heard of Model View Controller?).

Perhaps you dislike OO so much because you don't really understand it.

Whatever, we're not going to convice each other of anything here.....

Re:Somewhat OT, ignorant question

[abigor]

Ease-of-management also comes into it. Migrating servers is a lot easier when you don't have to worry about recompilation; just copy over some .class files. That's the advantage of the virtual machine: no worries about weird big-endian/little-endian bugs, 32 bit vs. 64 bit, etc. Couple that with the fact that Java is the most mature JVM environment with great tools and APIs, and you can see why it's widely used.

I won't deny .Net will become a contender. But Java also benefits from competition in the app server space. Bea vs. IBM vs. iPlanet and so forth means higher performance and more features. Where is the competition for .Net's app server environment? In the MS Transaction Server/COM+ days, it was all just MS - no choices. Will the same be true for .Net? I think so, and that scares a lot of people.

Finally, Java runs well on *nix, and *nix is THE choice for big, serious sites. Sun makes Solaris, and Sun makes Java; that's all that needs to be said about that.

Re:Somewhat OT, ignorant question

[abigor]

"Bosh! Many interpreters don't have such problems."

I wasn't speaking only about Java. In general, interpreted code is nice to have on servers.

"IMO, Java is hypeware and bloatware and PHB-friendly mediocrity at work."

It's pretty enduring for hypeware, don't you think? Anyway, aren't you the guy with the huge problem with object-oriented anything? Maybe a bit of bias showing through here?

Re:Wha?

[FatherOfONe]

Wow what you said sounds great! No more SQL. CMP Entity beans handles all my SQL issues...

Oh wait. I have to learn ANOTHER language. It is like SQL but yet not the same. Oh and I CAN'T have but simple relationships between tables that map to ONE bean! I want 10 or so tables to map to a "customer" bean.

Oh well I guess that I will just manage the persistance myself... OH MY GOD! trying to manage all the lifecycle stuff is a pain and weird stuff happens if you don't design it correct, and you try and scale it....

Give most of us SQL any day of the week. It is a pain, but at least you know it will work, and your data guys can help tune it. Also you don't have to worry about a lazy coder using instance variables and not cleaning them up with a bean managed persistant bean.

I don't want to claim to be some EJB hater or EJB God, but I do know that for 99% of the people out there a good JSP/Servlet engine is all they need.

I will say that if you want to get over 100 transactions a second (normal transactions 30 inserts/updates and 70 selects) EJB's appear to be the only way to get Java to scale.

They are by no means a silver bullet. The learning curve is steep, and they are difficult to test well.

Imports only exist in the source code

[greenrd]

You may have more "Class not found" errors up front, but it makes it much easier to track down missing .jar files when you go to install, since the runtime knows the full name of the class you're trying to find.

Uh, imports don't exist at the runtime level (unless, I suppose, you're using some special runtime tool that scans all the source files for import statements). All class references are made fully-qualified in the generated .class files.

Any more than one and there's a potential for name conflicts.

Exactly - this is the real reason why imports should usually be explicit.

Re:Somewhat OT, ignorant question

[abigor]

Cobol wasn't hypeware, either, so I don't get your point here. Cobol did its job well for many years, and now it's legacy code, mainly. It followed a natural lifecycle. Java will too. In the here and now, Java does a good job.

Python is nice. But Java is way more than just the language. Its got containment and infrastructure in the form of app servers, a vast number of APIs, a huge community, and a ton of third party support. From a pure language perspective, maybe Python is better, who knows. But really, it's design and infrastructure that count; languages are very often not as important.

By the way, what "multiple paradigms" (this from the guy that hates buzzwords and PHB speak) does Python support?

Another Review .... Of the Book

[pgrote]

Book Review of Building Java Enterprise Applications Vol. 1 Architecture

"Before you dive into the coding, read this book to summarize and organize your overall design and implementation. It will be well worth your time. I'm looking forward to seeing the rest of the volumes in this series."

Re:Somewhat OT, ignorant question

[Tablizer]

Java does well on the server simply because it is the best tool for that job. End of story. It is also much easier to maintain and upgrade than garbled PERL or old C hacks.

Some choice we have here: Java OR C OR Perl. Whatta diverse world. That it?

You know, personally I also think that Perl sucks. But Perl programmers seem to do wonderful things with it and can often even read and maintain other perler's code.

As long as they are productive, I have no place to bash Perl just because it ain't my bag. (Oh, I'll still complain though :-)

I think programming and paradigms is probably subjective. If you want productivity, then give people tools that best fit their head. Surveys by Ed Yourden tend to confirm this (although it is highly preliminary).

If you can show that Java and/or OOP are *objectively* better, then I would just loooove to see the actual evidence. Until then, please don't dictate to me what works best for me. Give me tools that fit my head well, and I can crank sh_t out faster than a vast majority of Java fans (and have it be more maintainable and simpler).

Probably the same with Perl fans. Paul Graham beat a lot of projects using LISP, a language created in the 1950's, and is now wealthy because of it, if you want an actual example of tool-fit-based productivity.

Re:Somewhat OT, ignorant question

[abigor]

Sure, Cobol succeeded in its claim. Java is succeeding, too. They are both successful workhorse languages that get the job done. The "hype" you claim is so vile - write once, run anywhere, and so forth - may have been made before. But it's still nice to have; these are virtues. Java (the platform) does not deserve your scorn, as it is an excellent server-side solution.

Regarding containment: have you ever worked with J2EE? Object containment, like EJB servers. Or in MS world, MTS/COM+.

My comment about the lesser importance of specific languages is simply this: design is what counts. Bad design = bad implementation; no language can save you. Many people like to work with objects; J2EE is an object-oriented, heavy duty framework. Its attendant language is Java.

So by "multiple paradigms" (argh) you mean Python allows you to break object orientation. That's not an advantage for me, but maybe for you it is. I wouldn't want to be the one who documents that sort of code.

Re:Somewhat OT, ignorant question

[j3110]

There really aren't many good arguements for Java on the server-side. Of them, the best seems to be abstraction. The JDBC drivers are required to support ANSI SQL (different versions for different levels of drivers). Also consider that at some point soon, a lot of people are going to have to port their projects to take advantage of the new 64 bit processors and for the Itanium. To you it may be as simple as "a simple recompile" but we both know it's not that easy when you are using third party libraries and components. Half the world can be brought to a halt because one component vendor isn't on the ball in the Delphi/C world.

The real strong arguements for Java on the server side though come from the wealth of code and architecture available for free. J2EE is a great technology. C# doesn't support clustering, distributed transactions, nor the object persistence that J2EE supports. Do you fully understand how much effort it would take for you to write a security system and distributed transactions for your entire enterprise? How about optimization of this system? J2EE halves the time to market if you need these features. J2EE is often much faster than raw database access because it optimizes your accesses by cacheing as much data as it can. How long would it take you to write a clustering solution for your application? In an enterprise situation, if you can't scale, then you're not going to fly. Ebay doesn't run on one computer, and it doesn't make mistakes when two people bid almost simultaneously. Writing C code for distributed transactions, security, and clustering would take longer than writting the code to make EBay work on one system. J2EE may increase the amount of time it takes to make EBay work on one system, but if it works on one, with J2EE it will be fine on as many as you want.

Re:Somewhat OT, ignorant question

[j3110]

Some database engines and database connectivity software is written in java. Also mathmatical software will benifit from the extra precision. Then again, the new 64bit systems arent't really just bringing an extra 32 bits to the table. They are bringing twice or greater number of registers. The benifits of this architecture will be experienced instantaneously by those that use them.

An old Java library will still work in new java implementations. You don't have to wait for the JDBC drivers to be updated for itanium, PPC, etc. support. In C/C++/Delphi (not C# or .Net with the CLR), you just can't do that.

*COM* is a cludge that requires more code to do the same task. If COM was worth a it's bits, .Net wouldn't exist. .Net doesn't have a persistance engine that doesn't require you to save the data through the same proprietary SQL statements. When you buy into .Net, you've made your mind on exactly what kind of system your software will run on. When MS increases the tax, you'll have to eat the losses, or redevelop on a different platform.

As for ebays faults, it just goes to show you how much debugging you can save by using J2EE as well. You don't have to worry about any of those problems with J2EE.

I don't think you'll be finding a system that does as much as J2EE that is easier to use.