Catalog Description:

The second course in computing, intended for majors and minors. Emphasis is on exploring encapsulation; polymorphism; composition; inheritance; finite state machines; linear data structures [including array lists, linked lists, stacks, queues, and the tradeoffs in implementation]; and recursion [including recursive linked lists] in the context of the software development lifecycle including the processes and practices for designing, implementing, and testing high quality software.

Contact Hours:

• Lecture: 3 hours

Prerequisites: CSC 116 with a grade of C or better
Co-requisites: CSC 217
Restrictions: None
Coordinator: Dr. Sarah Heckman
Textbook: ZyBooks for CSC 216, ZyBooks, 2021

Course Outcomes:

1. Describe the utility of inheritance, abstract classes, interfaces, and polymorphism in object-oriented systems, and design, implement, and test programs which use these language features;
2. Identify the phases of a simple model of the software life cycle, and employ these phases in developing software;
3. Describe basic design modeling techniques, including UML class diagrams and simple design patterns (e.g., model/view/controller), and indicate how and when to use them;
4. Identify and compare the basic kinds of software testing, describe when to use each method, and design and implement test code;
5. Navigate and extract information from the Java API, and employ the Javadoc tool to construct internal documentation of source code;
6. Use software engineering best practices like pair programming, test-driven development, code coverage, static analysis, version control, continuous integration, and documentation with supporting tooling to design, implement, and test object-oriented systems.
7. Design, implement, and test a finite state machine;
8. Identify when recursion is useful, and design, implement, and test recursive algorithms and simple recursive data structures;
9. Implement, test, and use a stack, queue, array-based list, and linked list.

Topics:

• Composition
• Software Testing & the Debugger
• Software Engineering Best Practices – Static Analysis, Code Coverage, Version Control
• Using Java Collections
• Inheritance and Polymorphism
• Abstract Classes and Interfaces
• Exceptions and Libraries
• Design and Patterns
• Software Lifecycle and Task Planning
• Finite State Machines
• State Pattern and Inner Classes
• Array Lists Implementation
• Generic Array Lists Implementation
• List Nodes
• Generic Linked Lists Implementation
• Complexity
• Stacks and Queues
• Iterators
• Recursion
• Recursive Lists Implementation
• GUI Views
• GUI Controllers
• Searching and Binary Search Trees
• Sorting