CST 183 - Principles of Computer Programming I

1. Apply basic computer programming and software engineering concepts.
   1. Define the history and attributes of chosen programming language and its relationship to other programming languages.
   2. Define the value and significance of high-level programming languages compared to past software development tools.
   3. Describe issues and challenges of building quality software.
   4. Define and apply the general software engineering life cycle including problem definition, design, constructing source code, compiling it, and executing object code.
2. 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 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.
   5. Deliver electronic files using online or magnetic disk storage.
   6. Create document files or screen captures to demonstrate program code or output.
3. Design software solutions for a variety of problems.
   1. Create a logic plan to map design of a software solution.
   2. Recognize basic flowcharting symbols.
   3. Graphically depict logic using flowcharting techniques.
   4. Read and interpret algorithms represented in pseudocode.
   5. Interpret requirements and specifications for a software problem to initiate accurate design of a computer program.
   6. Decompose a software problem statement into main tasks and subtasks using top-down design and step-wise refinement.
   7. Construct program code to implement program design specifications.
4. Produce working programs.   
   1. Define the history and attributes of the chosen programming language and its relationship to other programming languages.
   2. Contrast compiled versus interpreted code and define the behavior and value of a “virtual machine.”
   3. Describe the basic program format and structure of a program.
   4. Perform basic user input/output using simple dialog boxes.
   5. Define basic data types and variations in each data type family.
   6. Define issues with numerical data type conversions.
   7. Describe arithmetic operator precedence.
   8. Build and evaluate arithmetic expressions using a programming language.
   9. Define and utilize the Boolean data type for logical operations.
   10. Describe relational operators and use them to construct logical expressions.
   11. Describe logical operators (AND, OR, NOT) including their truth tables.
   12. Apply logical operators to construct compound logical expressions.
   13. Build selection statements with appropriate if/else/switch programming constructs.
   14. Define the most appropriate use of while, do/while, and for loops.
   15. Build repetition statements with looping constructs.
   16. Apply arrays for storing a variety of data and objects.
   17. Solve basic problems using two-dimensional arrays.
   18. Effectively construct loops for array processing.
   19. Apply string classes to perform a wide a variety of basic and advanced string manipulation.
5. Design modular programming solutions.
   1. Implement programming problem sub-tasks into user-defined functions.
   2. Effectively design and implement subprogram parameter input.
   3. Distinguish between subprogram return type options and build subprogram solutions to match requirements.
   4. Distinguish between global and local variables and define variable scope.
6. Implement programming applications that include graphical user interfaces.
   1. Design and implement programming solutions involving graphical user interface classes with labels, sliders, text boxes, text areas, and buttons.
   2. Design and implement programming solutions involving selection graphical user interface classes including drop-down lists, check boxes and radio buttons.
   3. Describe and compare various “listener” classes and methods for implementing event listeners.
   4. Construct correct event-handling methods for various user input requirements.
   5. Design graphical user interface layouts using basic layout managers.
   6. Design graphical user interface layouts using interface containers.
7. Implement programming applications that include specialized concepts in introductory computer science.
   1. Apply basic sorting algorithms and describe basic strategies utilized.
   2. Apply searching algorithms and compare and contrast their relative efficiencies.
   3. Practice various list processing algorithms for unordered and ordered lists.
8. Apply specialized programming features.
   1. Integrate exception-handling routines for various likely programming exceptions including number conversion, array processing, and file input/output.
   2. Apply basic dynamic memory allocation of objects and arrays.
   3. Describe general strategies for memory management and practice these to avoid memory leaks.
   4. Implement random number processing for simple games and simulations.
   5. Define simple concurrent programming concepts and apply basic features of multithreading in a programming solution.
   6. Display a graphic image within a user interface.
   7. Utilize basic file processing to input or output external data.
   8. Access text information from a web site URL.
   9. Build graphics including lines, shapes, color, and font management.
9. Apply object oriented programming concepts.
   1. Interpret specifications for classes that are part of the programming language.
   2. Utilize standard programming language classes and methods in working applications.
   3. Decompose problems into the interaction of a collection of objects.
   4. Recognize specific terminology related to object-oriented programming.
   5. Design an abstract data type from specifications.
   6. Build classes for objects including the correct variables and methods.
   7. Define “set” and “get” methods necessary for a class to protect private data members.
   8. Define and implement class constructors for user-defined classes.
   9. Implement user-defined methods with appropriate parameter passing.
   10. Define class inheritance and the behavior of the sub-class and super-class defined using inheritance.
   11. Define basic class inheritance as it relates to utilizing a programming language.
   12. Define class variables and distinguish between public, protected, and private member designation.
   13. Distinguish and apply method overriding and method overloading.
   14. Utilize class composition to integrate multiple classes into a software solution.
10. 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 working 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. Effectively create and import external code “packages” for storing and reusing classes.
    7. Develop systematic test plans, create test cases, and test data to verify program correctness.
    8. Execute tests and correct logic errors based on test results.
    9. Locate on-line resources for the chosen programming language.
    10. Build user-friendly computer programs for a variety of real-world problems.
    11. Design and build event-driven programming solutions.
    12. Deliver software solutions within given deadline requirements.
11. Utilize and build software solutions with a gaming emphasis
    1. Integrate a pseudo-random number generator into computing solutions.
    2. Build and manage user interactions/interfaces appropriate for a gaming scenario.
    3. Integrate drawing tools of a computer programming language to visualize game states and general game interactions.
    4. Create algorithms for simple decision-making required for games that plan “against the machine”.
    5. Build programming solutions for basic gaming mechanisms including dice throws, card draws, lottery numbers, etc.
    6. Create algorithms to effectively play a variety of simple games.