Steve Barber's Java, OO & CORBA Book List

Circa February 2000

Java Books

Good first books on Java

• Cornell & Horstman, Core Java 2, Volumes 1 and 2, 4th Edition, SunSoft Press/Prentice-Hall, 1998

Excellent tutorial, geared to learning the whole JDK and libraries. This is THE book to read if you have a good C or C++ programming background and want a thorough tutorial. Don't waste time with imitations or thinner volumes -- these have it all and you don't have to read it all at one go, either. Unlike most huge computer books, the Core Java series is consistently well-written and insightful throughout, without a hint of the shovelware mentality that plague most efforts of this size.
 
• Arnold & Gosling, The Java Programming Language, 2nd Edition, Addison-Wesley, 1998

The "K&R" of Java. This book is about Java as a language, and totally ignores applet and GUI programming, as it should. However, at the moment, it is *the* authoritative source for information about the Java language. Even though this is the first book I would read if I were learning Java today, that does mean this is the best way for every one to learn the language -- you really have to like computer languages as a topic to like reading this book.

Don't forget to check out the JDK 1.2 Appendix.
 

• Flanagan, Java in a Nutshell, 3rd edition, O'Reilly & Associates, 1999

This is not a book to learn Java from, but it's perfect to keep by your monitor while programming. Concise summaries and examples, lots of useful tables. It's worth its price in convenience alone.

First Java books for people with no programming background

• Heller, Who's Afraid of Java?, AP Professional, 1997

Here's one I can recommend to new programmers. Steve Heller breaks down the concepts and introduces the reader to programming, objects and Java in a very readable way. He uses the device of teaching through an e-mail conversation with a student. Full disclosure: Steve & I worked together many years ago, and was one of the people who introduced me to many of the fundamentals of good software design. But that doesn't mean this isn't a good book. I can quibble with the choice of Microsoft Visual J++ as the environment of choice here, because Heller introduces some very Microsoftish conventions that don't translate well to the 100% Pure Java camp. [Note: as of January 2000, Steve Heller says this book is unfortunately out of print.]
 
• Deitel & Deitel, How to Program Java, 3rd Edition, Prentice-Hall, 1999

This book has the heft and style of a college textbook, but is one of the very few books that teaches Java as a first programming language. It is comprehensive, and friendly despite its ambitions for the academic market. The Deitels are master teachers, by the way. If you ever have a chance to take one of their live courses, don't shy away.
 
• Winston & Narasimhan, On to Java, 2nd Edition, Addison Wesley, 1998

If you like the style of the "On to . . ." series, this is a book from which to learn Java from scratch. I, however, never found the "On to . . ." style a good way to learn anything, let alone programming.

THE Second Book on Java

• Coad & Mayfield, Java Design: Building Better Apps & Applications, 2nd Edition, Prentice-Hall, 1998


Written by one of the object methodology gurus, this book "gets it" in terms of leading the reader through how to use Java's language features to make more flexible and manageable system designs. The central theme is that the Java language is an excellent tool for the direct concrete expression of object-oriented designs. Many of the concepts will not be new to seasoned OO hands, but their application to Java is presented clearly here. Coad & Mayfield strive mightily to promote the use of interfaces and delegation/composition as fundamental design elements, and to dispel the notion, dear to many C++ programmers, that inheritance is a thing to be used very frequently. Coad & Mayfield also lead us through the proper use of notification (Observer/Observable) as a GUI construction paradigm, and there is some not quite so well-developed work on designing with threads. This book presents its examples using Coad's own notation, and also UML.

I've only seen two other reviews of this book, and both were unfavorable. One reviewer didn't like that the book mostly recycled material from Coad's other books, which if you haven't ever read them, is irrelevant. Further, Coad's other books are much longer and dryer, and here the approach is "compiled down" and focused on the application of OO design principles directly in Java. The other reviewer thought the material was too dry to even read, which I don't understand at all. OO methodologists as a group are pretty abstruse writers; Coad & Mayfield make the topic seem almost fun in comparison to some of the "classic" OO books I recommend below. As books on OO design go, this one is very accessible. In fact, it's just the thing to hand to someone who "doesn't have time" to learn OO design.

Deeper Stuff

• The Java Language Specification, Addison Wesley, 1996

I don't see how anyone could consider themselves a serious Java programmer and not have a copy of this work. Like most specifications, you wouldn't want to sit down and actually read it for fun, but it will answer questions about the language that simply aren't answered anywhere else. For example, did you know that Java's execution semantics anticipate a multi-processor model and specifies how thread states and data shared between threads synchronize themselves across separate address spaces? Nothing in most of the other books out there even hint at this, and no existing commercial implementations deal with this, yet this has implications for Java design and portability that no one has even explored.

• Tim Lindholm and Frank Yellin, The Java Virtual Machine Specification, 2nd Edition, Addison Wesley, 1999

While one might think that understanding the Java Virtual Machine itself is a pretty specialized topic, it's surprising how much is in here that the average Java programmer will need to know at one time or another. In particular, thread scheduling semantics are presented at a level of detail rarely discussed elsewhere, and, again, these details have pretty far-reaching implications for the design of portable systems.
 
• Doug Lea, Concurrent Programming in Java: Design Principles and Patterns, 2nd Edition, Addison-Wesley, 2000

This book is a comprehensive guide to thread programming in Java. It takes up where most other Java books leave off. Maybe this is overkill for most Java programmers, but Lea has really done a nice job at examining how to put together sane multi-threaded systems in the Java environment. It may even be the best book ever written on concurrent programming, period. This should probably be your third or fourth Java book.
 
• George Reese, Database Programming with JDBC and Java, O'Reilly, 1997

Forget all those 1000+ page JDBC books out there; this stuff just isn't all that hard. You initialize a connection, fire off a SQL statement, and you get back: a table full of data. The problem is: then what do you do with it? Relational tables and OO don't get along so well. Reese does a fine job of teaching you everything you'll ever need to know about JDBC and SQL as a Java application developer, but then he goes after the big fish: object/relational mapping problems in Java, the great unsolved problem for Java application developers.

Object-Oriented Theory, Design and Methodology

I don't claim to have covered this whole field; I am still kind of bumbling through it and am pretty unhappy with the material that's out there -- much of it is fragmentary, theoretical, dense and barely supported or field-tested. Even worse for the working developer, much of it requires serious mental effort to extract the good stuff and apply to real projects. Much OO writing seems designed to keep people in the dark; I can only assume from this that no one really understands how all the various topics in this field tie together yet, and certainly no one understands yet how to teach these concepts really well.

I've got two categories of books mixed together here: "Important" OO books, and books that have actually helped me. See if you can figure out which ones are which. I have included some important books here because even though they didn't help me work, they seem to be highly influential and I suspect that different people benefit from very different approaches to this material.

Good intro:

• Dave Taylor, "Object-Oriented Technology: A Manager's Guide," 2nd Edition, Addison-Wesley, 1998. Don't have to be a manager to read it!

Bertrand Meyer, Object-oriented Software Construction, 2nd Edition, Prentice-Hall 1997

This book is pretty unique in that it attempts to cover the whole software development lifecycle, especially implementation, in a well-integrated way. Meyer is the name primarily associated with a very useful technique called "Design By Contract" that many other OO gurus integrate into their own methodologies. What makes this book a little weird is that Meyer's notation and framework turns out to be Eiffel, a reasonably obscure OO language. So while learning to think in Eiffel is a bit sidetracking to those of us trying to build Java and CORBA systems, Meyer's approach is so comprehensive and well-presented that OO heads everywhere ought to have it within easy reach.

The thing to remember about methodologies is that they are not silver bullets -- they give only a framework in which to solve problems and do not solve problems on their own. Further, there are lots of competing methodologies, and some are better at some things than others. The reason I'm bothering to say this is that some people tend to learn a methodology and become religiously attached to it, and have trouble seeing its shortcomings, which there always are.

Why bother with methodologies? Because, absent long experience and true genius, following one or the other or some combination is about the only way to really up the odds of success for OO systems design. They also give frameworks for structuring development processes.The tricky part is to figure out when the methodology is helping, and when to ignore it. Unfortunately, this knowledge pretty much only comes with experience.

I am not by any means a guru on this topic, which is surrounded by religious wars, schisms, and beset by numerous approaches with confusing terminology. But these books have helped me understand the issues and become a decent practitioner.

• J. Rumbaugh et al., "Object-Oriented Modeling & Design," Prentice-Hall, 1991
• Grady Booch, "Object Oriented Analysis and Design, with Applications, 2nd Ed.", Benjamin/Cummings, 1994
• Ivar Jacobson, "Object-Oriented Software Engineering: A Use Case Driven Approach," ACM Press/Addison-Wesley, 1992

Heavy slogging; good for use case stuff, but be skeptical about generalizing use cases to the whole design process.

There are lots of books on UML by now. The best introduction is still:

Martin Fowler, UML Distilled, 2nd Edition, Addison-Wesley, 2000

Peter Coad, "Object Models: Strategies, Patterns, and Applications, 2nd Edition," 1997

This book is refreshingly jargon free and focuses on object modelling as the central task in OOA&D. Demystification is a central and very welcome theme. Coad has a methodology in mind, but he doesn't bash you over the head with it. He teaches by example, not by lecturing. By the end of the book you have stepped through the creation of five different, substantial object models and absorbed through osmosis a method of building them that includes both analysis and design. Object models are built using Coad's own very simple notation, and the results are presented in OMT, Coad and UML notations to allow very easy comparison between the notations. Note: this book can get very, very repetitive but stick with it. The repetitions are actually teaching you something and are there for very good reason.

THE Second Book to read on OO:

• Eric Gamma et al. ("Gang of Four"), "Design Patterns", Addison-Wesley, 1995

This book is really a practical catalog of some of the best OO-design elements. At first glance this appears to be a highly theoretical work, but it is actually extremely useful. Familiarity with these patterns will jump-start anyone deep into OO design. This book is the bible of the Design Patterns branch of the OO design movement. The Patterns approach is complementary to any particular OO methodology, but perhaps equally important. These patterns have already become a standard part of the working repetoire in the OO world, and learning the nomenclature presented here will also make efficient communication possible about OO design issues within and between development communities. Once you've absorbed the GoF patterns from the source, go get Mark Grand, Patterns in Java, Volume 1, Wiley & Sons, 1998. This book takes the GoF patterns, re-presents them, adds some more, and then provides fairly detailed examples with sketches of Java implementations. Sure, you could do this on your own, but why spend the time?

OK, I Understand the Theory, Now What?

• Applying Use Cases: A Practical Guide, Schneider & Winters, Addison-Wesley, 1998

One really useful part of the UML is the Use Case. This is a great way to capture requirements during the analysis phase of a project. The Use Case technique provides a fairly systematic way to describe system functions in languages that's precise enough to give to the system designer, but understandable enough to use with the people you're building the system for. Jacobson's books about Use Cases are the originals, but they pretty hard to read. This refreshingly thin book explains use cases, tells how to go about creating them, gives a nice template, and then best of all, presents an extended example that's will give you a great start on creating your own use cases.
 
• Firesmith et al., Documenting a Complete Java Application Using OPEN, Addison-Wesley 1998

You can read OO methodology, process and project management books until you're red in the eyes and blue in the face, but when it comes down to actually figuring out what you need to produce as a result of analysis and design, you've had zero help. Most books have room only for trivial examples. This book presents model development process documents for analysis and design, as well as the resulting code and documentation, for a moderate size (one staff year) project. It's short on telling you what steps to take to get these wondrous results, but these are available from other books. The really nice thing about seeing it all in print is that these documents provide at least one example of an answer to the question, "How do you know when you're done analysis (or design)?"

The one quirk about this book is in the title. The authors use the OPEN process and notations (Donald Firesmith is one of OPEN's developers and advocates). OPEN is Yet Another Object Modelling Notation, and you have to learn it in order to understand the documents in this book. It's not hard to learn, and the authors provide an adequate summary right in the text, but it's annoying to have to suffer through another skirmish in the notation wars. Another minor complaint: while the source code is provided on an accompanying CD-ROM, the real value here is in the analysis and design documents, so it would have been nice to get at least the templates in Microsoft Word format.

A sobering point: while this one staff-year project produced great documents, the code produced is quite small. Not that that's bad of itself, but the functionality supported by the code is quite modest as well. A staff year is not that big, I guess.

Also:

• Bruce F. Webster, "Pitfalls of Object-Oriented Development", M&T Books, 1995

Good to save you several months, if not years, worth of trouble. It's likely that this book is out of print, unfortunately.
• Fowler, Analysis Patterns: Reusable Object Models, Addison-Wesley 1997

Another book from the patterns movement, this book lays out a variety of patterns, some domain specific, for use in building analysis models. This is complementary to the Design Patterns book above. Fowler's survey of object-oriented analysis and design techniques is well worth reading on its own.

Books on using Java with CORBA

• Vogel & Duddy, Java Programming with CORBA, 2d Edition, Wiley, 1998

My favorite book on Java and CORBA programming for the working programmer. Dig in, learn and do. The final chapters focus on real issues encountered in building real systems, such as server management and security that get scant coverage elsewhere. Presents examples for use with Inprise's Visibroker for Java ORB but overall is reasonably vendor-neutral in its approach.
• Orfali & Harkey, Client/Server Programming with Java and CORBA, 2nd Ed., Wiley, 1998

This book has gotten too big and the Orfail/Harkey cutesy-Martian style and preachy approach rankle as always, but it is still a very readable and comprehensive introduction to the topic. Focuses on the Inprise Visibroker for Java ORB, though not exclusively so. Also notable for providing a lot of comparisons of CORBA to other distributed programming models such as RMI and DCOM, though it'd be hard to call the comparisons unbiased. Be a little careful though: Orfali & Harkey, by trying to be up to, or even ahead of, the minute with the latest and greatest specifications and technologies are prone to statements that turn out to be slightly wrong when the dust settles six months out. So this book is best when used to get conceptual overviews of a topic. For the details, it may turn out to be less of a headache in the long run to rely on other authors.
• Lewis, Barber and Siegel, Programming with Java IDL, Wiley, 1997

Something of a sentimental favorite for this author, this book focuses on writing fully OMG IDL to Java Mapping 1.0-compliant CORBA clients and servers.While the implementations are geared towards Sun's Java IDL ORB that finally shipped in Java 2, but any OMG-compliant Java ORB with a CosNaming service implementation can be used with the examples in this book.
• Pedrick, Weedon, Goldberg & Bleifeld, Programming with Visibroker, Wiley, 1998

Actually this focuses only on Visibroker for Java, and provides a thorough tutorial on using lots of Visibroker-specific facilities. Goes beyond the Inprise manuals and Web site, but not far beyond. Still, I found it useful to have around when working on Visibroker projects. I would still recommend Vogel & Duddy over this book for people just learning about CORBA -- first do it the OMG-compliant way, then learn the vendor-specific stuff.
• Iona Technologies, OrbixWeb 3.0 Programmer's Guide, 1997

Iona clearly needs some friends in the publishing industry, because the other available books that cover the popular OrbixWeb product just aren't very good. So I'm recommending that people actually read the manual as the best way to learn the product. This is actually a fairly comprehensive and mostly pretty readable introduction to CORBA and the use of Java with CORBA, but the presentation blends OMG-compliant and Iona-specific features to such a degree that they are difficult to sort out. Without some perspective, the reader will have a hard time figuring which features to use in which circumstances -- for which I again recommend Vogel & Duddy. The text has numerous typographical errors, but fortunately these are pretty easy to spot and the code presented is correct. But, you get the entire book for free as a PDF file when you evaluate the OrbixWeb product! Can't beat that price.

General CORBA

To take your budding CORBA design skills to the next level, Mowbray & Malveau's CORBA Design Patterns, Wiley 1997 can be quite useful, though it is not as profound as its title implies.

Beyond these, your best source of CORBA information is the extensive archives of the OMG available through the OMG Web site at http://www.omg.org, particularly the formal OMG specifications themselves and the Object Management Architecture (OMA) Guide.

In general, however, really good books on designing and architecting systems with CORBA have yet to be written.

I'm also hoping that someday some insider will write a political history of the OMG, because only then will we users be able to figure out why things in the OMG specs are the way they are, and what we can safely ignore as the artifact of some long-forgotten hallway compromise, as opposed to things that may turn out to be crucial hooks in the future evolution of this fascinating technology.