In search of the best Java book for beginners

A comparative review of 7 intro-programming language books

Until, say, 1996, I wouldn't have blamed any teacher still using Pascal as the main teaching prop in an introductory computer science curriculum (often code-named CS 101 or CS1). The obvious alternative (C++) was quite rightly considered by many teachers to be a pedagogical minefield. Today, however, there is no excuse: If you're not using Java to give your students their first taste of programming, then you are leaving the door wide open to be rightfully accused of not giving your students the best possible computer science education.

In the past year, a small minority of teachers found themselves unsatisfied by "just" pushing the teaching envelope in their respective classrooms (that is, by ditching Pascal and the legacy of its generation's procedural programming style, and adopting Java and its modern object-oriented programming style). These pioneering few went a step further by writing teaching texts for complete beginners, betting the whole shop on Java.

This month's book review takes a look at seven books that share the goal of teaching complete non-programmers how to program, and to do so with Java. (Notice that these books are quite distinct from those books designed to teach Java to programmers who've never used Java before. These books are for students who've never programmed with any computer language before.)

The titles reviewed are:

Below is a comparison table to provide you with a bird's-eye view of each title's main characteristics.

Java For StudentsJava GentlyJava -- An Object First ApproachIntroduction to Programming Using Java -- An Object- Oriented Approach

Object-

Oriented Programming in Java

Java How To ProgramComputing Concepts with Java Essentials
Price (U.S.$)8.006.954.007.959.998.007.95
Pages, Chapters (Appendices)586, 29 (8)508, 15 (2)394, 17 (3)783, 14 (4)953, 16 (2)1063, 18 (6)624, 14 (3)
Authors2112221
GlossaryPoorNoYesYesNoNoExcellent
IndexPoorPoorV. PoorYesYesV. GoodYes
CD-ROMNoNoNoNoYesNo *Yes **
Listings density (lines/page)48565348585050
Object-oriented early?NoYesYesYesYesNoNo
Applets(A) or applications(B)?ABBAA&BA&BA&B
Graphics early?YesNoNoNoNoNoYes
Support classes?NoYesNoNoNoNoYes
Keywords highlighted?NoNoYesNoNoNoNo
Suitable for hobbyist?NoNoNoNoYesNoNo
Overall score6/104/102/107/108/106/108/10

* The book doesn't come with a CD-ROM, but Prentice Hall sells a different product that combines the book with an interactive CD-ROM. See the book's review below for details. ** Strictly speaking yes, but the CD-ROM content is unrelated to the book's content!

In the absence of tools to calculate the true cost-per-bit equivalent of a book, the "Listings density" row gives you an idea of how dense or "aerated" the program listings are. Low lines and/or page values usually mean unreadable listings and a high page-fill factor, so the higher this value, the better.

The "Object-oriented early?" row indicates how modern the text is. Modern texts tackle object-orientation first, while conservative texts start by exploring procedural programming concepts. Although conservative texts need not be problematic, per se, you are advised to consider first texts that submerge you in the modern computer-science world view of object-oriented software.

The "Applets or applications?" row indicates which type of Java programs the authors primarily use. Java applets tend to be regarded as more fun (or "cool") by new students, so there's a lot to be said for texts that use lots of applets, especially early on.

The "Graphics early?" row indicates whether the author(s) let the student use graphics programming early on. Letting students see their programs "live" by way of dynamic, graphical output (instead of comparatively boring, plain text output) is a proven approach to get students interested in a programming course.

The "Support classes?" row indicates whether the authors attempt to shield students from Java's few student-unfriendly facets, by interposing some support classes (a text-formatting class, for example) between example programs and the raw Java classes.

The "Keywords highlighted?" row indicates whether the text enhances its program listings by highlighting keywords (and maybe other grammatical elements, such as program comments). Since even software veterans appreciate such highlighting (on the screen, as well as on paper), you can bet that such highlighting could significantly help students new to programming comprehend their first batch of examples.

The "Suitable for hobbyist?" row indicates whether the text takes the reader through all the necessary steps to fully install and configure a working Java software development environment. Most texts leave significant gaps in this area, presumably relying on a real-life teacher to be at hand to help with such initial tasks.

Java For Students by Bell & Parr (Prentice Hall)

Java For Students immediately distinguishes itself from its competition by using applets from the beginning (p. 14). Its "Hello World" program (the de facto program that most teachers use to introduce programming) is therefore the following seven-liner:

 
import java.awt.*; import java.applet.Applet;  public class Greeting extends Applet {     public void paint (Graphics g) {  g.drawString ("Hello"), 50, 50);     } } 

This applet-centric approach means the authors incur the cost of having to introduce a modicum of HTML to create a Web page for this applet, but the long-term return on this investment is considerable: From p. 22 onward (Chapter 3, "Introductory Graphics"), the authors are free to employ the pedagogically more productive use of graphics programming as a means to bring software to life. Chapter 8, "Repetition -- while, for and do," for example, relies on rendering graphical output to illustrate the use of program loops.

I'm a strong believer that effective teachers first hook their students, in this case by bringing them into contact with interactive and fun material, before diving into the more rigorous and abstract world of object-orientation, software development rules and regulations, and so on.

Bell and Parr's early use of graphics seems to mirror this philosophy. Unfortunately, the bulk of the book is otherwise quite conservative in its teaching approach. The book introduces the core concepts of objects, messages, and classes in a fairly shallow way with Chapter 9, "Objects and classes." By that point, the student already has seen "Variables and calculations" (Chapter 4), "Methods and parameters" (Chapter 5), "Events" (Chapter 6), "Decisions -- if and switch" (Chapter 7) and the above-mentioned "Repetition -- while, for and do" (Chapter 8). More elementary OO concepts are deferred even further, to Chapter 21, "OO Design." Clearly, this is not the object-first approach used by some other books in this review.

Some of the tail-end chapters are far from conservative though. These chapters deal with program style, testing, debugging, and the use of packages in nontrivial programming projects. Multithreading (which isn't exactly a simple topic for beginners) also is discussed. In addition to the expected chapter summary, chapters typically end with some added-value sections such as "Grammar spot," "Programming pitfalls," "New language elements," "Exercises," and "Answers to self-test questions." The pitfall notes especially will be of value to total beginners.

Lastly, a warning: The book claims on both covers to be "1.2 compliant." Ignoring the issue and question of what it would mean for any book to be "1.2 compliant," it was very clear from the book's content that it was written using little more than the simplest of 1.1 Java features (mainly event-handling using listeners).

Java Gently by Judy Bishop (Addison-Wesley)

It's not every day that one can give the thumbs down to an Addison-Wesley book. For many years I've admired Addison-Wesley for its consistently above-average quality output. Bishop's Java Gently is an exception, as it leaves a lot to be desired.

Foremost, and most surprising, it is pedagogically weak, while the text itself falls short of the usually high standard expected from this pillar of computer science publishing. Some pedagogical decisions underlying this book, such as sticking to text-only applications for the first two-thirds of the book, or covering advanced topics of dubious value to new students (inner classes, remote method invocation), are not lethally flawed. Some other introductory programming books (that use Java as a teaching vehicle) share these characteristics while still hitting their educational targets. What is a lethal flaw for Java Gently is being a text that often comes across as plain messy and (ironically) hurried, sprinkled with factual errors or explanations that obscure more than elucidate.

The first 50 pages of an introductory book present its author with his or her first (only) opportunity to hook students. Fail to do so and you lose them. As a teacher attempting to introduce complete programming virgins to the highly technical world of software construction, it is advised to carefully work out a teaching trajectory that avoids all contact with the many potential obstacles to understanding and learning that litter the landscape. In Java Gently's first two chapters of Part I ("Introduction" and "Simple programs"), the strategy for crossing the minefield seems to be to shut one's eyes and run in a straight line. I don't see how any new student can process these two crucial first chapters and emerge without having been thoroughly confused.

As a salient example, Bishop's explanation of OO basics (Section 2.2 "Fundamentals of object-oriented programming") is so poor, at least in comparison to other authors' similar sections, that it will give the innocent reader a very shaky foundation indeed. For the record (only), the rest of Part I ("Fundamentals") is comprised of chapters 3 to 7: "Structuring," "Changing the state," "Controlling the flow," "Arrays and tables" and "Formatting." Part II, called simply "Power," comprises chapters 8 to 16: "Objects at work," "Abstraction and inheritance," "Graphical user interfaces," "Event-driven programming," "Applets in action," "Multi-threading," "Networking" and "Algorithms and data structures."

There's only one thing that I really liked about this book -- something other books would do well to copy: the consistent and explicit stage of testing presented programs. Often, this amounts to little more than showing and discussing the example's output, but at least it's a beginning that instills in students the knowledge that software development involves more than simply designing and writing a program.

Java -- An Object First Approach by Fintan Culwin (Prentice Hall)

This book was a surprising disappointment, especially since Culwin is an active Java evangelist in the educational community in the UK and Ireland. The front cover of Java -- An Object First Approach includes a buyer-luring "Includes UML" splash, yet when I flip through the entire collection of diagrams the book contains, I can only see non-UML diagrams (JSP and OMT styles!). And this despite the additional back-cover assurances: "To support [object-oriented design and development], Unified Modelling Language (UML) notation is used consistently from the outset..." ! Yeah, right. Doesn't look as if the twenty-first century will be a sales spiel-free era.

This book confirms the consumer heuristic that front- or back-cover "economies with the truth" usually do not bode well for the content sandwiched between the covers. It's a shame copyright laws don't allow me to simply paste, right here, the first four pages of this title's first chapter, "Two initial applications," because that's all it would take to show that this book is a pedagogical disaster area. (Luckily, the book is online, so you can actually double-check my claim via the URL and link in the Resources section of this article.)

Without even trying to explain what a computer, a programming language, a program, source code, program execution, a Java environment, and a host of other technical concepts, are, the author presents an 18-line long "Hello World" program. What follows is the clumsiest dissection of an introductory program I have ever read, and one that is sure to conjure in the reader more questions than answers. In those first couple of pages of the book, some book-wide characteristics are quickly established. The author uses nonstandard terms for established technical terms (calling Java methods "actions," for example) and regularly defines new concepts clumsily and inaccurately. This problem occurs right up to, and including, the glossary at the end of the book. (For example, object is incorrectly defined as: "Class instances and instances of primitive types.")

The text also reads like a train out of control, introducing a hodgepodge of unrelated concepts without drawing attention to what is important and what is detail. Interleaved topics addressed on the fly include the book's own typesetting conventions, Java syntax, object-oriented and procedural terms, software engineering tips, advanced Java inner workings, design notation details, and so on. In other words, this book does not offer a learning curve, it offers a cliff studded with sharp objects!

Final proof (and coffin nail) that this book has very serious shortcomings in the teaching department has to be that the bulk of the book stubbornly sticks to presenting archaic console-mode applications. Apart from a totally inadequate sample in the form of this book's last chapter, Chapter 16, "Graphical user interfaces," there are no applets, no enlightening graphics, and no GUI programming (the stuff that often hooks new students on programming in the first place).

Introduction to Programming Using Java -- An Object-Oriented Approach by Arnow & Weiss (Addison-Wesley)

Arnow and Weiss plot an unconventional route through the computer science landscape. So much so, in fact, that the authors' approach leaves me with mixed feelings. On both macro and micro scales, this book contains superior approaches and sections, and, at the very least, questionable ones too. Here are some examples of excellence on the macro scale: Java is used as a means, not as a goal; initial emphasis is on class usage, not class design; the text explains common loop implementation patterns, not just loop syntax coupled with a few examples.

Equally progressive, but not as pedagogically clear-cut, are: very late coverage of primitive data types (such as integers) and arrays; too-early coverage of input/output (I/O) programming using Input- and OutputStreams (Chapter 3, "Using Classes"); and a parallel learning track for GUI-related material ("GUI Supplements").

On a micro scale, the author's detailed and verbose explanation of the object-oriented essence of message passing was one of the best descriptions of the same that I have ever read. Most chapters contain one or more Java interludes where the authors present strictly Java-specific material, as opposed to concentrating on vanilla computer science. These sections are where the authors formally define the grammatical and syntactical rules of the Java language.

All chapters end with a summary, a terminology review, questions for review, further exercises, and the GUI supplement section. The terminology reviews, mini-glossaries stuck at the end of each chapter, are original and helpful but nevertheless imperfect because the book does not collate all these terms into one single, conventional end-of-book glossary. (I frankly don't understand how any introductory book on programming can be truly reader-friendly without an extensive glossary. Software is a field oozing with difficult jargon).

The book also tackles exercises in an unconventional way: exercises are often inserted in the middle of chapters (to test the student on the material just presented), in addition to having normal end-of-chapter exercises. The latter are noticeably less numerous than in comparable books, though. This is one of the book's weak points, since programming, like house-building or surgery, is a field where the only real way to learn is to do and solve problems, not just read.

Notable in this book is one large chapter devoted to nontrivial, fully worked-out example applications. Chapter 12, "Examples," spends 110 pages developing three interesting applications: a LOGO-style turtle program; a Web site hypertext link scanner (not unlike the WebCrawler I presented in the November 1996 issue of JavaWorld); and an African board game called Mancala.

Generally, the book's numerous diagrams are quite clear. Most of them contain lots of call-outs (arrows with descriptions) to eliminate any possible ambiguity. Also, listings often are enhanced by shaded boxes containing extra comments.

Object-Oriented Programming in Java by Gilbert & McCarty (Waite Group Press)

Roughly 14 solar orbits ago, I really enjoyed learning the C programming language using Waite's C Primer, and a good old 8-bit Commodore 64 running a real C compiler. As evidence of the fact that many other things in life go in cycles, it was with nostalgic pleasure that I read through a very distant grandchild of C Primer: Object-Oriented Programming in Java. The fact that Gilbert & McCarty's book closely resembles C Primer means that this is a great text for independent (home) wannabe programmers. It takes the reader by the hand and doesn't let go. The informal style, careful pace, transparent explanations, figures sprinkled with call-outs, and the occasional humor all ensure that students won't drown due to lack of teacher-and-classroom backup.

As befits its title, this book dives in with objects very early on. Here's the sequence of the first 10 chapter titles: "What's all this Java stuff?," "Programs: The Community of Objects," "The Atomic Theory of Objects: Working with Object Attributes," "Simply Methods: One Step at a Time," "Making Choices: Teaching your Objects about True and False," "Teaching Your Objects to Repeat Themselves," "Testing and Debugging: When Things go Wrong," "Flocking Objects: Arrays and Exceptions," "Teams of Classes: Using Classes Together" and "Inheritance: Object Families." Don't be fooled by the informal chapter titles: I found Gilbert and McCarty's approach to teaching object-oriented principles to be of the highest quality. The remaining 6 chapters (11 to 16) move away from pure computer science topics and submerge themselves, without shame, in the slightly more ephemeral world of Java for Java's sake: "Jumpin' Java: Menus, graphics and sound," "The AWT: Containers, components, and layout managers," "Advanced AWT," "Streams and Files," "Data Structures and Utility Classes," "Advanced Topics: Threads and Networking." As with the first part of the book, the text of these chapters flows nicely, and is highly readable and accurate at the same time (something that cannot be said of many other computer books in this age of conveyor-belt book production.)

Throughout Object-Oriented Programming in Java, chapters end with a summary, a fill-in-the-blanks quiz and a set of exercises.

Finally, this book is the only hardback title in this review, and furthermore lies perfectly flat without being tortured (something that, again, can't be said about most computer books). I definitely recommend this title.

Java How To Program by Deitel & Deitel (Prentice Hall)

The author duo of this textbook claim that their previous books, C How to Program and C++ How to Program, are the world's leading introductory textbooks for universities, with more than 250,000 copies in use. Unlike many other books that have roots in older books focused on lesser programming languages, Java How To Program thankfully does not show any signs of being a hastily rewritten product to exploit the booming Java market.

Having said that, its approach is very conservative in the sense that it does not tackle object-orientation right from the beginning. Further (and of greater concern), it fails to spend much energy on teaching students how to think in OO terms. Chapters 2 to 5 ("Developing Java Applications," "Program Control," "Methods," "Arrays") have a distinct procedural-language feel to them. In these chapters, the authors manage to discuss most of the basics of programming without mentioning the O or C words (object and class) very often at all.

With Chapter 6, "Object-Based Programming," the book finally starts to focus on what Java is all about: objects. Unfortunately, I didn't like this chapter because it lacked focus and spent more time explaining relatively unimportant details than discussing the more important topics. The authors use a Time example class as their class/object guinea pig (not exactly a stunning choice to introduce students to the world of classes and objects). Although class Time is presented in Section 6.2, "Implementing a Time Abstract Data Type with a Class," the central concepts of type and abstract data type (ADT) are barely touched. Instead, the chapter gets bogged down by discussing member access modifiers, class scope, creation of packages, overloading of constructors, software reusability and other topics completely tangential to objecthood.

The problematic introduction to objects and classes in Chapter 6 is thankfully not carried over to Chapter 7, "Object-Oriented Programming." This chapter manages to tighten its focus on two fundamental facets of OOP: inheritance and polymorphism. Surprisingly and disappointingly though, almost the entire remainder of the book (chapters 8 to 18) fails to build on this OOP foundation, preferring instead to devote the bulk of its pages to dissecting Java class libraries.

Chapter 8 is all about Java's String and StringBuffer classes. Chapters 9, 10, 11, and 14 deal with graphics and graphical user interface (GUI) programming. Chapter 15 deals with file and stream input and output (I/O). Chapter 16 deals with networking. Interspersing these API-centric chapters are those on exception handling (Chapter 12), multithreading (Chapter 13) and data structures (Chapter 17).

To help students track their progress on this specific learning curve, and always know exactly what's ahead of them, every chapter starts with a list of learning objectives and an outline for the chapter's content. Each chapter ends with sections called "Terminology" (a list of new names, keywords and concepts; but without definitions), "Common Programming Errors," "Good Programming Practice," "Performance Tips," "Software Engineering Observations," "Testing and Debugging Tips," "Self-Review Exercises" (followed by their answers) and "Exercises" (sans answers). These chapter appendices comprise a large part of the value of this book.

Finally, you can purchase this book as part of "A Complete Java Training Course," a book-CD-ROM package. Unlike the vast majority of book-CD-ROMs, the "Multimedia Cyber Classroom" CD-ROM is actually a highly interactive CD based on the book. It uses video, audio, and live code to give the committed student a real taste of the classrooms of the future (if you believe the media).

Computing Concepts with Java Essentials by Cay Horstmann (John Wiley & Sons)

Computing Concepts with Java Essentials is a great, pedagogically excellently thought-out text. After introducing the right amount of historical and technological context in an agile, student-friendly way in the book's introduction, the book tackles the following subjects: "Fundamental Data Types," "Objects," "Decisions," "Functions," "Iteration," "Testing and Debugging," "Classes," "Arrays, Vectors and Matrices," "Files," "Packages," "Algorithms," "An Introduction to Data Structures," and "Inheritance and Polymorphism."

Each chapter is structured to give the student maximum grasp of the slippery learning curve. Each chapter starts by enumerating that chapter's objectives. In addition to the well-written text, chapters are sprinkled with "Random Facts" (interesting intermezzos), "Common Errors," "Advanced Topic," "Productivity Hints" and "Quality Tips." The latter two types of sidebars amount to software engineering tips in disguise.

Chapters end with a detailed summary of the chapter's content, a "Further Reading" section, and two types of exercises. Review exercises test students on their understanding of the presented material, while programming exercises force readers to roll up their sleeves by commanding they "Write a program that ...."

Horstmann clearly must be a perfectionist (a man on my wavelength) because one quickly sees that this book was crafted, not just written. Further, one senses the invested effort to determine how to best teach programming to new students. Horstmann consciously uses Java as a powerful means towards that end, but not as the end in itself. One sign of this laudable philosophy is the use of a small library of support classes that shield students from some of Java's few student-unfriendly aspects (like formatted console output, or inner classes).

Other effective pedagogical tactics include the early coverage of object-orientation and graphics programming using applets and applications. For OO teaching, the author also uses the common-sense approach of concentrating on class usage long before tackling class construction (while this is common sense, many other books get even this natural sequence wrong).

I do have a couple of criticisms for the book. Foremost is its ridiculously expensive price: 7.95! With a price like this, it's a wonder how Wiley's marketing department is expecting to sell this book in any great numbers. Secondly, a number of listings contain typos and/or won't compile. (The Web site supporting this book does have an errata.) And lastly, a minor but wholly predictable criticism: Appendix A3, "Moving from Java to C++." Now who would want to do that? I'm certain Horstmann meant "Moving from C++ to Java."

Thoughts for future intro-programming texts

Reviewing the above list of introductory programming texts wasn't exactly my first opportunity to think hard and long about how teachers could plot a path through the computer science landscape using Java as the all-terrain vehicle. In fact, last year I designed the outline for a personal teaching approach that differs quite radically from the approaches seen in the books reviewed this month, at least when it comes to the all-important route chosen through the initial foothills of the learning curve.

My first observation: Java is, without a shadow of a doubt, an ideal language for first-timers -- except for two annoying obstacles that students face right from the very first "Hello World" program. The first obstacle is that Java is a compiled programming language. The conventional approach to overcoming this obstacle is to explain the lengthy edit-compile-run cycle, and explain how to install the JDK. Both these necessary explanations are full of further details and pitfalls likely to distract the student from the more fundamental issue of how to write Java programs.

The second obstacle is that even the most trivial program requires the ugly and cryptic line public static void main (String[]args) before it can do anything useful (that is, in the case of applications). This obstacle means telling the student to either treat most of this Java code as necessary black magic, or embarking on a premature and pedagogically risky explanation of every part of this code.

My second observation was that one should start by exploring the essence of object-oriented programming before talking about conventional procedural concepts, that is: explore the use of objects, method invocations, and classes.

These two observations led to the logical solution of using a minimalistic Java (language, not bytecode) interpreter. Using this interpreter (which I subsequently developed and called Jin, for Java INterpreter), a teacher can sit a student down behind a keyboard and screen, and within five minutes the student will be manipulating real, interactive Java objects (such as Frames, Checkboxes, Scrollbars, Colors, etc.), using real, legal Java statements. Given an average teacher to guide the student, 15 minutes later the student should be able to understand what objects, classes, methods, arguments, variables, statements, and possibly a few other core concepts are. That's pretty good going -- less than half an hour into a CS 101 course! Using an interpreter instead of the vanilla JDK to break the ice with the student lets the teacher attack the central concepts directly, without having to worry about students getting confused (or worse: turned off) because of irrelevant details right from the word go. (If any teacher reading this wants to know more about Jin, please contact the editors via the e-mail link at the end of this article.)

Finally, another observation that doesn't seem to have occurred to most of the authors of the reviewed books is that class or framework use should be considered a foundational skill. It follows therefore that students should know how to browse and search for bits of reusable code, classes, or entire frameworks in existing code repositories; and Java's Core API in particular. The only platform-neutral way of doing this is to browse and analyze the freely available javadoc documentation (which comes as platform-neutral HTML pages; see Resources below). None of the above books show the student how to use this pivotal, yet simple, resource.

Let's do the Bubble Sort Shuffle... and see which books sink and swim

This month, picking winners and losers needs to be done from two opposite perspectives: from a teacher's perspective and from a student's. A bit like magicians and their endless repertoire of tricks, teachers can never master enough pedagogical techniques, or own enough teaching props, or know enough well-trod, proven paths through some complex subject. In view of this, I'd suggest teachers go out and buy copies of the following titles (yes, all of them):

How to purchase these books from

Computer Literacy

Computing Concepts with Java Essentials by Cay S. Horstmann

(John Wiley & Sons) - ISBN: 0471172235

Introduction to Programming Using Java -- An Object-Oriented Approach by Arnow & Weiss

(Addison-Wesley) - ISBN: 0201311844

Java -- An Object First Approach by Fintan Culwin

(Prentice Hall) -ISBN: 0138584575

Java For Students, Second Edition by Bell & Parr

(Prentice Hall) - ISBN: 0138584400

Java Gently, Second Edition by Judy Bishop

(Addison-Wesley) - ISBN: 0201342979

Java How To Program, Second Edition by Deitel & Deitel

(Prentice Hall) - ISBN: 0138993947

Object-Oriented Programming in Java by Gilbert & McCarty

(Waite Group Press) - ISBN: 1571690867

  • Computing Concepts with Java Essentials by Cay Horstmann (John Wiley & Sons)
  • Object-Oriented Programming in Java by Gilbert & McCarty (Waite Group Press)
  • Introduction to Programming Using Java -- An Object-Oriented Approach by Arnow & Weiss (Addison-Wesley)

If you distill the best from all these titles, your course will be dynamite, and your students will emerge from your classroom as competent Java developers. As a teacher, you may also want to browse Java -- An Object First Approach by Fintan Culwin (Prentice Hall), simply to make doubly sure that your course's approach does not resemble this book's approach. If you're a student, you need a text that teaches you the right mix of material, in an order that makes sense, and without teaching you things that are wrong or that you will have to unlearn later.

The three titles enumerated above actually come close enough to delivering those common-sense requirements (oh, and by the way, don't let the very latest Java 2 platform release confuse you: you do not need this latest version of Java to learn Java. Java 1.1 (the previous stable release) is the best choice for beginners). If, for some reason, you already know that you wish to concentrate on Java, as opposed to learning the fundamentals of modern programming using Java, then Java How To Program by Deitel & Deitel (Prentice Hall) is packed with suitable information and exercises. None of these books are exactly cheap, but their price can be put in a more realistic perspective if you consider that these books can teach you a skill that will eventually allow you to earn their cover price in a single hour (as a software consultant).

Laurence Vanhelsuwé is an independent software engineer. Self-taught, he dropped out of college and immediately started a professional career writing arcade games. He has worked on such diverse technologies as X.25 WAN routers, virtual reality flight simulation, Postscript, and realtime digitized video-based traffic analysis.

Learn more about this topic

  • Academic institutions teaching JavaA slightly out-of-date list maintained by Sun http://www.sun.com/products-n-solutions/edu/pandp/javaschools.html Should Java be taught in first year Computer Science? A very interesting site for teachers. It contains several links to other sites of similar value. http://www.cs.uwa.edu.au/~chris/java-in-cs1/
  • Java in the Computing Curriculum Conference (JICC3). South Bank UniversityLondon on Monday the 25th January 1999. http://www.scism.sbu.ac.uk/jfl/jicc3/
  • Java -- An Object First Approach http://www.scism.sbu.ac.uk/jfl/Chapter1/chap1.html
  • The standard, free, platform-neutral documentation to the Java classes. http://java.sun.com:80/products/jdk/1.2/docs/api/index.html
Join the discussion
Be the first to comment on this article. Our Commenting Policies