• ES Español
• EN English

5.29. Software Engineering I (Mandatory)

5.29.1. Justification ↑ Back to top

Software engineering is a collaborative discipline that applies structured processes to build high-quality systems. This first course focuses on the foundational aspects of the software lifecycle, from initial requirements and human-centric design to systematic testing. By integrating teamwork principles and rigorous development fundamentals, students will learn to create software that is both technically sound and user-oriented.

5.29.2. Generales Goals ↑ Back to top

1. Understand and apply various software process models and configuration management.
2. Master requirements elicitation and modeling using standardized notations.
3. Develop effective teamwork and collaboration skills for software development.
4. Design robust software architectures based on engineering principles.
5. Implement systematic testing strategies and understand software quality.

5.29.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.29.4. Content ↑ Back to top

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

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

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

Bibliography: (Sommerville, 2015; Wiegers and Beatty, 2013)

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.29.4.3. Team Collaboration and Dynamics (14 hours) [Skills AG-C03,AG-C09] ↑ Back to top

Bibliography: (Wigdor and Wixon, 2011; Johnson, 2013)

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.29.4.4. Principles and Software Architecture (12 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.29.4.5. 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.29.4.6. 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.29.4.7. 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.29.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.

Wiegers, K. and Beatty, J. (2013). Software Requirements. Microsoft Press, 3rd edition.

Wigdor, D. and Wixon, D. (2011). Brave NUI World: Designing Natural User Interfaces for Touch and Gesture. Morgan Kaufmann.

Johnson, J. (2013). Designing with the Mind in Mind. Morgan Kaufmann, 2nd 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.