CST 173 - Introduction to Programming

1. Demonstrate understanding of the Program Development Cycle.
   1. Demonstrate understanding of a problem with the goal of satisfying the needs of end users.
   2. Develop algorithms to solve a problem.
   3. Understand the difference between logic errors and syntax errors.
   4. Differentiate between high-level programming language and low-level machine language.
   5. Demonstrate the ability to debug program errors.
2. Demonstrate understanding of variables and data types.
   1. Distinguish between variable and constant data.
   2. Utilize basic data types in a program.
   3. Define issues related to mixing data types.
   4. Declare variables appropriately required for a given computing solution.
   5. Demonstrate assignment of data to variables.
   6. Assign, store, and retrieve string data.
   7. Manipulate string data using various operations.
   8. Develop solutions that include a mixture of string and numerical data.
3. Implement basic operations on data.
   1. Identify arithmetic and relational operators.
   2. Describe the order of arithmetic operations.
   3. Use arithmetic operators in simple expressions to perform calculations.
   4. Develop solutions that require user input.
   5. Develop solutions that incorporate appropriate program output.
4. Create simple algorithms.
   1. Decompose a software problem statement into main tasks and subtasks using top-down design and step-wise refinement.
   2. Document algorithms using flowcharts or pseudocode.
   3. Apply appropriate design tools to depict a top-down software solution.
   4. Apply subprogram constructs to implement a software solution with multiple modules.
5. Apply basic structuring concepts to build working programs.
   1. Utilize the basic computing model of input-process-output.
   2. Perform basic arithmetic operations on data including counting and accumulation.
   3. Use relational operators to control program flow using selection and iteration structures.
   4. Build selection and iteration structures.
   5. Demonstrate appropriate use of selection structures.
   6. Demonstrate appropriate use of iteration structures.
   7. Apply a random number generator as part of an algorithm.
   8. Read and process data from an external file.
6. Produce solutions to computing problems using programming tools.
   1. Build and debug a variety of programming solutions employing fundamental concepts, including user input and selection and repetition structures.
   2. Demonstrate understanding of developing modular programs.
   3. Define types of modules or functions.
   4. Demonstrate understanding of appropriate methods for communication between modules or functions.
   5. Demonstrate understanding of arrays.
   6. Develop solutions using arrays.
   7. Demonstrate understanding of data structures and lists.
   8. Develop solutions that traverse arrays or list data.
   9. Perform searching algorithms on arrays or list data.
   10. Demonstrate documentation of programming solutions.
   11. Test solutions for compliance to program specifications and requirements.
   12. Build programs with loop structures utilizing a loop control variable.
   13. Create nested selection structures and nested loop structures.
   14. Apply mainline flow logic and modularization techniques.
7. Demonstrate understanding of abstract data types associated with object-oriented programming.
   1. Understand abstract data types, class definition and implementation, including access modifiers and best practices.
   2. Develop solutions using abstract data types.
   3. Demonstrate the use of class constructors.
   4. Demonstrate the use of polymorphism in a solution.
   5. Demonstrate the implementation of a class definition.
   6. Create accessor, mutator, and work methods within a class definition.
   7. Modify working examples of classes and their implementations.
   8. Create a UML diagram for a class.