# Programación II

## 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
• ----->Abstraction
• ----->Program decomposition
• ----->Encapsulation and information hiding
• ----->Separation of behavior and implementation

Learning Outcomes:

1. [k] Discuss the importance of algorithms in the problem-solving process.
2. [k] Discuss how a problem may be solved by multiple algorithms, each with different properties.
3. [a] Create algorithms for solving simple problems.
4. [a] Use pseudocode or a programming language to implement, test, and debug algorithms for solving simple problems.
5. [a] Implement, test, and debug simple recursive functions and procedures.
6. [e] Determine when a recursive solution is appropriate for a problem.
7. [a] Implement a divide-and-conquer algorithm for solving a problem.
8. [a] Apply the techniques of decomposition to break a program into smaller pieces.
9. [a] Identify the data components and behaviors of multiple abstract data types.
10. [a] Implement a coherent abstract data type, with loose coupling between components and behaviors.
11. [e] Identify the relative strengths and weaknesses among multiple designs or implementations for a problem.

## SDF/Development Methods

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

Learning Outcomes:

1. [k] Explain why the creation of correct program components is important in the production of quality software.
2. [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.
3. [a] Conduct a personal code review (focused on common coding errors) on a program component using a provided checklist.
4. [a] Contribute to a small-team code review focused on component correctness.
5. [k] Describe how a contract can be used to specify the behavior of a program component.
6. [a] Create a unit test plan for a medium-size code segment.
7. [a] Apply a variety of strategies to the testing and debugging of simple programs.
8. [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.
9. [a] Construct and debug programs using the standard libraries available with a chosen programming language.
10. [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

[Elective]

Topics:
• 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

Learning Outcomes:

1. [k] Distinguish between program validation and verification.
2. [k] Describe the role that tools can play in the validation of software.
3. [a] Undertake, as part of a team activity, an inspection of a medium-size code segment.
4. [k] Describe and distinguish among the different types and levels of testing (unit, integration, systems, and acceptance).
5. [k] Describe techniques for identifying significant test cases for unit, integration, and system testing.
6. [a] Use a defect tracking tool to manage software defects in a small software project.
7. [k] Describe the issues and approaches to testing distributed and parallel systems.
8. [a] Create, evaluate, and implement a test plan for a medium-size code segment.
9. [k] Compare static and dynamic approaches to verification.
10. [a] Discuss the issues involving the testing of object-oriented software.
11. [k] Describe techniques for the verification and validation of non-code artifacts.
12. [k] Describe approaches for fault estimation.
13. [a] Estimate the number of faults in a small software application based on fault density and fault seeding.
14. [a] Conduct an inspection or review of software source code for a small or medium sized software project.
Generated by ACMgen v1.2 (c) 2012 Allan Lopez Hernandez allanlh (at) Gmail.com