CST 173 - Introduction to Programming

1. Demonstrate understanding of variables and data types.
   1. Distinguish between variable and constant data.
   2. Utilize basic data types and define issues related to mixing data types.
   3. Declare variables appropriately required for a given computing solution.
   4. Demonstrate assignment of data to variables.
2. Implement basic operations on data.
   1. Identify the arithmetic and relational operators.
   2. Describe the order of arithmetic operations.
   3. Use arithmetic operators in simple expressions to perform calculations.
   4. Recognize the use of relational operators in simple expressions to control program flow using selection and iteration.
   5. Implement user input and appropriate program output for given software problems.
3. Create simple algorithms using design tools.
   1. Decompose a software problem statement into main tasks and subtasks using top-down design and step-wise refinement.
   2. Define standard flowcharting symbols and associate each with programming construct.
   3. Document various algorithms using flowcharts or pseudocode.
   4. Apply appropriate design tools to depict a top-down software solution.
   5. Apply subprogram constructs to implement a software solution with multiple modules.
4. 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. Describe relational operators and use them to construct expressions to be utilized in selection and repetition control structures.
   4. Build selection statements with appropriate if/else constructs.
   5. Define the most appropriate use of loops.
   6. Apply a random number generator as part of an algorithm.
5. Develop and implement solutions to computing problems using elementary graphical programming tools.
   1. Build and debug a variety of programming solutions employing fundamental concepts, including user input and selection and repetition structures.
   2. Implement a subprogram construct to decompose program code into modules.
   3. Define types of subprograms and appropriate methods for communication between subprograms.
   4. Implement arrays to solve problems involving data structures and lists.
   5. Traverse arrays to access list data and apply it to working program solutions.
   6. Perform searching algorithms on arrays.
   7. Document programming solutions adequately.
   8. Test software solutions for compliance to specifications and requirements.
   9. Implement a working software solution for evaluation.
6. Demonstrate understanding of abstract data types and object oriented programming using pseudocode.
   1. Understand abstract data types, class definition and implementation, including access modifiers, and best practices.
   2. Define and implement abstract data types.
   3. Define class constructors demonstrating the concepts of polymorphism.
   4. Demonstrate the implementation of a class definition.
   5. Create accessro, mutator, and work methods within a class definition.
   6. Modify working examples of classes and their implementations.
   7. Create a UML diagram for a class.