The advanced programming course I have taught at Brown for about ten years is designed to follow an introductory programming sequence and to provide the background needed by the students in order to undertake serious programming projects in advanced courses, research, or actual jobs. It teaches the essential topics that are needed for serious programming but not generally covered in the earlier courses such as small-scale and large-scale object-oriented design, the ability to use a modern object-oriented programming language effectively (in this case C++), advanced programming concepts, user interface construction, debugging and testing, and basic software engineering. The course has a strong practical side, and the students actually design and implement significant projects during the semester. While there are individual books on each of the topics in the course, I have not found a single book that provided the right level of information on each subject with a strong practical bent. Thus I eventually broke down and undertook to write this one.

I designed this text to fit an intermediate-level programming course such as that described above. The text assumes the students have had a reasonable introductory programming sequence that includes basic programming and algorithms and data structures. At Brown, we teach Java in the introductory courses, but the text should be suitable for students with a C++ or procedural background as well. The book uses C++ rather than Java since C++ is still the language of choice for writing large systems and is still the basis for most advanced programming courses at Brown and elsewhere.

The text provides students with the tools and techniques that will enable them to be comfortable designing and implementing moderate-sized software systems alone or in a team, preparing them for more directed systems courses in specific areas such as databases, compilers, computer graphics, and software engineering, as well as for summer and full-time programming jobs.

The text assumes that the students have access to and familiarity with other books or manuals on the basic concepts of C++, a user interface framework such as Motif or Microsoft Foundation Classes, and a good suite of programming tools. If students have no C++ background, then a C++ text should probably accompany the first few chapters. Even with a C++ background, the students should have access to a language reference manual. A text, manual, or appropriate handouts are also needed to provide the details on the target interface for graphical user interfaces and the relevant programming environment. These additional works provide the raw materials that this text attempts to organize, integrate, and prescribe for the students.

Overview of the Text

The material is organized into sections, each concentrating on a particular topic, with some overlap. The basic topics include:

Each of these topics is treated in a practical, hands-on manner. Most chapters work through an example relevant to the material, using its concreteness to give the abstract principles a solid and understandable basis. The text is peppered with guidelines giving my best advice on how to build reasonable software systems. Complete code for the example of Chapters 2 and 3 and that of Chapter 7 is included in Appendices B and C, offering additional details to supplement the material in these chapters.

Use of The Text

This text was designed for an advanced programming/introductory software engineering course at Brown. The organization of the chapters in the text is essentially the one I use in class. The basic concepts of object-oriented design and implementation are taught early to give students the tools to implement actual programs. The first assignment is a simple program designed to familiarize the students with C++. Then, having gone through the material in Chapters 1 through 5, I assign a moderate-sized individual programming project (currently the control logic for a 3D pinball program). As the students work on this, I go through the material on design, libraries, debugging, and user interfaces. The next programming project involves developing a user interface and accompanying back end for a two-person project. While this project is under way, I cover most of the material in Chapters 12 through 14. The fourth programming project gives the students additional experience with user interfaces and an introduction to multiple-process programming. The last month of the course is occupied by a larger, four-person team project that the students select themselves and then specify and implement, which generally turns out to be a multiplayer game program. I cover the material in Chapters 15 and 16 while they are finishing up the previous program and starting to think about this project. Once this is done, the students give two in-class presentations, the first briefly describing what their project will do and the second describing its top-level design.

The material in the text can be used in other ways as well. Most of the chapters can, with only minor additions, be considered in a different order. The material on debugging, for example, can be easily moved either earlier or later in the course. Chapter 11 on user interface principles can be read earlier or omitted entirely, as can Chapters 12 and 14. Chapters 4 and 5 can be used before Chapters 2 and 3, but this makes it more difficult to start the students on a serious programming problem early in the course.

To provide supplementary material to this text, we have established a web site at:

We will be updating this site with corrections, suggestions, code, problems, etc., as appropriate. Contributions are encouraged.


I would like to thank the many people who have read and commented on the material in this text. Notable among these is Scott Lewandowski, who suffered through the first draft of the whole text and offered helpful comments and suggestions throughout. Others who have given helpful comments include Henrik Christensen and Andrew Schulak. I am also very appreciative for the many suggestions I received from outside reviewers including Owen Astrachan, Duke University; Sallie Henry, Virginia Tech; Ronald McCarty, Pennsylvania State University at Erie; James Purtillo, University of Maryland at College Park; Edna Reiter, California State University at Hayward; and David Stotts, University of North Carolina at Chapel Hill. Finally I would like to thank Trina Avery for making the prose more readable.


[ home | abstract | errata | faq | contents | preface | sources | problems | links ]