• ES Español
• EN English

5.50. Software Engineering III (Elective)

5.50.1. Justification ↑ Back to top

Software Engineering III focuses on advanced topics of the software lifecycle, emphasizing software quality, evolution, and deployment in modern architectures. This course prepares students to handle the complexities of maintaining systems, ensuring software quality through rigorous validation, and the application of professional tools and design practices for resilient and maintainable software products.

5.50.2. Generales Goals ↑ Back to top

1. Implement advanced quality assurance and reliability metrics.
2. Understand software evolution, refactoring, and technical debt management.
3. Integrate development and operations tools in collaborative environments.
4. Design cloud-native applications using advanced software architectures.
5. Analyze and apply systematic testing and validation strategies.

5.50.3. Contribution to Outcomes ↑ Back to top

AG-C09) Design and Development of Solutions: Designs, implements, and evaluates solutions for complex computing problems. (Usage)

AG-C03) Individual and Team Work: Performs effectively as an individual and as a member or leader in diverse teams. (Usage)

5.50.4. Content ↑ Back to top

5.50.4.1. Verification and validation Concepts (12 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015; Pressman and Maxim, 2019)

Topics

1. Verification and validation concepts
2. Verification: Are we building the thing right?
3. Validation: Did we build the right thing? enumerate
4. Why testing matters: Does the component remain functional as the code evolves?
5. Testing objectives
6. Usability
7. Reliability
8. Conformance to specification
9. Performance
10. Security enumerate

Learning Outcomes

1. Explain why testing is important [Explain]
2. Distinguish between program validation and verification [Distinguish]
3. Describe different objectives of testing [Describe]

5.50.4.2. Testing Tools and Analysis (3 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Pressman and Maxim, 2019)

Topics

1. Verification and validation tooling and automation
2. Static analysis
3. Code coverage
4. Fuzzing
5. Dynamic analysis and fault containment (sanitizers, etc.)
6. Fault logging and fault tracking enumerate
7. Test planning and generation
8. Fault estimation and testing termination including defect seeding
9. Use of random and pseudo random numbers in testing enumerate
10. Testing asynchronous, parallel, and concurrent systems
11. Verification and validation of non-code artifacts (documentation, training materials)

Learning Outcomes

1. Describe and compare different tools for verification and validation [Describe]
2. Automate the use of different tools in a small software project [Design]
3. Explain how and when random numbers should be used in testing [Explain]
4. Describe approaches for fault estimation [Describe]
5. Estimate the number of faults in a small software application based on fault density and fault seeding [Estimate]
6. Describe techniques and issues with testing asynchronous, concurrent, and parallel software [Describe]
7. Create a test plan for a medium-size code segment which contains asynchronous, concurrent, and/or parallel code, including a test matrix and generation of test data and inputs [Create]
8. Describe techniques for the verification and validation of non-code artifacts [Describe]

5.50.4.3. Performance Testing and Benchmarking (3 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Bondi, 2015; Gregg, 2020)

Topics

1. Performance testing and benchmarking
2. Throughput and latency
3. Degradation under load (stress testing, FIFO vs LIFO handling of requests)
4. Speedup and scaling
5. Amdahl's law
6. Gustafson's law
7. Soft and weak scaling enumerate
8. Identifying and measuring figures of merits
9. Common performance bottlenecks
10. Compute-bound
11. Memory-bandwidth bound
12. Latency-bound enumerate
13. Statistical methods and best practices for benchmarking
14. Estimation of uncertainty
15. Confidence intervals enumerate
16. Analysis and presentation (graphs, etc.)
17. Timing techniques enumerate

Learning Outcomes

1. Describe throughput and latency and provide examples of each [Describe]
2. Explain speedup and the different forms of scaling and how they are computed [Explain]
3. Describe common performance bottlenecks [Describe]
4. Describe statistical methods and best practices for benchmarking software [Describe]
5. Explain techniques for and challenges with measuring time when constructing a benchmark [Explain]
6. Identify the figures of merit, construct and run a benchmark, and statistically analyze and visualize the results for a small software project [Analyze]

5.50.4.4. API Compatibility and Versioning (12 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015)

Topics

1. Hyrum's Law/The Law of Implicit Interfaces
2. Backward compatibility
3. Compatibility is not a property of a single entity, it's a property of a relationship.
4. Backward compatibility needs to be evaluated in terms of provider + consumer(s) or with a well-specified model of what forms of compatibility a provider aspires to/promises. enumerate
5. Versioning
6. Semantic Versioning (SemVer)
7. Trunk-based development enumerate

Learning Outcomes

1. Identify both explicit and implicit behavior of an interface and identify potential risks from Hyrum's Law [Analyze]
2. Identify changes that can be broadly considered "backward compatible,'' potentially with explicit statements about what usage is or is not supported [Analyze]
3. Evaluate whether a proposed change is sufficiently safe given the versioning methodology in use for a given project [Evaluate]

5.50.4.5. Version Control and CI/CD (12 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Kim et al., 2016)

Topics

1. Software configuration management and version control: Software Development Practices
2. Configuration in version control, reproducible builds/configuration.
3. Version control branching strategies. Development branches vs release branches. Trunk-based development.
4. Merging/rebasing strategies, when relevant. enumerate
5. Release management.
6. Testing tools including static and dynamic analysis tools. Software Development Practices , Information Flow and Non-Interference , Injection and Input Validation , Memory Safety and Types , Malware Analysis and Advanced Security
7. Software process automation:
8. Build systems - the value of fast, hermetic, reproducible builds, compare/contrast approaches to building a project.
9. Continuous Integration (CI) - the use of automation and automated tests to do preliminary validation that the current head/trunk revision builds and passes (basic) tests.
10. Continuous Deployment (CD) - the use of automation to automatically release every change that passes the automated tests to the production environment, ensuring frequent and reliable deliveries.
11. Dependency management - updating external/upstream dependencies, package management, SemVer. enumerate

Learning Outcomes

1. Describe the difference between centralized and distributed software configuration management [Describe]
2. Describe how version control can be used to help manage software release management [Describe]
3. Identify configuration items and use a source code control tool in a small team-based project [Analyze]
4. Describe how available static and dynamic test tools can be integrated into the software development environment [Describe]
5. Understand the use of CI/CD systems as a ground-truth for the state of the team's shared code (build and test success) [Explain]

5.50.4.6. Principles and Software Architecture (12 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Fowler, 2017)

Topics

1. System design principles. System Reliability
2. Levels of abstraction (e.g., architectural design and detailed design)
3. Separation of concerns
4. Information hiding
5. Coupling and cohesion enumerate
6. Software architecture. System Reliability
7. Design paradigms
8. Top-down functional decomposition/layered design
9. Data-oriented architecture
10. Object-oriented analysis and design
11. Event-driven design enumerate
12. Standard architectures (e.g., client-server and microservice architectures including REST discussions, n-layer, pipes-and-filters, Model View Controller)
13. Identifying component boundaries and dependencies enumerate
14. Programming in the large vs programming in the small. System Reliability
15. Code smells and other indications of code quality, distinct from correctness. Security Design and Controls Engineering , Threat Analysis and Security Engineering , Trusted Computing and Privacy Engineering

Learning Outcomes

1. Identify the standard software architecture of a given high-level design [Analyze]
2. Select and use an appropriate design paradigm to design a simple software system and explain how system design principles have been applied in this design [Evaluate]
3. Adapt a flawed system design to better follow principles such as separation of concerns or information hiding [Create]
4. Identify the dependencies among a set of software components in an architectural design [Analyze]

5.50.5. Bibliography ↑ Back to top

Sommerville, I. (2015). Software Engineering. Pearson, 10th edition.

Pressman, R. S. and Maxim, B. (2019). Software Engineering: A Practitioner's Approach. McGraw-Hill Education, 9th edition.

Bondi, A. B. (2015). Foundations of Software and System Performance Engineering: Process, Performance Modeling, Requirements, Testing, Scalability, and Practice. Addison-Wesley, Upper Saddle River, NJ.

Gregg, B. (2020). Systems Performance: Enterprise and the Cloud. Addison-Wesley Professional, Boston, MA, 2nd edition.

Kim, G., Humble, J., Debois, P., and Willis, J. (2016). The DevOps Handbook. IT Revolution Press.

Fowler, M. (2017). Refactoring: Improving the Design of Existing Code. Addison-Wesley, 2nd edition.