Course Outline: PA, Carnegie Mellon University

By: Higher Education

Abstract: 15-127: Introduction to Programming and Computer Science

Carnegie - Mellon

Syllabus for 15-127
Introduction to Programming and Computer Science
Spring 1997: Sections C-F

Basic Information

  • Classroom WeH 5419B
  • Meeting Times MWF: C (10:30-11:20), D (11:30-12:20), E (12:30-1:20), F (1:30-2:20)
  • Instructor Richard Pattis
  • Office Location WeH 3115
  • Phone 268-8342
  • Office Hours MWF 9:00-10:00; MW 2:30-4:30, TuTh By Appointment
  • Lab Hours M 7:00pm-9:00pm in WeH 5419 A/B
  • E-mail pattis@cs.cmu.edu
  • Web Page www.cs.cmu.edu

Catalog Description

Introduction to problem solving and programming in C++. The course is taught with an emphasis on programming methodology and style: problem analysis, program structure, algorithm analysis, data abstractions, and dynamic data. Credit is by mastery examination.

Course Description

My goal in 15-127 is for students to learn the general principles of programming: how to specify, design, code, document, test, debug, evaluate, and maintain computer programs. To make these principles concrete, we will explore them by studying and using the C++ programming language. The content of 15-127 can be neatly divided into three main subject areas: Algorithmics, Abstraction, and Analysis (the triple-As):

  • Algorithmics data types, literals, variables, expressions, and control structures
  • Abstraction constants, compound/dynamic data types, (recursive) functions, classes,
    inheritance, exceptions, and templates
  • Analysis pragmatics, style, correctness, efficiency, and numerical accuracy

This course emphasizes Object Oriented Programming (OOP). The foundational unit of Object Oriented Programming is the class: a syntactic structure that describes and encapsulates the behavior (control structures) and state (data structures) of objects. We can view programs as collections of interacting objects. Early in the semester we will learn how to read the public interfaces of classes, and construct and use such objects in our programs; later, we will learn how to augment old classes and write new classes, and finally how to derive subclasses via inheritance. Classes provide an excellent context for exploring many aspects of programming.

The main programming methodology that we will learn and employ is iterative-enhancement, which decomposes a large project into a series of increasingly complex mini-projects (each is called a phase). Starting from a kernel, and writing a program for each of these phases in sequence, results in a solution to the original project. Each phase requires repeatedly specifying, designing, coding, documenting, testing, debugging, and evaluating the [mini]project; each phase produces a testable program that is a small extension of the capabilities of the previous phase. We will apply this same methodology when building software components (classes).

Although we will mostly study programming-in-the-small, we will concentrate on the technical and lingual issues of building large reliable programmed systems, which are constructed from components. I expect to cover the relevant C++ language features thoroughly (see Algorithmics and Abstraction), but we will also spend much time discussing the less concrete but ultimately more general and important aspects of programming (see Analysis). In particular, we will study and use tools for debugging, browsing, and profiling programs.

Finally, to become an expert in any discipline, we must master its terminology. Fluency with technical terms allows us to communicate and even to think more accurately and concisely. Therefore, the materials in this course will define, illustrate, and repeatedly use many important technical terms concerning programming. Take the time required to master them.

Any clod can have the facts, but having opinions is an art.
Charles McCabe (San Francisco Chronicle)

Course Assistants

I will assign a Course Assistant (CA: typically an upper-class CS major) to help with each of my sections. Each CA will be present during class, and collectively they will consult at various times in the Computer Lab (see Computer Labs) along with the CAs for a dozen other 15-127 sections. During their consulting hours, expect CAs to help you diagnose problems and guide you toward solutions. They are in the labs to help you learn how to program by answering your questions, but, do not expect them to write your programs for you. I will announce our CAs and their specific consulting hours during the second week of class.

Office Hours

I welcome students, individually or in small groups, to come by and talk with me during my posted office hours, or whenever I happen to be in my office. If you need to talk to me but cannot come by during my office hours, please call me so that we can arrange an alternative time to meet; or, maybe we even can resolve the entire issue over the telephone. Also, see Electronic Mail for an excellent way to ask short questions.

I will be glad to talk with you about 15-127, Computer Science, CMU, or whatever else you want to discuss. I especially encourage students who are having problems in the course to visit me immediately. The primary reason that students fail to thrive in 15-127 is that they fall behind in their work often because of what is initially a small misunderstanding; but, because of the cumulative nature of this course, even small misunderstandings can quickly grow into big ones. Getting help fast can critically affect your overall performance in 15-127: many times I've seen students start performing one grade level higher after getting help during my office hours.

Electronic Mail (E-Mail)

If you have a small question (one requiring little back-and-forth discussion), and cannot directly contact me or any of the CAs, please ask it by sending me e-mail. It has been my experience that the very act of writing a detailed description of a problem (detailed enough so that someone not physically present can understand it) often leads students to a solution for their problem. Frequently, before I even get to read my e-mail, I receive a second message saying, "Please ignore my earlier message, I solved the problem myself." The seeds of the solution are often sown in the act of carefully composing the first e-mail message.

When I am not in class teaching, I typically read and answer e-mail every few hours during the day. I normally will not answer e-mail sent to me after about 11:00pm until early the next morning. If you have problems late at night problems that the CAs cannot help you resolve please send me e-mail summarizing your problems and then go to work on something else.

Computing Platforms and Programming Environments

The computing platform for this course is Intel-based (Pentium) PCs running the Windows NT Operating System (OS): Windows NT is a more rugged version of Windows 95, but with the same Graphical User Interface (GUI). The programming environment that we will use is the Borland C++ Integrated Development Environment (IDE: including an editor, compiler, linker, debugger, class browser, profiler, help facility, etc).

Computer Labs

The required computing platforms and programming environments are available in the Introductory Computer Labs (ICLs), Wean Hall 5419 A/B. These rooms are used as classrooms during the day, and then are open for general use in the late afternoon, evening, and on weekends. In the past, the hours for the ICLs have been M-Th 4:30pm-12:30am; F 4:30pm-10:30pm; Sa 10:00am-10:00pm; Su 10:00am-12:00am. The exact schedule for this semester will be posted soon on the doors outside these rooms.

The same computing platforms and programming environments should also be available at all other CMU clusters running Windows NT: WeH 5217, Cyert 100, and Baker 104F. Although these labs have the advantage of being open 24 hours/day, only WeH 5419 is staffed by 15-127 CAs, so the ICLs are still the best place to work if you expect that you will need help.

Finally, students with the appropriate hardware and OS (Windows NT or Windows 95) can also purchase copies of Borland C++ 5.0 in CMU's Computer Store (628-2636), for their personal use. The cost is $115. To complete their coursework, such students will need to learn how to interface to a special file server for the introductory group, typically to download/upload files.

Textbook

The textbook for this course is, Deitel and Deitel, C++: How to Program, Prentice-Hall. Although most of the readings will come from course notes that I will distribute on-line, this book provides a good introduction to programming in general; it is also a good reference to the C++ language (which is used in many CS courses, research projects, and in industry).

Diskettes

Purchase one package of ten High-Density diskettes. Bring at least one blank diskette (or one with plenty of space) to each class. You will use these diskettes for archiving your coursework.

Course Management

Class Schedule

On most days, the 50 minute class will comprise 30-35 minutes of lecture/discussion followed by a 15-20 minute (ungraded) mini-lab. The mini-lab will focus on that day's lecture material: it will allow you a hands-on experience to learn the material, or just explore it further. During these mini-labs, the CA and I will circulate around the class to answer questions. On most Mondays, I will give a quiz instead of a mini-lab (see Quizzes). On some Mondays I will give a Midterm for the entire 50 minute class (see Midterms).

Class Format

I hope to conduct my lectures in an open manner: not just broadcasting information but discussing and explaining it. Our setting a small computer lab was designed to facilitate exactly this kind of classroom interaction. So, I encourage you to participate by raising your hand. If you have a question about the material, it typically means that I have explained something poorly or incompletely, and that other students have (or will soon have maybe right after they leave the classroom) the same question. So, it would be best for all of us to correct the problem immediately in class by someone bringing it to my attention. In this regard, our class motto concerning questions is, The only stupid question is the one left unasked.

Lecture Readings

I will produce a detailed set of lecture notes (in PowerPoint). I will distribute all these notes on-line, a day or two before each lecture. This approach will free you from taking extensive notes in class, although you may want to copy my notes and annotate them (physically or electronically) with information that you glean in class. Please read these notes before class, so that you will be better prepared to discuss the material I present, and ask questions about it.

Legend: = reading = mini-lab = test (quiz or midterm) program assigned program due

Monday
Wednesday
Friday
Week 1 (1) 1/13: Course Overview syllabus.doc, overview.ppt
(2) 1/15:Windows NT & BC++ IDE os+ide.ppt

Exploring Files/Projects/C++ IDE

#1: NT OS & BC++ IDE

(3) 1/17: EBNF

EBNF handout, debugger.doc

Monitoring Programs

Week 2(4) 1/20: C++ Programs: An Overview

programs.ppt

Quiz 1

(5) 1/24: Expressions I

expression I.ppt, profiler.doc

Profiling Programs

#2: BC++: Debugger & Profiler

#1

(6) 1/26: Expressions II

expression II.ppt

Exploring Expressions

Week 3(7) 1/27: Statements I

statement I.ppt

Quiz 2

(8) 1/29: Statements II

statement II.ppt

Exploring Statements

#3: Suite of Simple Programs

#2

(9) 1/31: Programs & Libraries

library.ppt

Writing Programs using Libraries

Week 4(10) 2/3: Classes I

class I.ppt

Quiz 3

(11) 2/5: Classes II (including templates)

class II.ppt

Exploring Classes

#4: Suite of Programs Using Classes

#3

(12) 2/7: Advanced Statements

statements III.ppt

Exploring switch, loops, exceptions

Week 5(13) 2/10: Test

Midterm

(14) 2/12: Writing Programs I

programming I.ppt

Writing a Kernel with Stubs

#5: A Large Program

#4

(15) 2/14: Writing Programs II

programming II.ppt

Writing a Kernel for Program #5

Week 6(16) 2/17: Writing Functions I

function I.ppt

Quiz 4

(17) 2/19: Writing Functions II

function II.ppt

Exploring Functions

#6: A Program with Functions

#5

(18) 2/21: Writing Classes

class III.ppt

Writing Class Member Functions

Week 7(19) 2/24: structs (vs classes)

Quiz 5

(20) 2/26: Arrays I

arrays I.ppt

Array Traversal

#7: Writing a Class & Its Driver

#6

(21) 2/28: Arrays II

arrays II.ppt

Array Construction & Mutation

Week 83/3: No Class (Mid-semester Break) (22) 3/5: Arrays III

arrays III.ppt

Exploring Arrays of structs/objects

#8: A Program with Arrays

#7

(23) 3/7: Arrays IV

arrays IV.ppt

Exploring the vector/string Classes

Week 9(24) 3/10: Advanced Arrays & Debugging

debugger.ppt

Quiz 6

(25) 3/12: Keyboard/Screen/File I/O

ksfio.ppt

Exploring I/O

#9 C/D Mastery Practice

#8

(26) 3/14: ADT: Abstract Classes

adt.ppt

Exploring Stacks/Queues

Week 10(27) 3/17: Test

Midterm 2

(28) 3/19: Deriving Stacks

stack.ppt

Modifying the Stack ADT

#10 A Program using ADTs

#9

(29) 3/21: Deriving [Priority] Queues

queue.ppt

Modifying the Queue ADT

Week 113/24: No Class (Spring Vacation)


3/26: No Class (Spring Vacation) 3/28: No Class (Spring Vacation)
Week 12(30) 3/31: Analysis of Algorithms I

aa I.ppt

Quiz 7

(31) 4/2: Analysis of Algorithms II

aa II.ppt

  • Measuring/Predicting Speeds of

Executing Programs

(32) 4/4: Pointers

pointer.ppt

Exploring Pointers

Week 13(33) 4/7: Pointers to (dynamic) Arrays

dynamic array.ppt

Quiz 8

(34) 4/9: Linked Lists I

linked list I.ppt

List Traversal

#11 Suite of Linked List Functions

#10

4/11: No Class (Spring Carnival)
Week 14(35) 4/14: Linked Lists II

linked list II.ppt

Quiz 9

(36) 4/16: Linked Lists III

linked list III.ppt

List Construction & Mutation

#12 An ADT with Linked Lists

#11

(37) 4/18: ADTs with Linked Lists

adt+ll.ppt

Reimplementing the Queue ADT

Week 15(38) 4/21: Recursion Basics

recursion I.ppt

Recursive Functions for Integers

(39) 4/23: Recursion on Linked Lists

recursion II.ppt

Recursive Functions for LL

#13 B Mastery Practice

#12

(40) 4/25: Mastery Review I: Levels CD

C&D Mastery Problems

Week 16(41) 4/28: Test

Midterm 3

(42) 4/30: Mastery Review II : Level B

B Mastery Problems

#13

(43) 5/2: Mastery Review III : Level A

A Mastery Problems

Quotes (to get us started thinking about programming)

Computer Science is the first engineering discipline in which the complexity of the objects created is limited solely by the skill of the creator, and not by the strength of raw materials.
                  B. Reid

A programming language is a system of notation for describing computations. A useful programming language must therefore be suited for both description (i.e., for human writers and readers of programs) and for computation (i.e., for efficient implementation on computers). But human beings and computers are so different that it is difficult to find notational devices that are well suited to the capabilities of both.
                  R. Tennant (Principles of Programming Languages, Prentice Hall, 1981)

Habitability is the characteristic of source code that enables programmers coming to the code later in its life to understand its construction and intentions and to change it comfortably and confidently...Software needs to be habitable because it always has to change...Programs are written and maintained, bugs are fixed, features are added, performance is tuned, and a whole variety of changes are made both by the original and new programming team members... What is important is that it be easy for programmers to come up to speed with the code, to be able to navigate through it effectively, to be able to understand what changes to make, and to be able to make them safely and correctly.
                    R Gabriel (Patterns of Software, Oxford Press 1996)

It goes against the grain of modern education to teach students to program. What fun is there to making plans, acquiring discipline, organizing thoughts, devoting attention to detail, and learning to be self critical.
                    A. Perlis

Grading

Quizzes

I will give nine quizzes, to ensure that everyone is following the material and is able to express themselves in both English and C++. All quizzes are given on Mondays, replacing a mini-lab (so, each quiz is 15 minutes). Quizzes are cumulative, but emphasize the material discussed in the previous week. I will distribute a solution at 2:30 on the day that each quiz is given. For this reason, there are no make-ups for quizzes; but, I will drop your lowest quiz score.

Midterms

I will give three midterms. Midterms are cumulative, but emphasize the material covered in the previous four weeks. In format, each midterm will be like a long quiz, taking the entire 50 minute class period. Midterms are a bit more philosophical than quizzes: besides testing C++ skills, they will test a broader view of programming. I will distribute a solution at 2:30 on the day that each midterm is given. For this reason, there are no make-ups for midterms; unlike quizzes, all midterms count.

Programs

I will give thirteen programs. Generally, each will be assigned on a Wednesday and be due the following Wednesday. Some programming assignments may be longer, lasting up to 2 weeks. Also, some programming assignments will come directly from the Mastery Exam (see below), so that you will have a chance to preview the kinds of problems that it encompasses. I will distribute a solution at 2:30 on the day that each program is due (except for solutions to Mastery Exam problems, which I cannot distribute). The best time to study my solution is then, having just spent a week working on yours. For this reason, I will not accept any late programs. Partially working programs will receive partial credit: Half a program fully working is worth more than a full program not working. Finally, I will drop your lowest program score.

Later in the semester I will distribute a more detailed document on program submission and grading. For example, programs are graded both for correctness and style. The first few programs will be graded for both, but only the correctness grade will be entered. Once you become familiar with the grading criteria for style, both grades will count.

Coursework Grades

The following table illustrates how quiz, midterm, and program grades are combined into a coursework grade (see also Mastery Exam, Mastery Exam Grade, and Final Grade ).

InstrumentNumber Given Points/InstrumentPoints Total % of Grade
Quiz9 (-lowest) = 8 25 20025.0%
Midterm3100 30037.5%
Program13 (-lowest) = 12 2530037.5%
800 100.0%

Your coursework grade is computed according to the percentage of points that you accumulate during the semester A: 90-100%, B: 80-89%, C: 70-79%, D: 60-69%, and R (Fail): below 60%

I will maintain a spreadsheet with all up-to-date grades on-line. It will be publicly available, indexed by your student IDs. I expect you to examine this spreadsheet weekly. If I have incorrectly recorded any of your grades, see me as soon as possible, bringing your graded work with you to help resolve the discrepancy.

Mastery Exam

Mastery Exams provide a controlled environment in which you can demonstrate the problem solving and programming skills that you have acquired during this course. Each mastery exam is given during the exam period at the end of the semester, in our classroom, in one 4-hour sitting. A mastery exam requires you to write solutions to a random group of programming problems at different levels. Mastery Exams are given at the D, C, B, and A level. Besides file I/O, the material covered at each level is

  • D Level: simple operations on array/struct (non-dynamic) data structures
  • C Level: complicated operations (nested loops and conditionals) on simple data
  • B Level: operations on dynamic data structures (singly linked lists)
  • A Level: operations on novel dynamic data structures (array of pointers, list of lists)

All mastery exam problems there are about a dozen at each level are publicly available on-line. In fact, during the quarter we will solve some mastery problems as programming assignments. At the end of the quarter, we will also spend a few days reviewing the entire suite of mastery problems.

Mastery Exam Grades

All students are required to take a mastery exam to pass 15-127. First you must decide at what level you are taking the exam (see the matrix below). Then, when you arrive for the exam, you will be randomly assigned programming problems from the D level up to (and including) the level that you chose. If you correctly solve all these problems, your mastery exam grade will be the level that you chose. If you fail to solve any problem, your mastery exam grade will be the level before the first problem that you failed to solve (starting at the D level, working upward). So, if you attempt the B level mastery exam and pass problems at the D and B level, but fail the problem at the C level, your grade is D. If you fail at the D level, or if you do not show up for your assigned mastery exam, you fail the entire mastery exam, resulting in a final grade of R.

Final Grades

Your final grade is based on a combination of your coursework grade and your mastery exam grade. Final grades are computed according to the following matrix. Note some interesting properties of this matrix: an A in your coursework and a B on your Mastery yields a Final grade of A; also, a B in your coursework and an A on your Mastery yields a Final grade of A.

Mastery Grade
A
B
C
D
R
A
A
A
B
C
R
Coursework
B
A
B
B
D
R
Grade
C
B
B
C
D
R
D
C
C
C
D
R
R
D
D
D
R
R

Final Grades with Mastery Retake

Students are allowed to retake the mastery exam once, if they perform very poorly on it: their mastery exam grade is two letters lower than their coursework grade. In this case, a student can retake the mastery exam and the final grade is computed according to the following matrix. Note that in this case, the final grade can equal, but not exceed the coursework grade.

Mastery Retake Grade
A
B
C
D
R
A
A
B
B
C
R
Coursework
B
B
B
C
D
R
Grade
C
C
C
C
D
R
D
No retake allowed
R
No retake allowed

There are two ways to retake the mastery exam:

  • In this semester, find an available slot to (re)take the mastery exam at a later date.
  • In the following semester, see me during the first week of classes to discuss the details for
    signing up. Retakes are usually scheduled for the second or third week.

Generally retakes are not allowed after the retake period of the following semester.

Exceptions to the Rules

This document sets forth many strict policies that apply, by default, to all the students in this course. But, in the case of extraordinary circumstances, I reserve the right to bend these rules for individuals. If you feel you that are the victim of such circumstances, I encourage you to contact me, to discuss how I could bend the rules in your particular case.

Total Available Lectures: 43 Days - 3 Midterm Exams = 40

Title
Material
(In-Class Lab)
[Programming Assignment]

  1. Course Overview
    Review Syllabus; Software; OS/IDE Demo
    (none)
  2. Windows NT/Borland C++ IDE
    Windows NT (folders & files), Borland C++ IDE (projects)
    (Copy Project Template + File; Create Project with File; Compile/Correct/Link/Run)
    [Program 1: E-Mail; Compiling/Linking under Borland IDE + DropOff]
  3. EBNF
    Descriptions & Rules, Syntax & Semantics, Charts, Sets, Recursion
    (Using the Debugger)
  4. C++ Programs: An Overview
    Identifiers (Keywords); Delimiters; Types & Literals; Comments; Understanding Simple Programs
    (Quiz 1: NT, IDE, EBNF)
  5. Expressions I
    Variables/Initialization; Prototypes/Signature (overloading); Arithmetic, Logical, Character, and String operators
    (Using the Profiler)
    [Program 2: Debugger; Profiler]
  6. Expressions II
    Forming/Evaluating Expressions; Conversions (implicit Widening/Narrowing; explicit); Precedence; Pragmatics
    (Writing Programs that Test Expressions)
  7. Statements I
    Sequences, Assignment, Procedure Call, Input/Output (as Magic)
    (Quiz 2: Programs, Expressions)
  8. Statements II:
    If, Looping (loop/exit - macros for syntax enhancement)
    (Writing Programs that Test Loops)
    [Program 3: Suite of Simple Programs]
  9. Programs & Libraries
    Input/Process/Output; I/O Libraries
    (Writing Programs that Test I/O Libraries)
  10. Classes I
    Reading classes; Enumerations; Object creation; Member access; Protection)
    (Quiz 3: Statements + I/O Library)
  11. Classes II
    Pre/Post; Protection; Templated Classes; More Examples
    (Writing Programs that Test Classes)
    [Program 4: Suite of Programs that Use Classes]
  12. Advanced Statements
    Switch, Looping, try (exceptions)
    (Writing Programs with Swtich, Loops, and Exceptions)
  13. Midterm #1
    Algorithmics + Classes
  14. Writing Programs I
    Iterative-Enhancement; An Example
    (Writing the Kernel)
    [Program 5: A Large Program]
  15. Writing Programs II
    4 Principles of Style
    (Writing a Kernel for Program 5)
  16. Writing Functions I
    Parameter modes; Return; Tracing; Scope
    (Quiz 4: Writing Programs)
  17. Writing Functions II
    Nested Functions; More Examples;
    [Program 6: Structural Decomposition of Programs]
  18. Writing Classes
    Member functions; Scope; Public and Private
    (Augmenting a Class)
  19. Structs (vs. classes)
    struct as records; compared to classes (degenerate case; protection flipped)
    (Quiz 5: Functions)
  20. Arrays I
    Declaring, Accessing, Traversing (with for loops) Arrays; Searching
    (Writing Array Traversing Functions)
    [Program 7: Writing a Class and Its Driver]
  21. Arrays II
    Building and Mutating Arrays; Sorting (a templated function)
    (Writing Array Construction and Mutatation Functions)
  22. Arrays III
    Arrays of struct/Objects
    (Declaring Compound Data Structures and Functions that Process them)
    [Program 8: Writing a Program that Uses Arrays]
  23. Arrays IV
    char arrays (null terminated); string class; templated Vector class; 2-d Arrays
    (Writing Program that use Vector)
  24. Advanced Debugging
    Wrapup of Arrays
    (Quiz 6: Arrays)
  25. Keyboard/Screen/File I/O
    Reading Information from Files
    (Writing a Program that Reads an Array of Information From a File)
    [Program 9: C/D Mastery Practice]
  26. ADT
    Abstract (Pure Virtual) Templated Classes; Virtual Functions; Stacks, [Priority] Queues
    (??)
  27. Midterm II
    Abstraction: Functions + Data Structrures
  28. Deriving Stacks
    Array Implementations of Stacks
    (Exploring the Array Implementation of Stack)
    [Program 10: Writing a Program that Uses ADTs]
  29. Deriving [Prioritiy] Queues
    Array Implementations of [Priority] Queues
    (Exploring the Array Implementation of [Priority] Queues)
  30. Analysis of Algorithms
    Metrics, Terminology: Big O (etc), Complexity Classes
    (Quiz 7: ADTs)
  31. Analysis of Algorithms II
    Searching/Sorting; Measuring & Predicting Performance; Engineering considerations
    (Using Excel to Predice Sorting Performance)
  32. Pointers
    The notation of Dynamically Allocated Data; dereference syntax; new/delete
    (Hand Simulations)
  33. Pointers to Dynamic Arrays
    Reimplementing a Stack/Queue with Dynamic Arrays
    (Quiz 8: AA, Pointers)
  34. Linked Lists I
    Struct vs. Class; Diagraming; Traversal; -> syntax
    (Writing Functions to Traverse linked lists)
    [Program 11: Linked List Functions]
  35. Linked Lists II
    More Traversals
    (Quiz 9: Dynamic Arrays, Traversals of Linked Lists)
  36. Linked Lists III
    Construction; Mutatation
    (Writing Functions to Build and Mutate Linked Lists)
    [Program 12: Writing an ADT with Linked Lists]
  37. ADTs with Linked Lists I
    Reimplementing the Stack ADT
    (Reimplementing the Queue ADT)
  38. Recursion Basics
    Decomposing/Building Recursive Functions on Integers; Onions
    (Writing Recursive Functions)
  39. Recursion on Linked Lists
    Recursion on Recursively Defined Data
    (Recursive Linked List Functions)
    [Program 13: B Mastery Practice]
  40. Mastery Review: Levels C & D
  41. Midterm III
    Dynamic Data Structures, Recursion
  42. Mastery Review: Level B
  43. Mastery Review: Level A

Attending lectures is important, but you will not truly understand the material until you have used it in your programming assignments. Always be open to identifying a misconception or learning something new. From this struggle and introspection comes real knowledge about (and mastery of) programming.

Missing in Action: Frameworks/OOP Construction

CAs
10:30 Adam Megacz megacz+@andrew.cmu.edu

11:30 Bryan Meyer bmeyer+@andrew.cmu.edu

Work Schedule

Monday: Contact Preparation

Lecture/Give Exam
Give Quiz
Office Hours

Tuesday

Office Hours Lecture
(by appointment) Mini-Lab
Grade Quiz/Exam

Wednesday

Lecture
Mini-Lab
Distribute Program
Office Hours

Thursday

Office Hours Lecture
(by appointment) Mini-Lab
Grade Programs

Friday

Lecture
Mini-Lab
Office Hours

Weekend

Lecture
Quiz/Exam
Program+Writeup

Handouts

Directory Structure:

C-F
Lectures
Library (all of .h, .cpp, .lib)
Handouts/Documents
Quizzes, Midterms, Test
Programming Assignments & Solutions
Sample Programs

Standard IDE with additional speedbar entries

Grading Spread Sheet

Overview.ppt

OS+IDE.ppt

EBNF.ppt

Debugger.doc

Profiler.doc
Program #1
Retrieve, Edit, Submit Questionnaire
Retrieve Project, Run/Fix Program, Submit Project

Program #2
Retrieve Project, Debug Program, Submit Writeup
Retrieve Project, Profile Program, Submit Writeup

Programming Assignments:
Form
Hand-in
Grading

Code Style Sheet

Cheating

Handout <->Lecture: .doc or .ppt for things like using the debugger, profiler


Return to Course Information

Server Response from: ETNASC02