C++ Programming Students

It’s strange that I’m the only tutor for our Com­puter Sci­ence and Infor­ma­tion Sys­tems depart­ment, but I can live with that. What irks me though, is how these stu­dents come to gain their knowl­edge about programming.

To be fair I will not men­tion names, and not blame any­one. I truly believe this to be a sim­ple mat­ter of mis­com­mu­ni­ca­tion, and eas­ily solved. I also feel that the scope of these classes needs to be mon­i­tored a lit­tle more closely, and what fol­lows is sim­ply what I under­stand the classes should teach in an intro­duc­tory pro­gram­ming class, and my under­stand­ing of what is being taught in our intro­duc­tory pro­gram­ming classes.

The classes in ques­tion are our first intro­duc­tory classes to C++, and then our fol­low up course. These courses together should leave the stu­dent com­fort­able with the basic con­structs and built-ins of C++. It should also make them com­fort­able with classes, and work­ing in an OOP(Object Ori­ented Pro­gram­ming) par­a­digm. The prob­lem crops up in the tran­si­tion between these two classes. It seems (and this I know because of my tutees) that their under­stand­ing of the basics gets mud­dled in the first class, and thus they can­not build upon this knowl­edge in the sec­ond class. I have heard many things about what may be hap­pen­ing wrong in this class to cause such a ter­ri­ble calamity, but let us refo­cus and start by going over what should be cov­ered in the first class in order to suc­ceed in the fol­low­ing class and through­out the whole program.

In an intro­duc­tory pro­gram­ming class it should be impor­tant for stu­dents to become famil­iar with func­tions, con­trol struc­tures, and var­i­ous key­words (not all of them mind you just most of them). Thus they should be com­fort­able look­ing through a piece of code like the fol­low­ing, and have an under­stand­ing of the major­ity of it:

#include <cstdlib>
#include <iostream>

using namespace std;

int factorial(int n)
{
    if (n == 0)
        return 1;
    return n * factorial(n - 1);
}

int main(int argc, char argv[])
{
    if (argc != 2)
    {
        cerr << "You must pass a number to get the factorials!" << endl;
        return EXIT_FAILURE;
    }
    int n = argv[1] + 1;
    while (--n, n > 0)
        cout << "The factorial of " << n << " is " << factorial(n) << "." << endl;
    return EXIT_SUCCESS;
}

They should also be able to under­stand Make­files (rudi­men­tary Make­files not automake or any­thing of its ilk), header files vs. source files, the stages of com­pil­ing and how to deal with dif­fer­ent errors in each (i.e. A link­ing error ver­sus a com­pi­la­tion error), and they should under­stand array mechan­ics (if not exactly what they are then how to use them). They should be able to put all of this together, and make a nice mod­u­lar pro­gram that allows them to expand and reuse code in an intel­li­gent way. Then if there is time (although this gets cov­ered in great detail in the sec­ond class) a quick cov­er­age of structs should ensue. At this point the edu­ca­tion they should have gained from the first class should be enough of the basics that they under­stand the con­structs of the lan­gauge, and can start read­ing sim­ple pro­grams like the one above.

In real­ity, this goal (mind you this is my per­sonal goal and does not reflect the goals of the pro­fes­sors or the depart­ment) was not met, and based on expe­ri­ence with peo­ple I’m tutor­ing who are in the sec­ond class at this time it is quite obvi­ous where their short­com­ings are. Those short­com­ings are out­lined below:

• Lack of under­stand­ing about the loop­ing con­trol structures
• Lack of knowl­edge as to how arrays func­tion, and should be used
• Lack of knowl­edge as to how the com­piler actu­ally takes the source code (pos­si­bly spread over many files), and makes an executable
• Lack of under­stand­ing as to how to solve sim­ple prob­lems like manip­u­lat­ing all the entries of an array
• Lack of under­stand­ing as to how to do a sim­ple search, or uti­lize func­tions pro­vided in an API(Advanced Pro­gram­ming Interface).

This list will be updated appro­pri­ately as I gain more knowl­edge on what the stu­dents actu­ally know. Thus this list may have inac­cu­ra­cies and short­com­ings, and may not reflect reality.

The list goes in in much the same fash­ion here after, and this is obvi­ously a prod­uct of the class not ful­fill­ing its pri­mary pur­pose of lay­ing down a foun­da­tion that the stu­dents can build on. To bet­ter achieve this goal it may be nec­es­sary to at the very least rec­om­mend some sup­ple­men­tal texts (see list at the end of this arti­cle for rec­om­mended books for the var­i­ous pro­gram­ming courses).

Now, what I’ve heard reports of in this class is that (1) these con­cepts out­lined above are not get­ting cov­ered in the detail that is required of them in the sub­se­quent classes (which only con­firms what I’ve observed in stu­dents), and (2) there has been a report that a new teach­ing tool “Alice” was used in the intro­duc­tion class.

The first point appears to be just a short­com­ing of the class, and could be ame­lio­rated by sim­ply spend­ing more time and going over more exam­ples of the con­cepts in question.

Also, the stu­dents them­selves need to real­ize that they con­trol their edu­ca­tion, and must par­tic­i­pate for a class to truly be suc­cess­ful for them. When enter­ing a class, stu­dents should think to them­selves what do I want from this class, and how can I have this class help me achieve that goal? By ask­ing ques­tions and look­ing for more mate­r­ial on the spe­cific area of study the stu­dent is inter­ested in they can get a much more ful­fill­ing expe­ri­ence and bet­ter under­stand­ing of the top­ics involved, but may hit a point where they just can’t keep up with the class and need fur­ther assis­tance that isn’t self-guided. Tutors are avail­able from the tutor­ing depart­ment, and should not be shied away from. If you really want to learn the mate­r­ial you have to be will­ing to get help and help your­self towards that goal. That’s only part of the prob­lem, stu­dents who do try are still hav­ing a hard time within the sta­tus quo.

The sec­ond point requires that I do not put forth my per­sonal opin­ion, but does require that I state its pur­pose (from the Alice website):

Alice is an inno­v­a­tive 3D pro­gram­ming envi­ron­ment that makes it easy to cre­ate an ani­ma­tion for telling a story, play­ing an inter­ac­tive game, or a video to share on the web. Alice is a freely avail­able teach­ing tool designed to be a student’s first expo­sure to object-oriented pro­gram­ming. It allows stu­dents to learn fun­da­men­tal pro­gram­ming con­cepts in the con­text of cre­at­ing ani­mated movies and sim­ple video games. In Alice, 3-D objects (e.g., peo­ple, ani­mals, and vehi­cles) pop­u­late a vir­tual world and stu­dents cre­ate a pro­gram to ani­mate the objects.

In Alice’s inter­ac­tive inter­face, stu­dents drag and drop graphic tiles to cre­ate a pro­gram, where the instruc­tions cor­re­spond to stan­dard state­ments in a pro­duc­tion ori­ented pro­gram­ming lan­guage, such as Java, C++, and C#. Alice allows stu­dents to imme­di­ately see how their ani­ma­tion pro­grams run, enabling them to eas­ily under­stand the rela­tion­ship between the pro­gram­ming state­ments and the behav­ior of objects in their ani­ma­tion. By manip­u­lat­ing the objects in their vir­tual world, stu­dents gain expe­ri­ence with all the pro­gram­ming con­structs typ­i­cally taught in an intro­duc­tory pro­gram­ming course.

In con­clu­sion, it is my per­cep­tion that there is a miss­ing com­mu­ni­ca­tion link in the way these classes are han­dled, but it’s not just between the pro­fes­sors of the two classes (they seem to not have a smooth break between the classes), it’s between the stu­dents and the pro­fes­sors that the com­mu­ni­ca­tion has really bro­ken down. The stu­dents must speak up for their edu­ca­tion or they may see it going down a path that does not max­i­mally fur­ther their edu­ca­tion. This is wider spread than just the sim­ple class exam­ple I’ve given here. Almost every­where one looks, it seems that stu­dents are becom­ing more lethar­gic; push­ing to just get through the courses. There is a lack of gen­uine inter­est in the edu­ca­tion being pro­vided, and more of a view that col­lege is now a neces­sity to con­tinue in soci­ety. Unfor­tu­nately, that has begun to be so, but we can still fight for the free­dom of our minds.

Sup­ple­men­tal Books for CSIS Courses: 1. 152 * C++ in Plain Eng­lish by Brian Over­land 2. 252 * C++ in Plain Eng­lish by Brian Over­land 3. 352 * C++ in Plain Eng­lish by Brian Over­land * Beyond the C++ Stan­dard Library: An Intro­duc­tion to Boost by Björn Karls­son * C++ Cod­ing Stan­dards: 101 Rules, Guide­lines, and Best Prac­tices by Herb Sut­ter & Andrei Alexan­drescu * Design Pat­terns: Ele­ments of Reusable Object-Oriented Soft­ware by Erich Gamma, Richard Helm, Ralph John­son, John M. Vlissides