COP 3003
Programming II
Schedule
Orientation, Purpose, and Structure
About this course
Catalog Course Description
COP 3003 Object-Oriented Programming
Students will expand on their knowledge base and skills gained from introductory programming. Topics include, but are not limited to, modularity (classes and packages); object-oriented concepts (e.g., encapsulation, inheritance, and polymorphism); error handling and exceptions; generics/templates; dynamic constructs and memory management encompassing pointer arithmetic, parameter passing, and dereferencing; and reuse of API/frameworks/libraries/packages (e.g., GUI, networking, persistence storage, and web). Relevant programming environments and tools (e.g., build tools), especially in the context of software engineering are also experienced. This course is delivered in C++ unless noted otherwise.
Course Student Learning Outcomes (SLOs)
At the completion of the course, students will be able to:
Design and implement a class. [Usage]
Use subclassing to design simple class hierarchies that allow code to be reused for distinct subclasses. [Usage]
Correctly reason about control flow in a program using dynamic dispatch. [Usage]
Compare and contrast (1) the procedural/functional approach (defining a function for each operation with the function body providing a case for each data variant) and (2) the object-oriented approach (defining a class for each data variant with the class definition providing a method for each operation). Understand both as defining a matrix of operations and variants. [Assessment]
Explain the relationship between object-oriented inheritance (code-sharing and overriding) and subtyping (the idea of a subtype being usable in a context that expects the supertype). [Familiarity]
Use object-oriented encapsulation mechanisms such as interfaces and private members. [Usage]
Define and use iterators and other operations on aggregates, including operations that take functions as arguments. [Usage]
From ACM / IEEE Curriculum Guidelines for Undergraduate Degree Programs in Computer Science
General Schedule
4:30-5:00: Input. Review previous week, lecture "tell me" new concepts, class discussions
5:00-5:50: Processing. Lecture "show me" coding demonstration, project preview
5:50-6:00: Break
6-7: Output. Lab "let me do it" just-in-time programming assistance, project
7-7:15: Wrap Up. Concept reinforcement, look ahead
“Tell me and I forget, teach me and I may remember, involve me and I learn.”
― Benjamin Franklin
Design Influence
Course Overview / Student Expectations
Attend every class meeting.
Have a piece of paper and pen or pencil in front of you everyday.
Contact me for assistance / clarification.
Productively spend 2-3 hours on classwork outside of class (6-9 / week) for every hour in class (3 / week)
Workload / sample schedule for most weeks:
Before class
Discussion assignment (.5 - .75 hours)
Follow every link in the Resources section on the lesson page for the week, actively read page and / or watch video, take notes in OneNote (1 - 1.5 hours)
Read textbook chapter(s) indicated in the Readings section on the lesson page for the week (1-1.5 hours)
Complete Open EDG module from the lesson page on course web page (2-3 hours)
In class
Take notes, engage in discussions (.5 hours)
Complete Activity with classmates (1 hours)
Work on Tutorial or Project with classmates (.75 hours)
After class
Study for and take quiz (.5 - .75 hours)
Work on Tutorial or Project (1-1.5 hours)
If you cannot dedicate at least 6 hours outside of class on this course per week, do not expect to do very well.
If you are able to meet the requirements for assignments in less time, challenge yourself and go above and beyond. There will be varying levels of experience and ability in the class. Your goal should be improvement.
If you find that you need more than 9 hours per week outside of class to understand and complete assignments you probably need a different approach. Please speak to the professor and / or Academic Support Services.
There will be a cumulative final exam
Topics
From ACM / IEEE Computing Curricula 2020
PL-Programming Languages
A. Present the design and implementation of a class considering object-oriented encapsulation mechanisms (e.g., class hierarchies, interfaces, and private members).
B. Produce a brief report on the implementation of a basic algorithm considering control flow in a program using dynamic dispatch that avoids assigning to a mutable state (or considering reference equality) for two different languages.
C. Present the implementation of a useful function that takes and returns other functions considering variables and lexical scope in a program as well as functional encapsulation mechanisms.
D. Use iterators and other operations on aggregates (including operations that take functions as arguments) in two programming languages and present to a group of professionals some ways of selecting the most natural idioms for each language.
E. Contrast and present to peers (1) the procedural/functional approach (defining a function for each operation with the function body providing a case for each data variant) and (2) the object-oriented approach (defining a class for each data variant with the class definition providing a method for each operation).
F. Write event handlers for a web developer for use in reactive systems such as GUIs.
G. Demonstrate program pieces (such as functions, classes, methods) that use generic or compound types, including for collections to write programs.
H. Write a program for a client to process a representation of code that illustrates the incorporation of an interpreter, an expression optimizer, and a documentation generator.
I. Use type-error messages, memory leaks, and dangling-pointer to debug a program for an engineering firm.