Java's phenomenal success as an enabler of enterprise-wide, Web-deployed
applications has compelled countless organizations and individuals to seek
Java proficiency. Many are drawn like moths to a flame, and in fact go "down
in flames." They're ill-prepared to harness Java's power as an
object-oriented programming language due to a basic lack of understanding of
Many professional software developers schooled only in procedural
programming languages are now looking to make the transition from procedural
to OO programming with Java. Motivated by career survival, they seek a
"quick fix" a single book or course that can transform them into
Java-proficient software engineers.
In addition, the relative shortage of Java-trained professionals has led
organizations to attempt to mass-produce Java talent by retooling their
in-house programming staff in Java. Eager to do so in the quickest way
possible, they fall prey to the notion that sending competent programmers to
Java training especially C++ programmers, who are presumably already
proficient with objects will produce instant "Java savvy."
What these individuals and organizations often don't realize is that:
Most Java training does only a cursory job of explaining object concepts. After a perfunctory lesson on what objects and classes are, Java instructors usually dive into the details of Java syntax without giving participants a
big-picture appreciation for the nature of objects. Topics key to harnessing
the full power of an OO language e.g., encapsulation, information hiding,
object collaboration, overriding, polymorphism are merely touched upon in
passing, if at all. Students go through the motions of writing Java code
"snippets" but often come away without any knowledge of how to structure a
software application from the ground up to make the most of Java's OO
Not all C++ programmers are object savvy. Many software engineers who adopted C++ years ago were "born-again" C programmers who saw C++ as a
"better C." They weren't necessarily compelled to learn the object paradigm
beyond a superficial level because they were able to successfully write
procedural C++ code upon merely learning C++ language syntax. (Despite many
syntactic similarities between the two languages, Java is arguably more true
to the object paradigm it provides fewer "back doors" with which a
programmer can escape the rigor of objects.) Those C++ programmers who never
learned objects properly don't have a leg up learning Java, but
organizations unfortunately assume they do.
The prevalence of drag-and-drop Java IDEs exacerbates the situation. While such tools allow those without object know-how to craft OO user interfaces, these UIs sit on top of a non-OO infrastructure. Like the Hollywood facade of a town in the Old West, an application built with such an IDE may appear
to be object-oriented. Scratch the surface, however, and you'll see the
reality there is a noticeable discontinuity between the OO front end and a
decidedly nonOO back end. This leads to brittle applications that are
difficult to extend and maintain.
The "object crisis" is by no means insurmountable. By observing a few
basic guidelines for how best to retool with objects in general and Java in
particular, you can quickly be off to the right start:
Invest in object training before Java training: it's like learning how
to hold a golf club properly before strategizing how to play a particular
golf course. But choose wisely. Make sure that the object training you
select doesn't teach objects in isolation it should also illustrate how to
bridge the gap between object models and Java code.
Craft your own Java code using a bare-bones IDE or simple text editor
to master the OO aspects of Java before relying on a drag-and-drop GUI
builder to churn out code automatically.
Engage a Java-proficient object mentor to work with a fledgling Java
team throughout the project life cycle.
Tackle a reasonably small project first don't attempt to conquer a
major enterprise-level application. Ideally, cut your teeth on an in-house
project versus a project-for-hire for a key client.
The object paradigm is intuitive and powerful...nonetheless, mastery of
objects doesn't happen automatically by virtue of learning Java syntax. An
up-front investment in learning objects properly will pay for itself
numerous times over in terms of the quality, maintainability, and robustness
of the resulting Java applications.
Jacquie Barker is a professional software engineer, author, and adjunct
faculty member at The George Washington University. Her book, Beginning Java
Objects, is focused on conquering the object crisis by teaching fundamental
object concepts side by side with beginning Java syntax (www.objectstart.com).
Java and Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. SYS-CON Publications, Inc. is independent of Sun Microsystems, Inc.