Complete one chapter of "Teach Yourself C++ in 21 Days" each day until I complete the book.

Currently, I’m in chapter 18. Which I believe should have been among the first chapters. Chapter 18 is particularly interesting because the author insists that project estimators should simply capitulate to not having the project done on time.

While it’s true that projects are rarely delivered on time and on budget, the particular methodology that he advocates is, in my mind, doomed to failure and his advice to simply give in to not having the project fully completed by the deadline sort of makes sense in that case.

But the fact is, I’ve only missed a deadline once. And that was due to my unwillingness to walk away when the customer kept monkeying with the specifications. It was my fault. But I no longer allow changes after the fact to specs anymore. And I no longer miss deadlines.

This approach is controversial and I’m often accused of being inflexible. Of course, the discussion usually stops when I offer to renegotiate the cost or deadline. I guess I am somewhat flexible but the customer must also be.

There have been many more features I’ve gone through, but I only have about 15 minutes for this entry (the first in weeks) and so I can’t go through each of those chapters. I do find the overall arrangement of the book (with these last chapters looking a lot like filler) to be odd. But more about that when I can give my final verdict on the experiment and the feasibility of the book’s thesis.

Finally feeling good enough to make an entry on this.

References are a vital tool for resolving many problems in programming. The author does a decent job of covering the subject but references in C++ are essentially the same as they are in C.

Of more interest the chapter on advanced functions covers something I never knew about C++. These are virtually all related to working with objects. The overloading (or changing the behavior) of operators (such as the minus sign and the plus sign) is a neat feature. Though I realized that this a logical extension of the language, since there is an occasional necessity to use those operators with programmer created objects. It’s a long chapter but in the hands of a dedicated reader, it would yield – and probably in less than an hour.

Perhaps the most slippery aspect for beginners in programming. I learned C in an environment that requires the use of pointers (PalmOS) so, I wasn’t terribly concerned.

I did spot a typo, though. After carefully introducing the new and delete keywords (new allocates memory and returns the address of the allocated memory and delete deallocates it) a FAQ box referred to a malloc() call.

malloc() (memory allocate) is a C – NOT C++ – call that does the same as the new keyword in C++.

This the first of what will probably be many typos. This was common for many technical books of the time…There was, literally, a gold rush as people poured into the technology market and book companies rushed their books into print to capitalize on the interest of those folks. It was the largest section in the bookstore the day I bought this book.

My work on this experiment continues apace (despite my illness).

At last, in chapter six, we touch on an aspect of what makes C++ , C++.

Day six introduces the concept of an object. This is, finally, over the wall from C to C++. Of course, day seven veers back into C with a more advanced treatment of program flow (for the first time looping – possibly the most important aspect of programming – is introduced).

I think I’ve discovered pattern. Since C++ is a superset of C, the book intersperses one with the other. This approach does not invalidate the fundamental premise of the book though it does sort of have a stop and go effect on my interest in the topics covered. (I’m pretty decently experienced in C, so the bits about pointers and streams and references I’ve already covered).

Day eight covers pointers, which I think are very cool (and indeed, in constrained environments, are the only way programming can take place at all).

So, going into week two, I do expect my pace to slow but only marginally since there are a lot of topics that I’ve already experience with.

Since many of these introductory chapters should – in my opinion – be consolidated, I decided to take my own advice and treat them as one. Having done this, days two through five (inclusive) and probably day seven really should be one day.

These chapters cover the anatomy of a C++ program, variables and constants, expressions and statements, functions and chapter seven appears to cover advanced program flow (which I haven’t completed). Day six (which will be tomorrow for me) finally enters into C++ territory with “Basic Classes.”

The first five days are essentially a rehash / introduction to C or procedural programing (with the important exception of pointers). Not entirely useless, it turns out, even for me. The reintroduction to recursion (having a portion of a program branch back to itself) was a challenge that resulted in a very satisfactory solution. In most applications I’ve worked on, recursion was always very rare, so I am rather proud to have reacquainted myself with it again.

Only 16 more days to go!

Total time to complete this chapter (with exercises): 30 mins.
Probably could have been consolidated into day one. Not a criticism, really. I promise. Just a difference of opinion.

These short chapters cause me concern since I know that in order even to get close to the stated aim of the book, I’ll be making up for them – in spades – probably next week as the book moves into more advanced topics. I’ve glanced ahead and sure enough, there are several 40 page chapters ahead.

I would imagine that for a complete beginner this sort of ramp up could seem scary. Of course, on the other hand, a determined and motivated beginner (say, a Russian high school graduate with an interest in computers and no money to go to college) would probably push on through that.

Once things start to get serious (by day seven or nine) I’ll have a better handle on how realistic the thesis of this book is.

Total time (including the completion of the exercises): 50 minutes.
Good that it ends with a series of exercises that puts the reader in front of the IDE.

Overall, the chapter was a bit of a crash introduction. The book makes a brief reference to analysis and design and accurately indicates that these are the most important steps in the development of an application…Curiously, however, neither one of the traditional program planning methodologies – psudeocode or flowcharts – are mentioned. Ironically there’s even a flowchart to illustrate the development process.

• Encapsulation. A more intuitive term would be “compartmentalization.” Basically, in object oriented programming, we create “objects” that contain data and do stuff to data and other objects. But encapsulation, I imagine, sounds much more mysterious to non technical folks (and thus, justifies the amount of money programmers are paid).
• Inheritance. Like as in money? No. This aspect of object oriented programming allows you to take the data and procedures of one object and add data and procedures to create a new or “extended” object of your own creation. The idea is that if functionality already exists, you shouldn’t have to re-invent it.
• And my personal favorite: Polymorphism! A two bit buzz word that means you can pass different data to a procedure and have it handle that data correctly.

These attributes are important but I think that the gratuitous use of technical jargon is really just a cover up.

The third edition – copyright 1999 – has been on my shelf for at least eight years. From the little I have read in those eight years, I’ve wondered if the pace the author and publisher have set is, in fact, possible. I’m a much more experienced programmer than I was when I originally purchased the book and my objective is to see, if, under any circumstances this is possible.

While much of the material is now instinctive to me, I will start with chapter one, working each day, to chapter 21.

Each day, I’ll post my thoughts here on the chapter and its related exercises. Given that today is July 4, I’ll start the experiment tomorrow.