• ES Español
• EN English

5.39. Software Engineering II (Mandatory)

5.39.1. Justification ↑ Back to top

Software Engineering II builds upon the foundational principles of the first course, shifting focus towards advanced design, software evolution, and the management of large-scale projects. It explores the complexities of maintaining systems, ensuring software quality through rigorous validation, and the application of professional teamwork and project management techniques in collaborative environments.

5.39.2. Generales Goals ↑ Back to top

1. Apply advanced software design principles and patterns to solve complex architectural problems.
2. Master software configuration management and collaborative development practices.
3. Understand the principles of software evolution, refactoring, and maintenance.
4. Implement systematic testing strategies and understand software reliability.
5. Develop professional skills for team-based software development and stakeholder management.

5.39.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.39.4. Content ↑ Back to top

5.39.4.1. Team Collaboration and Dynamics (14 hours) [Skills AG-C03,AG-C09] ↑ Back to top

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

Topics

1. Effective communication, including oral and written, as well as formal (email, docs, comments, presentations) and informal (team chat, meetings). Technical and Professional Communication , Team Communication and Culture
2. Common causes of team conflict, and approaches for conflict resolution.
3. Cooperative programming:
4. Pair programming or Swarming
5. Code review
6. Collaboration through version control enumerate
7. Roles and responsibilities in a software team: Ethics Codes and Legal Accountability , Professional Responsibility and Public Policy , Professional Values, Nature and Continuing Development , Ethical Dissent and Cultural Context , Workplace Ethics
8. Advantages of teamwork
9. Risks and complexity of such collaboration enumerate
10. Team processes - responsibilities for tasks, effort estimation, meeting structure, work schedule

Learning Outcomes

1. Follow effective team communication practices [Analyze]
2. Articulate the sources of, hazards of, and potential benefits of team conflict - especially focusing on the value of disagreeing about ideas or proposals without insulting people [Articulate]
3. Facilitate a conflict-resolution and problem-solving strategy in a team setting [Analyze]
4. Collaborate effectively in cooperative development/programming [Analyze]
5. Propose and delegate necessary roles and responsibilities in a software development team [Propose]
6. Compose and follow an agenda for a team meeting [Compose]
7. Facilitate through involvement in a team project, the central elements of team building, establishing healthy team culture, and team management including creating and executing a team work plan [Create]

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

Bibliography: (Gamma et al., 1994a; Pressman and Maxim, 2019)

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.39.4.3. Coding Practices (14 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015)

Topics

1. Practical small-scale testing Software Development Practices
2. Unit testing
3. Test-driven development - This is particularly valuable for students psychologically, as it is far easier to engage constructively with the challenge of identifying challenging inputs for a given API (edge cases, corner cases) a priori. If they implement first, the instinct is often to avoid trying to crash their new creation, while a test-first approach gives them the intellectual satisfaction of spotting the problem cases and then watching as more tests pass during the development process. enumerate
4. Documentation Software Development Practices
5. Interface documentation - describe interface requirements, potentially including (formal or informal) contracts, pre and post conditions, invariants.
6. Implementation documentation should focus on tricky and non-obvious pieces of code, whether because the code is using advanced language features, or the behavior of the code is complex. (Do not add comments that re-state common/obvious operations and simple language features.)
7. Clarify dataflow, computation, etc., focusing on what the code is.
8. Identify subtle/tricky pieces of code and refactor to be self-explanatory if possible or provide appropriate comments to clarify. enumerate enumerate
9. Coding style Software Development Practices
10. Style guides
11. Commenting
12. Naming enumerate
13. "Best Practices'' for coding: techniques, idioms/patterns, mechanisms for building quality programs Software Development Practices , Information Flow and Non-Interference , Injection and Input Validation , Memory Safety and Types , Malware Analysis and Advanced Security
14. Defensive coding practices
15. Secure coding practices and principles
16. Using exception handling mechanisms to make programs more robust, fault-tolerant enumerate
17. Debugging Software Development Practices
18. Logging
19. Use of libraries and frameworks developed by others Software Development Practices

Learning Outcomes

1. Write appropriate unit tests for a small component (several functions, a single type, etc.) [Write]
2. Write appropriate interface and (if needed) implementation comments for a small component [Write]
3. Describe techniques, coding idioms and mechanisms for implementing designs to achieve desired properties such as reliability, efficiency, and robustness [Describe]
4. Write robust code using exception handling mechanisms [Write]
5. Describe secure coding and defensive coding practices [Describe]
6. Select and use a defined coding standard in a small software project [Use]
7. Compare and contrast integration strategies including top-down, bottom-up, and sandwich integration [Compare]
8. Describe the process of analyzing and implementing changes to code base developed for a specific project [Describe]
9. Describe the process of analyzing and implementing changes to a large existing code base [Describe]

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

Bibliography: (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.39.4.5. Testing Tools and Analysis (4 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015; 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.39.4.6. Performance Testing and Benchmarking (4 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.39.4.7. Reliability Concepts (10 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015)

Topics

1. Concept of reliability as probability of failure or mean time between failures, and faults as cause of failures
2. Identifying reliability requirements for different kinds of software
3. Software failures caused by defects/bugs, and so for high reliability the goal is to have minimum defects - by injecting fewer defects (better training, education, planning), and by removing most of the injected defects (testing, code review, etc.)
4. Software reliability, system reliability and failure behavior
5. Defect injection and removal cycle, and different approaches for defect removal
6. Compare the "error budget'' approach to reliability with the "error-free'' approach and identify domains where each is relevant.

Learning Outcomes

1. Describe how to determine the level of reliability required by a software system [Describe]
2. Explain the problems that exist in achieving very high levels of reliability [Explain]
3. Understand approaches to minimizing faults that can be applied at each stage of the software lifecycle [Explain]

5.39.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.

Gamma, E., Helm, R., Johnson, R., and Vlissides, J. (1994a). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Professional, Reading, MA, 1st 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.