CS330 Outline

Overview

This module introduces you to the course organization, policies, and mechanics. We will review the structure of the course website.

We will take a brief look at the major themes and areas of emphasis that we will cover this semester. We will discuss (briefly) the basics of Python 3 with particular emphasis on how

• PEP 8
• PEP 20

apply to Object Oriented Programming Languages (e.g., C++, Python, Java, and Rust.

Objectives

At the conclusion of this Orientation Module students will be able to:

1. Explain the Syllabus.
2. Explain the importance of Office Hours.
3. Discuss why C++, Java, Python, and Rust will be covered.
4. Discuss the S.O. in S.O.L.I.D.

Overview

Many students start CS 330 with either a fuzzy or shaky foundation in the fundamentals as covered in CS 250/251 and CS 252. This module serves as an opportunity to revisit foundational skills and identify any questions that need to be addressed (i.e., discussed and answered) before moving on to new material.

Objectives

At the conclusion of this Orientation Module students will be able to:

1. Connect to the CS VPN.
2. Log in to the CS Linux servers.
3. Create a project in their preferred IDE (not Dev-C++).
4. Use buildfiles (make and/or Gradle).
5. Checkout the course example set GitHub Repository

Overview

This module covers the notion of ADTs from a design perspective. We motivate the notion of ADTs as a design principle, and move towards ADTs as a contract.

The latter part of this module discusses the implementation of ADTs using classes. This includes mechanics (e.g., Constructors, Destructors, accessors and mutators) and best practices (in the form of a checklist).

Objectives

At the end of this module students will be able to:

1. Discuss what belongs in a header (.h) file.
2. Discuss what belongs in an implementation (.cpp, .cxx, or .cc) file.
3. Describe the purpose of inline functions/methods.
4. Explain Resource Allocation is Initialization (RAII).
5. Describe the use of an inner class in the context of abstraction and encapsulation.
6. Summarize the justification for a formal class checklist.
7. Describe the emergent nature of a class checklist regardless of selected OOP Language.

Overview

This module covers the use of C++ iterators including using pointers, vector::iterators, and custom iterators. This includes definition of custom ADTs that provide iterators and analysis of the required interfaces.

Objectives

At the end of this module students will be able to:

1. Replace data structure specific code (e.g., arrays and linked lists) with iterator and container abstractions.
2. Describe how to leverage C++ templates to reduce repeated code, when implementing read-only (const) and read-and-write (non-const) iterators.
3. Discuss the motivations for memory pools.
4. Analyze the parallels between Java, Python, and Rust iterators.
5. Explain (and justify) the motivation for UML Class diagrams.

Overview

This module serves as an opportunity to review all materials, topics, and concepts covered thus far, before discussing:

• design and testing from the perspective of implementation

• the C++ class checklist and an analysis of its analogues in Java and Python 3

Objectives

After completing this module students will be able to:

1. Dissect the class checklist in the context of interface completeness.
2. Formulate class checklists for Java and Python 3–in general any language.

Overview

This module continues the discussion of design and UML. This includes modeling scenarios (partially and fully) through use cases, interaction diagrams, and sequence diagrams.

Objectives

After completing this module students will be able to:

1. Construct UML Class Diagrams to analyze existing code.
2. Leverage UML Class Diagrams to investigate and model a problem domain.
3. Explain and track data lifetimes.
4. Explain ownership.
5. Utilize UML Sequence Diagrams to model the logic of existing object-oriented code.
6. Construct UML Class Diagrams.
7. Validate UML Class Diagrams through use of UML Sequence Diagrams.
8. Leverage UML Class Diagrams to investigate and model a problem domain.
9. Leverage UML Sequence Diagrams to investigate and model a problem domain.

Overview

Note: the use of Midterm in this module refers to the point in the semester, not the Midterm Exam.

This module serves as an opportunity to review all materials, topics, and concepts covered thus, before moving on to inheritance, Java and Python.

Objectives

This module’s objectives are the set union of all previously listed module objectives.

Overview

This module covers…

• pointers and common memory management misteps, concerns and considerations.

• garbage collection and the associated challenges that must be considered when working with dynamic memory.

Objectives

After completing this module students will be able to:

1. Explain what a pointer stores.
2. Explain the difference between a pointer and a reference variable.
3. Analyze memory deallocation pitfulls.
4. Explain and track data lifetimes.
5. Explain why memory management can be a non-trivial problem.
6. Summarize the motivation behind smart pointers.
7. Explain ownership.
8. Summarize garbage collection.

Relevance

Programmers must be familiar with the issues surrounding memory management. This includes lanagues that allow low-level memory allocation (e.g., C/C++ and Rust), garbage collected languages (e.g., Java and Python).

The Rust language is a bit of a special case. Time permitting Rust lifetimes may be used as a brief case study.

Overview

This module discusses the notion of Inheritance in OOP. This includes an exploration subtyping as it relates to inheritance. We review the mechanic of function overriding, an mechanic analogous to function overloading.

The application of dynamic binding and the associated mechanics (e.g., virtual functions and pure virtual functions) are a focal point. Once we discuss these mechanics in one language, the transition to other languages (e.g., Python or Rust) is purely mechanical.

This module includes two case studies: the Spreadsheet Example and the Shapes Example.

Objectives

After completing this module students will be able to:

1. Explain the necessity of pointers for dynamic binding.
2. Explain the necessity of references for dynamic binding.
3. Implement the Big-3 (or Big-5) alongside an inheritance hierarchy.
4. Summarize the difference between overloading and overriding.
5. Summarize the difference between inheritance and subtyping.
6. Use raw pointers to allow dynamic binding.
7. Use C++14/C++17/C++20 smart pointers pointers to allow dynamic binding.
8. Use reference variables to allow dynamic binding.
9. Explain when = default and = delete can be used.
10. Discuss the Observer-Observable Pattern.
11. Discuss the Factory Model.

Overview

This module continues our language comparison discussions, with a focus on Java. This brief module covers three brief examples. This module serves as preparation for our OOP in Java discussions.

Objectives

After completing this module students will be able to:

1. Discuss the C++ and Java entries in the Cross Language Class Checklist.
2. Explain the Java Iterator Interface.
3. Explain the mechanical differences between C++ and Java iterators.
4. Discuss how to approach an unfamiliar language (e.g., Java, Python or Rust).
5. Map existing knowledge of object oriented C++ onto Java.

Overview

This module discusses the implementation of ADTs using Java classes. This Module complements (i.e., it is a companion to) the earlier OOP in C++ Module.

Objectives

After completing this module students will be able to:

1. Explain how Java object variables are conceptually pointers (albeit by a different name).
2. Implement the Java Big-not-quite-3 (i.e., clone) alongside an inheritance hierarchy.
3. Use Java Reference variables to allow dynamic binding.
4. Summarize the difference between inheritance and subtyping.
5. Discuss the Observer-Observable Pattern.
6. Discuss the Factory Pattern.
7. Explain how to implement equals, hashCode, toString, and (sometimes) iterator.
8. Define the concept of a Java package and compare it to a C++ namespace.
9. Apply the principles defined by S.O.L.I.D in Java.
10. Apply the D.R.Y principle in Java.
11. Summarize the difference between overloading and overriding.
12. Refactor ABCs into distinct interfaces.

Overview

This module discusses Graphical User Interfaces (GUIs) and threads in Java. We briefly cover the principles of multi-threading (parallelism) through the Runnable interface..

Objectives

After completing this module students will be able to:

1. Discuss the Java Swing classes required to build a GUI.
2. Identify the Java Swing classes that represent familiar elements (e.g., buttons, text fields, and text areas).
3. Write Java Listeners to handle user interaction.
4. Write Java Listeners as Immediate Classes.
5. Write Lambda functions to to replace Java Listeners.
6. Explain the differences between sequential and multi-threaded programs.
7. Explain the different ways to utilize multiple threads (e.g., ThreadPools).
8. Define syncronization and identify the mechanics involved.
9. Refactor code to follow either the MVC or M-VC patterns.

Overview

In this Module we will revisit concepts discussed through the semester, but in Python (and maybe Rust)!

Objectives

After completing this module students will be able to:

1. Analyze lazy evaluation in the context of Generators and Generator Expressions.
2. Refactor code to make use of context managers.
3. Discuss the Decorator Pattern.
4. Discuss the Builder Pattern.
5. Discuss Protocols vs. ABCs
6. Utilize properties and setters
7. Discuss Dependency Injection. Recomendation from Vanguard Dev
8. Discuss how to approach an somewhat unfamiliar language (e.g., Java, Python or Rust).
9. Map existing knowledge of object-oriented Java onto Python.

Overview

This is a pseudo-module. There is no new material (e.g., languages, paradigms or patterns) covered. This Module is an end-of-semester wrap up. We will revisit selected topics from throughout the semester.

We will introduce a few quick topics to explore with your new skills and knowledge.