CS 232: Programming Concepts and Methodology II

• Write programs that use each of the following data structures: arrays, records, strings, linked lists, stacks, queues, and hash tables.
• Implement, test, and debug simple recursive functions and procedures.
• Evaluate tradeoffs in lifetime management (reference counting vs. garbage collection).
• Explain how abstraction mechanisms support the creation of reusable software components.
• Design, implement, test, and debug simple programs in an object-oriented programming language.
• Compare and contrast object-oriented analysis and design with structured analysis and design.

1. Programming Fundamentals (PF)
2. Fundamental data structures
   1. Primitive types
   2. Arrays
   3. Records
   4. Strings and string processing
   5. Data representation in memory
   6. Static, stack, and heap allocation
   7. Runtime storage management
   8. Pointers and references
   9. Linked structures
   10. Implementation strategies for stacks, queues, and hash tables
   11. Implementation strategies for trees and graphs
   12. Strategies for choosing the right data structure
3. Recursion
   1. The concept of recursion
   2. Recursive mathematical functions
   3. Simple recursive procedures
   4. Divide-and-conquer strategies
   5. Recursive backtracking
   6. Implementation of recursion
4. Programming Languages (PL)
5. Declarations and types
   1. The conception of types as a set of values together with a set of operations
   2. Declaration models (binding, visibility, scope, and lifetime)
   3. Overview of type-checking
   4. Garbage collection versus Automatic Resource Counting
6. Abstraction Mechanisms
   1. Procedures, functions, and iterators as abstraction mechanisms
   2. Parameterization mechanisms (reference vs. value)
   3. Activation records and storage management
   4. Type parameters and parameterized types - templates or generics
   5. Modules in programming languages
7. Object-oriented programming
   1. Object-oriented design
   2. Encapsulation and information-hiding
   3. Separation of behavior and implementation
   4. Classes and subclasses
   5. Inheritance (overriding, dynamic dispatch)
   6. Polymorphism (subtype polymorphism vs. inheritance)
   7. Class hierarchies
   8. Collection classes and iteration protocols
   9. Internal representations of objects and method tables
8. Software Engineering (SE)
9. Software design
   1. Fundamental design concepts and principles
   2. Design strategy

Students will be assigned lab work for each category below.

1. Object Based Programming
2. Object Oriented Programming
3. Polymorphism
4. Inheritance