CST 283 - Principles of Computer Programming II

Credits: 4
Instructional Contact Hours: 4

1. Demonstrate computer literacy skills to successfully use software development environments.
   1. Utilize an integrated development environment to create a project workspace.
   2. Enter and edit program source code using a text editor.
   3. Manage multiple project, data, and source code files.
   4. Use a compiler to check program diagnostics and correct syntax errors.
2. Perform critical analysis to create working software solutions.
   1. Analyze alternative solutions to a given programming problem and select the best approach.
   2. Develop and implement a variety of testing strategies to verify correctness of programs.
   3. Diagnose and debug syntax, run-time, linker, and logic errors to create a working and correct software solution.
   4. Document program source code for clarity and readability using accepted documentation standards including comments, indentation, and other techniques.
   5. Integrate and re-use previously working program code into new software development.
   6. Develop systematic test plans, create test cases and test data to verify program correctness.
   7. Execute tests and correct logic errors based on test results.
   8. Build user-friendly computer programs for a variety of real-world problems.
3. Practice basic principles for software engineering and design.
   1. Describe a variety of simple design methods and techniques for computing algorithms.
   2. Define information hiding, its value, and how it is implemented using a programming language.
   3. Define fundamental software engineering principles including the software life cycle, software quality, and basic software testing methods.
   4. Define the value of software documentation and utilize basic documentation techniques including definition of preconditions and post-conditions.
   5. Describe methods to design generic and re-usable data structures and classes.
4. Implement abstract data types as basic custom classes.
   1. Define the concept and value of data abstraction.
   2. Define the abstraction levels for defining data including the abstract, implementation, and application levels.
   3. Describe basic classifications of abstract data type operations and distinguish between transformers and observers for a variety of data structures.
   4. Create and apply a basic class to implement and abstract data type.
   5. Describe the purpose and value of class constructors.
   6. Define “set” and “get” methods necessary for a class to protect private data members.
   7. Instantiate objects, and call their member functions, and apply objects to solve a basic software problem.
5. Model an object-oriented solution for a problem domain.
   1. Identify object attributes and behaviors and determine significant events that define a problem.
   2. Specify objects that exist within system boundaries and identify object relationships and interactions.
   3. Determine hierarchical relationships between objects and determine the need for inheritance to implement object oriented principles.
   4. Classify object relationships in terms of access, ownership, inheritance.
6. Design classes to implement object-oriented solutions.
   1. Use access specifiers in class creation.
   2. Create destructor member functions and define the necessity for destructors.
   3. Describe the necessity and implementation of copy constructors for various dynamically allocated classes.
   4. Pass objects to functions.
   5. Categorize accessor, mutator, and iterator member functions.
   6. Specify scope of objects, methods, and attributes.
   7. Describe different access specifiers for derived classes.
   8. Override base class functions in the derived class.
   9. Use virtual functions to implement polymorphism.
   10. Distinguish between assignment and initialization.
7. Apply various data structures to solve problems.
   1. Describe fundamental operations of a sequential list.
   2. Describe, analyze, and modify unsorted and sorted lists implemented with arrays.
   3. Implement array-based list searching using both linear search and binary search.
   4. Describe, analyze, and modify unsorted and sorted lists implemented with linked structures.
   5. Build general data nodes for use in various dynamic data structures.
   6. Apply an array-based list class to implement a software solution to a practical problem.
   7. Apply a linked list class to implement a software solution to a practical problem.
   8. Describe and trace linked list implementations using arrays.
   9. Describe variations of linked lists including circular and doubly linked lists.
   10. Describe the fundamental operations of a stack abstract data type including push and pop.
   11. Describe, analyze, and modify stack classes implemented with arrays.
   12. Describe, analyze, and modify stack classes implemented with linked structures.
   13. Apply a stack class to implement a practical software solution to a practical problem.
   14. Convert arithmetic expressions to and from infix notation, prefix notation, and postfix notation and convert arithmetic expression patterns using stacks.
   15. Describe the fundamental operations of a queue abstract data type including enqueue and dequeue.
   16. Describe, analyze, and modify queue classes implemented with arrays.
   17. Describe, analyze, and modify queue classes implemented with linked structures.
   18. Describe a basic queuing simulation using a random number generator.
   19. Apply a queue class to implement a practical software solution to a practical problem.
8. Apply tree data structures to solve problems.
   1. Define a tree data structure and differentiate from a common tree and a binary tree.
   2. Describe the fundamental operations of a binary search tree including special terminology related to tree data structures.
   3. Describe, analyze, and modify a binary search tree implemented using linked structures.
   4. Apply a queue class to implement a practical software solution to a practical problem.
   5. Define tree traversal patterns including preorder, inorder, and postorder traversals.
   6. Relate binary tree traversal patterns to creation and overall balance.
   7. Describe a binary expression tree and relate tree traversal patterns to arithmetic infix, prefix, and postfix notation.
   8. Define a heap data structure and its relationship to trees.
   9. Implement a heap using arrays and describe the algorithms for inserting and deleting data with heaps.
   10. Describe and analyze a heap implemented using linked structures.
   11. Apply a heap to class to implement a priority queue.
   12. Describe the purpose of hashing and the function of a hash function.
   13. Compare and contrast a hash table with a list and define attributes of a good hash function.
   14. Describe methods for managing data collisions for a hash table operation.
   15. Describe and trace a data structure build using hashing and chaining of linked lists.
   16. Define a graph data structure and represent the edge set and vertex set of a graph.
   17. Compare and contrast undirected graphs, directed graphs, and weighted graphs.
   18. Represent a graph data structure using an adjacency matrix.
   19. Describe the fundamental operations of a graph data structure.
   20. Define graph traversal patterns including depth-first and breadth-first search.
   21. Describe various problems for which graphs can be applied to represent data patterns.
9. Apply recursive programming to solve problems.
   1. Compare and contrast recursive and iterative algorithms.
   2. Define the value and appropriate uses of recursive programming.
   3. Create recursive algorithms including definition of the base case and general case for function returns.
   4. Trace recursive algorithms and define the behavior of computer algorithms running recursive algorithms.
   5. Implement a variety of algorithms using recursive approaches.
   6. Integrate recursive strategies into sorting algorithms as well as for processing various non-linear data structures.
10. Analyze algorithms for information manipulation from various data structures.
    1. Define the basic concept of algorithm efficiency including the definition of the order of magnitude (big-O) of an algorithm.
    2. Define the basic concept of algorithm efficiency including the definition of the order of magnitude (big-O) of an algorithm.
    3. Analyze and measure the efficiency difference between the linear search and binary
    4. Describe a high probability ordered search as an improvement to a linear search.
    5. Describe and trace basic O(N2) sorting algorithms including bubble sort, selection sort, and insertion sort.
    6. Describe and trace recursive O(Nlog2N) sorting algorithms including quicksort, mergesort, and heapsort.
    7. Recognize the big-O for a collection of sorting algorithms and define the best and worst in terms of efficiency.
    8. Measure numerous sorting algorithms for best and worst efficiency with a variety of list configurations.
11. Use constructs of a programming language to solve problems.
    1. Implement programs applications separated into multiple file modules.
    2. Evaluate bitwise operations including bitwise and, or, exclusive-or, shift, and compliment.
    3. Define implementations of data structures using bitwise operations.
    4. Utilize generic template classes for data type independence.
    5. Describe and utilize the boolean (bool) data type in a variety of algorithms including an array of boolean values.
    6. Define arrays, array indexing, and array processing using loops.
    7. Apply dynamic data allocation with appropriate use of keyword “new.”
    8. Define potential risks and errors that could occur using dynamic data allocation.
    9. Perform hexadecimal counting and required conversations to and from decimals.
    10. Explain exception handling and implement a basic exception handling programming construct.

12. Construct basic game application software.

1. Incorporate a pseudo-random number generator into computing solutions.
2. Utilize animation tools of a computer programming language for game motion.
3. Build and manage user interactions/interfaces appropriate for a gaming scenario, including a complete game as a course capstone project.
4. Create algorithms for decision-making required for games that plan “against the machine”.
5. Create algorithms to effectively play a variety of simple games in the context of object-oriented programming.
6. Integrate basic data structures in the context of games and user gaming decisions.