SDF/Algorithms and Design
This unit builds the foundation for core concepts in the Algorithms & Complexity knowledge area, most notably in the Basic Analysis and Algorithmic Strategies units.
Core-Tier1 topics [11 hours]:
- The concept and properties of algorithms
- ----->Informal comparison of algorithm efficiency (e.g., operation counts)
- The role of algorithms in the problem-solving process
- Problem-solving strategies
- ----->Iterative and recursive mathematical functions
- ----->Iterative and recursive traversal of data structure
- ----->Divide-and-conquer strategies
- Implementation of algorithms
- Fundamental design concepts and principles
- ----->Program decomposition
- ----->Encapsulation and information hiding
- ----->Separation of behavior and implementation
- [k] Discuss the importance of algorithms in the problem-solving process.
- [k] Discuss how a problem may be solved by multiple algorithms, each with different properties.
- [a] Create algorithms for solving simple problems.
- [a] Use pseudocode or a programming language to implement, test, and debug algorithms for solving simple problems.
- [a] Implement, test, and debug simple recursive functions and procedures.
- [e] Determine when a recursive solution is appropriate for a problem.
- [a] Implement a divide-and-conquer algorithm for solving a problem.
- [a] Apply the techniques of decomposition to break a program into smaller pieces.
- [a] Identify the data components and behaviors of multiple abstract data types.
- [a] Implement a coherent abstract data type, with loose coupling between components and behaviors.
- [e] Identify the relative strengths and weaknesses among multiple designs or implementations for a problem.
This unit builds the foundation for core concepts in the Software Engineering knowledge area, most notably in the Software Design and Software Processes units.
Core-Tier1 topics [9 hours]:
- Program correctness
- The concept of a specification
- Defensive programming (e.g. secure coding, exception handling)
- Code reviews
- Testing fundamentals and test-case generation
- Test-driven development
- The role and the use of contracts, including pre- and post-conditions
- Unit testing
- Modern programming environments
- Programming using library components and their APIs
- Debugging strategies
- Documentation and program style
- [k] Explain why the creation of correct program components is important in the production of quality software.
- [a] Identify common coding errors that lead to insecure programs (e.g., buffer overflows, memory leaks, malicious code) and apply strategies for avoiding such errors.
- [a] Conduct a personal code review (focused on common coding errors) on a program component using a provided checklist.
- [a] Contribute to a small-team code review focused on component correctness.
- [k] Describe how a contract can be used to specify the behavior of a program component.
- [a] Create a unit test plan for a medium-size code segment.
- [a] Apply a variety of strategies to the testing and debugging of simple programs.
- [a] Construct, execute and debug programs using a modern IDE (e.g., Visual Studio or Eclipse) and associated tools such as unit testing tools and visual debuggers.
- [a] Construct and debug programs using the standard libraries available with a chosen programming language.
- [a] Apply consistent documentation and program style standards that contribute to the readability and maintainability of software.
SE/Software Verification Validation
Core-Tier2 topics [3 hours]:
- Verification and validation concepts
- Inspections, reviews, audits
- Testing types, including human computer interface, usability, reliability, security, conformance to specification
- Testing fundamentals
- Unit, integration, validation, and system testing
- Test plan creation and test case generation
- Black-box and white-box testing techniques
- Defect tracking
- Testing parallel and distributed systems
- Static approaches and dynamic approaches to verification
- Regression testing
- Test-driven development
- Validation planning; documentation for validation
- Object-oriented testing; systems testing
- Verification and validation of non-code artifacts (documentation, help files, training materials)
- Fault logging, fault tracking and technical support for such activities
- Fault estimation and testing termination including defect seeding
Generated by ACMgen v1.2 (c) 2012 Allan Lopez Hernandez allanlh (at) Gmail.com
- [k] Distinguish between program validation and verification.
- [k] Describe the role that tools can play in the validation of software.
- [a] Undertake, as part of a team activity, an inspection of a medium-size code segment.
- [k] Describe and distinguish among the different types and levels of testing (unit, integration, systems, and acceptance).
- [k] Describe techniques for identifying significant test cases for unit, integration, and system testing.
- [a] Use a defect tracking tool to manage software defects in a small software project.
- [k] Describe the issues and approaches to testing distributed and parallel systems.
- [a] Create, evaluate, and implement a test plan for a medium-size code segment.
- [k] Compare static and dynamic approaches to verification.
- [a] Discuss the issues involving the testing of object-oriented software.
- [k] Describe techniques for the verification and validation of non-code artifacts.
- [k] Describe approaches for fault estimation.
- [a] Estimate the number of faults in a small software application based on fault density and fault seeding.
- [a] Conduct an inspection or review of software source code for a small or medium sized software project.