Lab Courses - CS201
Software Development Methods
|
|
Knowledge
|
Skills
|
| Software Engineering |
- Mastery
- Information Hiding
- Software Reuse Via Existing Classes
- Use Of Class Libraries
- Familiarity
- Good Programming Practices
- Object-Oriented Design
- Separate Compilation
- Debugging
- Representation Of Elementary Types
- Simple Test Coverage Metrics
- Configuration Management
- Exposure
- Spiral And Iterative Enhancement Development Processes
- Requirements Specification
- Large System Design Recovery
- Maintenance Costs
|
- Mastery
- Identification Of Design Decisions
- Use Of Existing Classes
- Retrieval Of Existing Classes
- Familiarity
- Small System Design
- Implementation Of Simple Designs
- Developing Source Code With Good Style
- Developing Test Cases
- Exposure
- Working From Requirements Specifications.
- Working With Large Systems
- Development Of Suitable Processes
|
| OS and Environment |
- Familiarity
- Debugging Tool
- Profiling Tool
- Source-Code Control Tool
- Representation Of Basic Types And Instructions
- Exposure
- Linkage Editor
- Design Recovery Tool
|
- Familiarity
- Locating Simple Errors
- Measuring Statement Coverage
- Exposure
- Interpret Binary Representations Of Simple Types And Instructions
- Recovering Existing Designs
|
| Imperative Programming |
- Mastery
- Operator Precedence
- All Iteration Mechanisms
- Conditional Statements
- Streams
- Reference and Value Parameters
- Structures
- Familiarity
- Pointers
- Simple Data Structures - Lists, Queues, Binary Trees
|
- Mastery
- Implementation Of Simple Sequential Algorithms Requiring Up To 1,000 Lines Of Source Code.
- Familiarity
- Implement Algorithms Associated With Simple Data Structures.
|
| Object-Oriented Programming |
- Mastery
- 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.
- Familiarity
- 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.
- Exposure
- 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 an decrement operators.
- References as class members.
|
- Mastery
- 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.
- Familiarity
- 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.
- Exposure
- In existing code, recognize the use of multiple inheritance, private inheritance, static members, class member pointers, initialization lists, and references as class members.
|
