Course Overview I will briefly examine the overview (html) document and tour through various other documents on the course web site, mostly reachable from the left (tan) index on the fact sheet. I recommend that you continue to explore the course web site: look especially closely at the Syllabus document. We will look a bit at the details of all the testing instruments and how the final grade will be computed. I will explain that students who come to question the grading of their quizzes, programs, and exams set up a win-win situation. Either I did grade it wrong and you deserve more points (a win for you), or you will learn what was wrong with a solution that you thought was correct (another win for you). I will distribute my "Academic Integrity Contract" on Monday, which we will discuss on Wednesday. You should carefully read this document and sign and return it on FRIDAY. Every year there are Academic Integrity violations in my classes, so I want to clearly describe my policy on this topic; I hope that you will take to heart this information. This contract is also available on the Handouts (General) link in the index on the fact sheet. Next we will talk about the three major goals for this class. The focus of ICS 46 is (abstract) data types, data structures that implement them, and analyzing the performance of these implementations: their time and space efficiency. There are many practical and theoretical issues related to these goals. 1) Demonstrate skill solving problems/programming with C++ template classes (from the ICS46 Template Library: ITL): specifically, understand the operations that we can perform on the (abstract) data types Stack, Queue, PriorityQueue, Set, Map, (and later Equivalence Class and Graph) and their iterators; and use combinations of these data types and their operations to solve complicated problems. We call these collections data TYPES or ABSTRACT data TYPES because they are characterized completely by their external behavior. E.g., in queues we know that if C++ executes q.enque("a"); followed by q.enqueue("b"); and q.enqueue("c"); then calling q.dequeue() will returrn "a" and leave only "b" (first) and "c" (last) in the queue, no matter how such a queue is actually implemented in C++ as a data strcuture (see 2 below): by an array, linked list, etc. Likewise, in stacks we know that if C++ executes s.push("a"); followed by s.push("b"); and s.push("c"); then calling s.pop() will returrn "c" and leave only "b" (at the top) and "a" (at the bottom) in the stack, no matter how such a stack is actually implemented in C++ by a data structure (see 2 below): by an array, linked list, etc. 2) Demonstrate skill at using low-level C++ data structures (primarily arrays and self-referential/linked data structures) to implement these data types correctly (how the information is represented and what algorithms process the information) and ensure that they run efficiently. There are many different data STRUCTURES that we can use to implement every data TYPE. E.g., there are various implementations of queues that use arrays and linked-list data structures, each correctly producing the required queue behavior. Each has different advantages and disadvantages over the other (see 3 below, for an important category of differences). I will provide slow implementations for all these data types, which use simple array data structures to implement their behavior. Using these simple implementations, we can write programs (with these data types, using their simple implementations) that execute correctly, if slowly. During the quarter we will discuss more interesting data structures and use them to re-implement these data types more efficiently. By substituting a faster implementation for a data type (using just a few edits in our code) our programs will produce the same results but run more quickly. Doing so works only if the complete data type is implemented by the data structure. For templated classes, we use the definition part of .hpp files to define concrete classes in C++ to specify how the operations on a data type are implemented using the data structure implementing it. 3) Understand big-O (and big-Omega and big-Theta) notation, and demonstrate the ability to use these notations to analyze the efficiency of data structures implementing data types, and understand the appropriate use and limits of these notations (and compare and contrast them to approaches thatr collect empirical data). Since all data structures that implement a data type have the same external behavior (a program using one should produce an equivalent result to a program using another), the primary "observable" differences among different implementations is how fast their operations execute (and to a lesser extent, how much memory they occupy). We will use mathematical and empirical approaches to study the efficiency of the algorithms that run on various data structures (concentrating on the operations of the data types they implement). In addition, in the pursuit of goals 1-2, we will gain experience using intermediate-level C++ programming ideas. Finally, time permitting, we will briefly tour the CLion Integrated Development Environment which will serve as the standard vehicle for programming in this course (although you can develop programs using any environment, the programs must compile/run correctly using Clang C++). I recommend that you install CLion on your computer and work on Programming Assignment #0 to familiarize yourself with its operation. You might try to adapt the code you wrote in ICS-45C to run under CLion. Quote for the Day: I am always doing that which I cannot do, in order that I may learn how to do it. - P. Picasso