CST 183 - Principles of Computer Programming ICredits: 4
Instructional Contact Hours: 4
Introduces programming abilities necessary for computer science. Includes control structures, subprograms, string handling, arrays, files, and the use of graphical user interface components. Emphasizes object-oriented programming concepts, and the use of classes. Introduces exception handling, drawing, and multithreading.
Prerequisite(s): Math Level 6; CST 173 , CST 180 , or instructor-approved computer programming experience.
Lecture Hours: 60 Lab Hours: 0
Meets MTA Requirement: None
Outcomes and Objectives
- Apply basic computer programming and software engineering concepts.
- Define the history and attributes of chosen programming language and its relationship to other programming languages.
- Define the value and significance of high-level programming languages compared to past software development tools.
- Describe issues and challenges of building quality software.
- Define and apply the general software engineering life cycle including problem definition, design, constructing source code, compiling it, and executing object code.
- Demonstrate computer literacy skills to successfully use software development environments.
- Utilize an integrated development environment to create a project workspace.
- Enter and edit source code using a text editor.
- Manage multiple project, data, and source code files.
- Use a compiler to check program diagnostics and correct syntax errors.
- Deliver electronic files using online or magnetic disk storage.
- Create document files or screen captures to demonstrate program code or output.
- Design software solutions for a variety of problems.
- Create a logic plan to map design of a software solution.
- Recognize basic flowcharting symbols.
- Graphically depict logic using flowcharting techniques.
- Read and interpret algorithms represented in pseudocode.
- Interpret requirements and specifications for a software problem to initiate accurate design of a computer program.
- Decompose a software problem statement into main tasks and subtasks using top-down design and step-wise refinement.
- Construct program code to implement program design specifications.
- Produce working programs.
- Define the history and attributes of the chosen programming language and its relationship to other programming languages.
- Contrast compiled versus interpreted code and define the behavior and value of a “virtual machine.”
- Describe the basic program format and structure of a program.
- Perform basic user input/output using simple dialog boxes.
- Define basic data types and variations in each data type family.
- Define issues with numerical data type conversions.
- Describe arithmetic operator precedence.
- Build and evaluate arithmetic expressions using a programming language.
- Define and utilize the Boolean data type for logical operations.
- Describe relational operators and use them to construct logical expressions.
- Describe logical operators (AND, OR, NOT) including their truth tables.
- Apply logical operators to construct compound logical expressions.
- Build selection statements with appropriate if/else/switch programming constructs.
- Define the most appropriate use of while, do/while, and for loops.
- Build repetition statements with looping constructs.
- Apply arrays for storing a variety of data and objects.
- Solve basic problems using two-dimensional arrays.
- Effectively construct loops for array processing.
- Apply string classes to perform a wide a variety of basic and advanced string manipulation.
- Design modular programming solutions.
- Implement programming problem sub-tasks into user-defined functions.
- Effectively design and implement subprogram parameter input.
- Distinguish between subprogram return type options and build subprogram solutions to match requirements.
- Distinguish between global and local variables and define variable scope.
- Implement programming applications that include graphical user interfaces.
- Design and implement programming solutions involving graphical user interface classes with labels, sliders, text boxes, text areas, and buttons.
- Design and implement programming solutions involving selection graphical user interface classes including drop-down lists, check boxes and radio buttons.
- Describe and compare various “listener” classes and methods for implementing event listeners.
- Construct correct event-handling methods for various user input requirements.
- Design graphical user interface layouts using basic layout managers.
- Design graphical user interface layouts using interface containers.
- Implement programming applications that include specialized concepts in introductory computer science.
- Apply basic sorting algorithms and describe basic strategies utilized.
- Apply searching algorithms and compare and contrast their relative efficiencies.
- Practice various list processing algorithms for unordered and ordered lists.
- Apply specialized programming features.
- Integrate exception-handling routines for various likely programming exceptions including number conversion, array processing, and file input/output.
- Apply basic dynamic memory allocation of objects and arrays.
- Describe general strategies for memory management and practice these to avoid memory leaks.
- Implement random number processing for simple games and simulations.
- Define simple concurrent programming concepts and apply basic features of multithreading in a programming solution.
- Display a graphic image within a user interface.
- Utilize basic file processing to input or output external data.
- Access text information from a web site URL.
- Build graphics including lines, shapes, color, and font management.
- Apply object oriented programming concepts.
- Interpret specifications for classes that are part of the programming language.
- Utilize standard programming language classes and methods in working applications.
- Decompose problems into the interaction of a collection of objects.
- Recognize specific terminology related to object-oriented programming.
- Design an abstract data type from specifications.
- Build classes for objects including the correct variables and methods.
- Define “set” and “get” methods necessary for a class to protect private data members.
- Define and implement class constructors for user-defined classes.
- Implement user-defined methods with appropriate parameter passing.
- Define class inheritance and the behavior of the sub-class and super-class defined using inheritance.
- Define basic class inheritance as it relates to utilizing a programming language.
- Define class variables and distinguish between public, protected, and private member designation.
- Distinguish and apply method overriding and method overloading.
- Utilize class composition to integrate multiple classes into a software solution.
- Perform critical analysis to create working software solutions.
- Analyze alternative solutions to a given programming problem and select the best approach.
- Develop and implement a variety of testing strategies to verify correctness of working programs.
- Diagnose and debug syntax, run-time, linker, and logic errors to create a working and correct software solution.
- Document program source code for clarity and readability using accepted documentation standards including comments, indentation, and other techniques.
- Integrate and re-use previously working program code into new software development.
- Effectively create and import external code “packages” for storing and reusing classes.
- Develop systematic test plans, create test cases, and test data to verify program correctness.
- Execute tests and correct logic errors based on test results.
- Locate on-line resources for the chosen programming language.
- Build user-friendly computer programs for a variety of real-world problems.
- Design and build event-driven programming solutions.
- Deliver software solutions within given deadline requirements.
- Utilize software solutions with a gaming emphasis
- Integrate a pseudo-random number generator into computing solutions.
- Manage user interactions/interfaces appropriate for a gaming scenario.
- Integrate drawing tools of a computer programming language to visualize game states and general game interactions.
- Build software solutions with a gaming emphasis
- Build and manage user interactions/interfaces appropriate for a gaming scenario.
- Create algorithms for simple decision-making required for games that plan “against the machine”.
- Build programming solutions for basic gaming mechanisms including dice throws, card draws, lottery numbers, etc.
- Create algorithms to effectively play a variety of simple games.
Add to Portfolio (opens a new window)