ICS 46 Spring 2022, Notes and Examples: Course Introduction

Course background and goals

This course is a deep dive into the implementation and analysis of data structures and their associated algorithms. While you will spend a fair amount of your time in this course working on writing implementations of them, you'll also learn how to analyze the big-picture decisions that lead to good implementations, as well as how to choose from among existing ones. We'll find that it quite often isn't possible to implement them well — no matter your level of programming skill — without making the right decisions up front, so we'll be sure that we understand how to think about things the right way and get the "big stuff" right before we try to delve into the finer-grained details.

Assessing your preparedness for the course

There are a few paths that lead to this course through our curriculum (or transfer curricula), but they all should leave you in (more or less) the same place with respect to how prepared you are for this course. I'll presume that you've programmed a fair amount before, roughly equivalent to what you would have seen in our first four quarters (ICS 31, 32, 33, and 45C). You should now be at the point where relatively simple programming problems — finding the maximum in a collection of integers, reading user input until it is valid, and things of that nature — are things you can complete fairly easily on your own, while hitting very few snags along the way. You should also be at the point where you can write code that solves a problem, given an abstract description of the problem, rather than just copying and pasting example code and trying to adapt it; being able to visualize a problem and its solution is core to what we'll be doing in this course.

Since ICS 45C — our course that introduces C++ programming at some depth — is a prerequisite for this course, I'll presume that you've previously learned C++, either as a first or a second (or later) language, roughly equivalent to what you would have learned in our ICS 45C course. It turns out that introductory C++ courses tend to vary from one offering to another, since C++ is a large and complex language, so a quick list of things I'm assuming you've seen follows.

Basic built-in data types, such as int, double, bool, and char
Basic expressions and operators
Control structures, such as if and switch statements, while and for loops
Header and source files, and separate compilation
Objects, references, pointers, and memory management
Stack and heap allocation
The const keyword and its uses (e.g., on variables, on parameters, within classes)
Built-in data structures, like arrays and std::vector
Iterators in the Standard C++ Library
Built-in algorithms, like std::find or std::for_each
Classes, inheritance, and polymorphism
Virtual functions, pure virtual functions, and abstract base classes
Making classes "well-behaved" (e.g., properly implementing constructors, destructors, and copy constructors, as well as avoiding them when unnecessary)

You might also have seen other C++ features that will be of use to us in this course, though I'll assume that you either haven't seen these, or that their coverage was light.

Function templates and class templates
Class design (e.g., contracts and invariants)
Exceptions and their effect on design, including the resource acquisition is initialization (RAII) pattern

If you've seen most of that, you'll be fine, though if you want to take a deeper look into any of those topics, either to brush up on them or because they're new to you, take a look through the Notes and Examples from my most recent ICS 45C offering, which includes a thorough treatment of all of these topics.

What is this course about?

Our focus in this course is twofold:

Learning how to recognize the tradeoffs inherent in selecting the right data structures and/or algorithms to solve a given problem. These tradeoffs aren't necessarily made on the basis of what's most comfortable, what's most familiar, or what requires the smallest amount of code (though that's one way to trade things off). We'll instead be considering which choice provides the fastest solution, the solution that uses the least memory, the solution that uses the least power, the solution that makes the best use of available hardware (e.g., one that parallizes the best, if we have many processors), and so on. And we don't just want to make these choices based on "feel"; we need to learn how to quantify them when we can.
Implementing data structures and/or algorithms that are not already familiar to you. It's likely that you've implemented something like a linked list before — that's something you'd have seen in prerequisite coursework here. But what about data structures that are more complex? That's one thing we'll do in this course. The goal is to help you to cultivate the skill of being able to understand an abstract problem, visualize a solution to it, and bring it to concrete reality. Developing techniques for making these things visible, for debugging code like this when it isn't working, and so on, is vital to being able to build all kinds of software — not just when you implement data structures — so this is a more universal skill set than you might first realize.

Along the way, we'll learn enough additional C++ to allow us to tackle problems that we might not easily be able to tackle otherwise. Periodically, we'll spend a little bit of time on "new" C++ features that you may not have seen before, but that support our work in this course; that's a fairly small percentage of what we'll do in the course.