• ES Español
• EN English

5.61. Tópicos en Ingeniería de Software (Elective)

5.61.1. Justification ↑ Back to top

Modern software development requires rigorous engineering practices to ensure quality, maintainability, and reliability. This course explores advanced topics in the software lifecycle, focusing on team collaboration, formal verification, and advanced refactoring. Students will master the use of professional tools to design, construct, and validate complex systems while ensuring high standards of reliability and formal correctness.

5.61.2. Generales Goals ↑ Back to top

1. Apply advanced software construction and refactoring techniques to improve code quality.
2. Use formal methods and validation strategies to ensure system reliability.
3. Manage complex requirements and design architectures that meet stakeholder needs.
4. Lead software teams using professional tools and collaborative workflows.

5.61.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.61.4. Content ↑ Back to top

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

Bibliography: (Sommerville, 2015)

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.61.4.2. Version Control and CI/CD (4 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Pressman and Maxim, 2014)

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.61.4.3. Requirements Engineering (6 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015)

Topics

1. Describe functional requirements using, for example, use cases or user stories.
2. Using at least one method of documenting and structuring functional requirements.
3. Understanding how the method supports design and implementation.
4. Strengths and weaknesses of using a specific approach. enumerate
5. Properties of requirements including consistency, validity, completeness, and feasibility.
6. Requirements elicitation.
7. Sources of requirements, for example, users, administrators, or support personnel.
8. Methods of requirement gathering, for example, surveys, interviews, or behavioral analysis. enumerate
9. Non-functional requirements, for example, security, usability, or performance, also called as Quality Attributes. Sustainable Design and Pervasive Computing , Environmental Footprint of Computing Systems , Systemic Effects and Social Context
10. Risk identification and management, including ethical considerations surrounding the proposed product. Ethics Codes and Legal Accountability , Professional Responsibility and Public Policy , Professional Values, Nature and Continuing Development , Ethical Dissent and Cultural Context , Workplace Ethics
11. Communicating and/or formalizing requirement specifications.

Learning Outcomes

1. Compare different methods of eliciting requirements along multiple axes [Compare]
2. Identify differences between two methods of describing functional requirements (e.g., customer interviews, user studies) and the situations where each would be preferred [Analyze]
3. Identify which behaviors are required, allowed, or barred from a given set of requirements and a list of candidate behaviors [Analyze]
4. Collect a set of requirements for a simple software system [Analyze]
5. Identify areas of a software system that need to be changed, given a description of the system and a set of new requirements to be implemented [Analyze]
6. Identify the functional and non-functional requirements in a set of requirements [Analyze]

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

Bibliography: (Sommerville, 2015)

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

Bibliography: (Fowler, 2018)

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.61.4.6. API Compatibility and Versioning (6 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Fowler, 2018)

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.61.4.7. Verification and validation Concepts (6 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Pressman and Maxim, 2014)

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

Bibliography: (Pressman and Maxim, 2014)

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.61.4.9. 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.61.4.10. Reliability Concepts (5 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Pressman and Maxim, 2014)

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.61.4.11. Formal Methods (5 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Sommerville, 2015)

Topics

1. Formal specification of interfaces
2. Specification of pre- and post- conditions
3. Formal languages for writing and analyzing pre- and post-conditions. enumerate
4. Problem areas well served by formal methods
5. Lock-free programming, data races
6. Asynchronous and distributed systems, deadlock, livelock, etc. enumerate
7. Comparison to other tools and techniques for defect detection
8. Testing
9. Fuzzing enumerate
10. Formal approaches to software modeling and analysis
11. Model checkers
12. Model finders enumerate

Learning Outcomes

1. Describe the role formal specification and analysis techniques can play in the development of complex software and compare their use as validation and verification techniques with testing [Describe]
2. Apply formal specification and analysis techniques to software designs and programs with low complexity [Apply]
3. Explain the potential benefits and drawbacks of using formal specification languages [Explain]

5.61.5. Bibliography ↑ Back to top

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

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

Fowler, M. (2018). Refactoring: Improving the Design of Existing Code. Addison-Wesley Professional, 2nd 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.