20 or 25 Day C++ Day Curriculum

Description

This curriculum is specifically designed to accommodate a broad range of needs. With more than fifteen days of instruction, we can slow the pace of the course to allow more time for laboratory exercises and student questions. The fifteen days are broken down into beginning, intermediate and advanced. See the outlines.

We include extensive discussions of object-orientation throughout the fifteen days and how it relates to C++ programming.

How Many Advanced C++ Courses?

Our initial concerns are to fill classes. If we offer too many classes, no single class will have enough students to meet the initial threshold.

Do we only need a single advanced class? If so, which one? Do we need more than one? Please scrutinize the candidate outlines for advanced C++ courses and complete our little questionnaire.

Unless there is a lot of interest, we will probably abandon the present advanced C++ course because it does not accommodate the large number of special environment programmers enrolling in our classes.

Two Kinds of Programmers

We have found it necessary to distinguish between application programmers and special environment programmers. For that reason, some of the courses have been retitled to include "Application" in the title. Other courses have the term "Special Environment" in the title to indicate that they include special laboratory exercises that do not require any special run-time libraries.

Please Take Our Brief Survey!

Please take a look at the outlines and take our survey.

Our Non-Traditional Approach

Rather than discussing feature A on Monday and feature Z on Friday, we take a different approach to better maximize programmer productivity. We identify three styles of programming: Type-Safe (or Procedural) C/C++, Class User Programming and Class Provider.

We start with the simplest: Type-Safe C/C++. This basically includes all the features in C++ that are not specific to creating new classes or object-orientation. We avoid using pointers in this section, and prefer to use the reference feature to pass arguments instead.

This is followed by Class-User Programming. This gives us another productivity boost as we use the standard library to exemplify the re-use of classes. We continue to avoid pointers and suggest that anything that requires pointers can be done much more effectively with a container class from the standard library.

Finally we discuss Class-Provider Programming. We explain that this should be avoided when it is possible to re-use someone else's classes. Here we finally examine the role of pointers and identify how the use of pointers generally leads to

	Dynamic memory allocation which makes our code run slow and hard to understand and debug
	Constructors, destructors, overloaded assignment operators which make are code more cryptic.

This progression of type-safe, class-user and class-provider programming is repeated with each 5 day installment with increasing sophistication in the beginning, intermediate and advanced courses.

Our C++ Philosophy

Years of programming, training and research in C++ have lead us to some powerful principles that guide our consulting and training efforts.

We believe in improving programming productivity. This is our foremost goal. We focus on how Bjarne Stroustrup (the originator of C++) added features to the C language to invent C++ specifically to improve programmer productivity. Often this means employing object-orientation -- but not always.

Productivity is not limited to getting a product out the door. One of our favorite examples used throughout the 15 days will be the Y2K crises. We discuss how to avoid these kinds of problems that will imperil the productivity of future generations of maintenance programmers can be avoided.

We believe in using the optimal tool for the job. In these courses we will compare the perils and merits of programming in C++ with other options such as Java. We ask the question: "If you are not writing highly optimized code in C++, should you be using Java?" We consequently emphasize the importance of the balance between the insensitivity to performance issues and the perils of premature optimization.

We believe the rests are more important that the notes. Ask any musician which is more important: the notes (when to make a sound) or the rests (when not to make a sound). The musician will always answer that the rests are more important. We believe knowing what programming techniques to avoid is just as important (or even more important) than what techniques to use.

We believe in balancing object-orientation and performance wisely. Even seasoned Java programmers know that object-orientation can be perilous to good optimization. C++ programmers should be even more keenly aware of this issue. We will also learn that the ANSI standard library specifically avoids object-object orientation for performance reasons.

We believe that well written procedural code is far superior to poorly written object-oriented code. While we discuss object-orientation extensively, the first order of business is to learn the basics and that includes type-safe (or procedural) C/C++, the common subset of ANSI C and ANSI C++.

Sometimes object-orientation is not tractable. Because C++ has extremely limited support for late binding (and late binding is perilous to performance anyway), we examine scenarios where we might abandon it. Examples include integration with relational databases and modeling state changes with a different class for each state.

There is no substitute for Analysis, Design and Testing. While these are not courses on object-oriented analysis, design and testing, they are extremely important topics. These courses anticipate that students will be working from a design and discuss the techniques in C++ for implementing an object-oriented design.