VisualAge for C++: Visual Programmer's Handbook

Reviewed by Keith Hubbard, IBM

VisualAge for C++: Visual Programmer's Handbook (ISBN: 0136143229) by Dale Nilsson and Peter Jakab is a complete, step-by-step introduction to visual programming using IBM's VisualAge for C++. Using a series of example applications, the book teaches the concepts and techniques needed to successfully build applications using the Visual Builder component of VisualAge. It is designed as a hands-on tutorial with detailed instructions on how to implement each step. The book also comes with two CDs containing 60-day trial versions of VisualAge for C++ and IBM DATABASE 2 for OS/2 and Windows 95/Windows NT.

The book starts with an overview of the VisualAge for C++ development environment and the available documentation and tools. Detailed instructions are provided for installing the software provided on the CDs and getting started with VisualAge for C++. The second chapter jumps into programming by showing how to create a "Hello World" application and walks you through all the steps required to build programs using the Visual Builder. Later chapters quickly progress to more complex user interfaces, complete with toolbars, pop-up menus, fly over help, and notebooks. The book also shows how to develop custom, non-visual parts containing application logic and how to create composite visual parts to simplify connections and allow reuse. Other aspects of GUI development are covered as well, including chapters on building help files, debugging applications, storing persistent data in OS/2 INI files or the Windows registry, and using the Data Access Builder to interface with databases (such as DB2). The final chapter deals briefly with advanced topics, such as creating resource DLLs, running programs under Windows 3.1, and application design considerations.

The book grew out of a one week course taught by the authors and retains the learn-by-doing feel of a lab-oriented class. Most of the book focuses on showing how to implement a series of example applications illustrating the concepts and methods used in visual "construction-from-parts" development. Strong emphasis is placed on implementation rather than design and theory. New parts and techniques are briefly described in the text and then covered in detail through step-by-step instructions showing how to incorporate them into an example application. As you make changes, the examples should be rebuilt and tested to show the new features in action. Much of the book's information is contained in the instructions; to really benefit from the book, you will need to work through the examples. Each step is clearly described (often with pictures), making it easy to follow along with the book and completed "answer" files are available on the CDs if you get stuck. The book also contains helpful advice ranging from Visual Builder shortcuts to design considerations for improved usability and performance. Differences between the OS/2 and Windows environments are pointed out and platform specific instructions are given where needed.

Overall, VisualAge for C++: Visual Programmer's Handbook is a solid introduction to the Visual Builder and "construction-from-parts" paradigm. The book covers everything needed to start building real applications, from installing the compiler to building custom resource DLLs to hold icons. The instructions are clear and combined with the abundance of pictures, code fragments, and figures, are very easy to follow. The hands-on approach is a natural fit to visual programming and allows you to see your progress quickly and experiment as you learn new material. The major techniques and components are covered in multiple applications, giving you practice in implementing them in different contexts. Even if you do not have any experience programming graphical user interfaces, you should be able to work through the book without much difficulty.

However, the strong step-by-step approach that makes the book an easy-to-follow tutorial limits its usefulness beyond an introductory level. The organization makes it inconvenient to use the book as a reference. The book is structured around the example applications; information about parts and concepts is discussed wherever it is needed to implement different aspects of an application. Unless you know which example introduced an idea, it is difficult to know where to look for it in the book. To complicate matters, information is sometimes buried in obscurely labeled sections. For example, toolbars are introduced and described in the major section "Copying Parts" while adding keyboard handlers and clearing entry fields both fall under "Testing the User Interface." There are two different "Understanding VisualAge Parts" sections which cover similar but different information. Although the index helps, it does not seem complete.

My biggest concern about the book is its relatively narrow focus on implementation details. Like many other books of its kind, it teaches you the "hows" of visual programming and building from parts but leaves out many of the "whys." After studying the book, you certainly should be able to effectively use the Visual Builder tool and understand the concepts behind it, but there is a big leap from understanding a small pre-designed example and being to design and implement a useful real-world application. Although the authors state up front that they expect you to understand object-oriented programming concepts, there is a lot of difference between conventional C++ programming and visual, parts-based programming. Patterns that work well when writing sequential C++ code often fall apart if you try to translate them into the visual programming model. It can be frustrating to quickly build visible user interface components but then get stuck trying to hook all the pieces into an application that works. More elaboration on the thought processes that went into the design of some of the parts (especially the nonvisual parts) and overall logic flow could help bridge the gap from simple examples to more complex applications.

Home Page