| Course/Topic | Knowledge | Skills | ||||
|---|---|---|---|---|---|---|
| CS 101 (CS1) | Exposure | Familiarity | Mastery | Exposure | Familiarity | Mastery |
| Software Engineering | Software Life Cycle Documentation Walk Through Ethics |
Timing Debugging Reuse Standard Libraries Testing | Develop Test sets Unambiguous problem and design specification Standard Libraries | |||
| OS and Environment | Windows TCP/IP |
Commands File System | Retrieve files from other sites | Edit files Manipulate windows Send E-mail | Log onto computer system Copy files Traverse directory structure | |
| Imperative Programming | Pointers | Operator Precedence Iteration Conditional Statements Streams Reference and Value Parameters Structures Classes | Basic Data Types Variables Assignment | Time individual segments of a program. |
Implement a two-hundred or so line program given a problem specification and a detailed design Use a debugger to trace a program Read a 500 line C++ program | Pass arguments using the appropriate parameter style. Use appropriate control structures within a program. |
| Object-Oriented Programming | Polymorphism Templates Inheritance | ADT Overloading | Top-Down Design Computational complexity
| Recognize importance of paradigm Use existing classes Design an abstract data type with appropriate information hiding Add function to an existing class. Problem Solving and Analysis | ||
| Data Representation | Structures Objects File Processing | Arrays Strings | ||||
| CS 201 | Exposure | Familiarity | Mastery | Exposure | Familiarity | Mastery |
| Software Engineering | Spiral And Iterative Enhancement Development Processes Requirements Specification Large System Design Recovery Maintenance Costs | Good Programming Practices Object Oriented Design Separate Compilation Debugging Representation Of Elementary Types Simple Test Coverage Metrics Configuration Management |
Information Hiding Software Reuse Via Existing Classes Use Of Class Libraries |
Working From Requirements Specifications. Working With Large Systems Development Of Suitable Processes
|
Small System Design Implementation Of Simple Designs Developing Source Code With Good Style Developing Test Cases |
Identification Of Design Decisions Use Of Existing Classes Retrieval Of Existing Classes |
| OS and Environment | Linkage Editor Design Recovery Tool |
Debugging Tool Profiling Tool Source-Code Control Tool Representation Of Basic Types And Instructions |
Interpret Binary Representations Of Simple Types And Instructions Recovering Existing Designs
|
Locating Simple Errors Measuring Statement Coverage | ||
| Imperative Programming | Pointers Simple Data Structures - Lists, Queues, Binary Trees |
Operator Precedence All Iteration Mechanisms Conditional Statements Streams Reference and Value Parameters Structures | Implement Algorithms Associated With Simple Data Structures.
| Implementation Of Simple Sequential Algorithms Requiring Up To 1,000 Lines Of Source Code. | ||
| Object-Oriented Programming | Multiple Inheritance. Private inheritance. Static members. Implementation of virtual function calls. Initialization lists for derived classes. Class member pointers. Declaration of pre- and post- Increment and decrement operators. References as class members.
| Single inheritance. Virtual functions. Copy constructors and assignment operators. Memory allocation and memory leaks. Matching rules for calls to overloaded functions. References as function return types. Compiler generation of implicit calls to constructors and destructors. |
Classes, objects, and members. Access rules for private and protected members. Operators as member functions and friends. Constructors and destructors. Templates. Promotion by constructors. The standard IO library. References as function parameter. | In existing code, recognize the use of multiple inheritance,
private inheritance, static members, class member pointers, initialization
lists, and references as class members.
| Design a hierarchy of classes. Derive a new class from an existing class. Provide and redefine virtual functions where needed. Implement correct copy constructors and assignment operators for classes which dynamically allocate memory. Determine which of a set of overloaded functions will be invoked for a given function call. Design and implement member functions which return references. Determine when a compiler will generate a destructor call for an automatic or file-scope variable. | Design a simple class with the
necessary constructors, destructors, member functions, and friends. Design a template for a simple container class. Use insertion operators, extraction operators, and manipulators with various istream and ostream objects. Design constructors as necessary to perform promotions that will be needed for a given class. Pass parameters by reference in appropriate circumstances. |
| CS 340 | Exposure | Familiarity | Mastery | Exposure | Familiarity | Mastery |
| Software Engineering | Formal specifications. Formal verification. Symbolic execution. Mutation analysis. | Evolutionary prototyping. Throw away prototyping. Structured analysis. Structured design. Jackson structured development. Component based software reuse and systematic reuse. Reuse libraries not based on classes. Project cost estimation. Project scheduling. Project management. Formal inspections. Static analysis. Test case development. Test automation. Design recovery. | Spiral-model process development. Risk assessment and management. Natural language requirements specifications. Design for reusability and portability. Programming techniques supporting high quality, maintainable software. | Recognize the significance of formal specifications. Understand when to appeal to formal verification.
| Apply simple COCOMO model. Develop dataflow diagrams. Model systems using dataflow as part of requirements capture. Apply prototyping to requirements capture. Conduct effective inspections. Develop test cases based on functional, statement and branch coverage. Appreciate the limitations of traditional testing. Apply static analysis tools and interpret the resulting analyses. Apply simple design recovery tools and techniques. Comprehend the design of a medium-sized (up to 10,000 lines) existing system. |
Develop specifications in structured English. Develop small-group schedules and spiral processes. Develop reusable, portable implementations of medium-sized systems. |
| OS and Environment | Structured analysis support tools. Context sensitive editors. Application generators. Configuration management systems. Software analysis tools. | Unix-like software tools. | Apply modern CASE tools. | Create Make files. Manage files using RCS. Develop efficient shell scripts. | ||