Skip to content
Topos Uranos
English

Final review of Programming in C++ I

Summary

This entry is not one more lesson, but the final account of the course: it recalls the seven learning objectives that the syllabus set out at the beginning, shows in a single figure to which of them each lesson of each unit was assigned, explains how each objective was worked on throughout the eight content units, distinguishes the objectives that have a unit of their own from those that run through the whole course, gathers what the course leaves beyond C++, teaches how to read the self-assessment by objective, which gathers the first attempt at the exit assessments, and points out what the course leaves to Programming in C++ II.

Learning objectives

  1. State the seven global objectives of the course and recognize in which units and lessons each one was worked on.
  2. Distinguish the objectives that have a unit of their own from those that run through several, in particular problem solving with its cycle of compiling and debugging, and specification and testing, and explain how the latter are exercised.
  3. Separate, in what was learned in the course, what holds in any language from its form in C++, and explain what the course leaves to Programming in C++ II.
  4. Decide, from the self-assessment by objective, the figure and the challenges of each synthesis, which units and which lessons are worth reviewing.

What the course set out to do

The course was born with a general aim: to teach how to write correct programs from scratch, making programming itself, and not a language, its object. For this it chose a demanding instrument, C++, because it does not hide the machine: it forces types to be declared, separates compilation from execution, makes visible the memory, the cost of copying and the limits of each number, and punishes with undefined behavior what other languages conceal. The lesson on the syllabus unfolded that aim into seven global learning objectives, which are worth keeping in view with the numbering with which the figure cites them:

  1. Solve problems with programs: specify what goes in and what comes out, design an algorithm, trace it by hand, and write, compile, run and debug it, interpreting the messages and the warnings of the compiler.
  2. Choose the appropriate type for each piece of data and reason about the limits of its representation: the range of integers, overflow, floating-point rounding and text encoding.
  3. Build correct expressions, knowing precedence, type conversions, side effects and what the standard leaves undefined.
  4. Design control flow with correct decisions and loops, which terminate, and justify their correctness with an invariant.
  5. Decompose a problem into functions with clear interfaces, choose how to pass the parameters, and solve problems by recursion.
  6. Represent and process compound data (sequences, tables, records, text and files) with the basic algorithms and with the standard library, estimating their cost.
  7. Organize larger programs into several files, specify them with a precondition and a postcondition, test them systematically and argue for their correctness.

Each lesson of the course also stated its own specific objectives. The lessons do not say which global objective each one serves; that correspondence is a reading made from outside, with the same method as in the other courses of the site. Each specific objective is assigned to a main global objective and, if it touches them, to other secondary ones; each counts in full towards its main objective and by half towards each secondary one, and the lesson is joined as main to the global objective that gathers the most weight and as secondary to the others that receive some. If two objectives tie, the one of the unit decides and, if neither is, the one with the lower number; thus the lesson on variables and memory, whose objectives are split equally between 1 and 2, is joined to 2, which is the one of its unit. The introductions follow the same rule. The syntheses, on the other hand, follow a criterion of their own: their main objective is that of their unit, because their chain of concepts, their exit assessment and most of their challenges gather what the unit taught; the unit on text and files, which has no objective of its own, is counted with 6, to which three of its four lessons belong. If this is so, the whole course takes the form of a spine: the head is the general aim; the column, the order of the units, each with its segment; each lesson is a node of that segment, joined to its main objective, and the seven objectives float around the column, held up by the lessons that feed them.