Course contents (draft)

Week 1

Session 1: Introduction to the command-line, first steps

• the command-line
• navigating the filesystem
• invoking the compiler
• using an editor: micro (or notepad++)
• writing our first hello_world.cpp
• including standard headers
• Basic data types: bool, int, float, double
• the std::string class
• command-line arguments
• the std::vector class
• range-based for loop
• regular for loop
• type inference: the auto keyword
• conditional execution: the if statement
• statements and compound statements
• switch statement TODO
• jump statements: break and continue TODO
• basic error handling

Exercises TODO

Session 2: first project, input/output, functions

• Introduce DNA shotgun sequencing project
• std::cin, std::cout, std::cerr and their use
• reading data from file: std::iftream
• Using algorithms from the C++ Standard Template Library: std::min(), std::max()
• writing data to file: std::ofstream
• Using and defining functions
• returning values from functions

Exercises TODO

---

Week 2

Session 1: multi-file project, error handling

• type aliasing

• defining headers and cpp files

• Error handling using C++ exceptions

• More practice with functions and string handling

• More on using STL algorithms: iterators

• the while loop TODO

• do-while loop TODO

• More command-line handling: options

• conditional (ternary) operator (?:)

• using functions

• defining functions

• variable scope: global, block, function

• default arguments for functions

• function overloading

• references

• const for variables

• const for pass-by-reference

• references, const & auto in range-based for loops

• pass by value vs. pass by reference

• the inline keyword

• the function stack and recursion

  • relationship to scope

Week 2

Session 1: file IO

• terminal I/O
• file input/output
• introduce concept of RAII?
• relate to scope
• handling file paths
• introducing first project: DNA shotgun sequencing (?)
  • exercise: implement loading function for project

Session 2: split project files

• separate code into header and cpp files
• how to compile and link at the command-line
• explain C preprocessor in more detail
• automated build systems
  • Make, CMake, Ninja, ...
  • introduce our custom build script
• explain namespaces (in particular std)
  • what they are, no need for students to know how to define their own

---

Week 3

Session 1: Organising data

• grouping data using struct
• categoricals using enum
• classes
• member functions: mutators, accessors, facilitators
• constructors
• member initialisation
• destructors
• member function overloading

Session 2:

• inheritance
• virtual functions
• difference between virtual and overloaded functions
• static / dynamic binding
• pure virtual functions
• abstract and concrete classes

---

Week 4

Session 1:

Session 2:

---

Week 5

Session 1:

Session 2:

---

Week 6

Session 1: Object-oriented design

• aggregation, composition, inheritance
• object lifetime & ownership
• OOP design principles (SOLID):
  • DRY (Don’t repeat yourself)
  • Encapsulate What Changes
  • Open Closed Design Principle
  • Single Responsibility Principle
  • Dependency Injection or Inversion principle
  • Favor Composition over Inheritance
  • Liskoff substitution principle
  • Interface Segregation Principle
  • Programming for Interface not implementation
  • Delegation principles
• UML overview
• UML class diagrams
• typical workflow for the OOP design
  • blog abour OOP design process

Session 2:

• Peer marking
• go through solution and marking scheme
• ...?

---

Week 7

Session 1:

Session 2:

---

Week 8

Session 1:

Session 2:

---

Week 9

Session 1:

Session 2:

---

Week 10

Session 1:

Session 2:

---

Open questions:

• how use inheritance in a meaningful way without pointers?
  • should be fine using references instead
• how to demonstrate aggregation without pointers?
  • can demonstrate construction of member (const) reference
  • note that non-const references are not recommended in the C++ Core Guidelines
    • but only because this makes the class copy-constructable, but not copy-assignable
    • if anything, highlights issues of ownership and lifetime, which are a serious problem with aggregation
• how to teach design?
• how to assess design?

Not covered in course:

• new / delete
• memory leaks
• double free
• array new[] & delete[]
• using constructor / destructor / copy constructor / assignment operator to manage memory
• Why? See recommendations in this video:
  • Kate Gregory: Stop Teaching C
  • and these blog posts:
    • C++ Will No Longer Have Pointers
    • Raw Pointers Are Gone!
    • No New New: Raw Pointers Removed from C++
    • Deprecating Raw Pointers in C++20
    • No more pointers

---

Unsorted topics to be (or not) covered:

• difference between compiled and interpreted languages
• the preprocessor and directives
• the #include statement
• the compile & link process
• C vs. C++
• dynamic vs. static type checking
• namespaces - the std:: namespace
• namespaces - how to define & use your own
• single-line comments
• multi-line comments and why they're usually best avoided
• editing a file
• compiling a program
• using the command-line
• file path concepts (absolute, relative)
• shortcuts for special folders (., .. , ~)
• running a command - even when not in the PATH, or in the current folder
• debugging a program - using a debugger?
• anatomy of a command - arguments & options
• statements
• compound statements
• std::vector
• std::string
• std::array
• difference between std::vector::operator[] and std::vector::at() in terms of bounds checking
• checking for errors
• throwing exceptions
• handling exceptions
• standard arithmetic operators
• comparison operators
• logical operators
• operator precedence
• standard data types
• expressions with mixed types, implicit type casting, integer promotion, ...
• const for variables
• const for pass-by-reference
• const for member methods
• the <cmath> header and associated functions
• list initialisers
• control flow
• if statement
• nested if statements
• regular for loop
• range-based for loop
• while loop
• do-while loop
• switch statement
• jump statements: break and continue
• conditional (ternary) operator (?:)
• references
• using functions
• defining functions
• pass by value vs. pass by reference
• returning values from functions
• returning multiple values from functions using C++17 structured binding
• default arguments for functions
• function overloading
• variable scope: global, block, function
• spreading projects over multiple files
• multiple files: implications for compiling & linking
• function recursion
• the program stack
• inline functions
• struct
• enum
• file I/O
• OOP principles: encapsulation, polymorphism, inheritance, abstraction
• classes
• member functions: mutators, accessors, facilitators
• constructors
• member initialisation
• destructors
• static data members
• copy constructor
• virtual functions
• pure virtual functions
• abstract and concrete classes
• inheritance vs. composition
• member function overloading
• difference between virtual and overloaded functions
• static / dynamic binding
• OOP design - REQUIRES A LOT OF THOUGHT!
• UML
• composition / aggregation / inheritance
• operator overloading
• friend functions
• overloading the stream insertion operator
• operator overloading: global or member?
• this pointer
• overloading the assignment operator
• function templates
• class templates
• runtime vs. compile-time/static polymorphism
• RAII
• object lifetime & ownership
  • relationship to composition & aggregation, etc.
• class vs. object vs. instance
• OOP design principles (SOLID):
  • DRY (Don’t repeat yourself)
  • Encapsulate What Changes
  • Open Closed Design Principle
  • Single Responsibility Principle
  • Dependency Injection or Inversion principle
  • Favor Composition over Inheritance
  • Liskoff substitution principle
  • Interface Segregation Principle
  • Programming for Interface not implementation
  • Delegation principles
• blog abour OOP design process
  • how to teach design?
  • how to assess design?