- ES Español (Latinoamérica)

- EN English

3.37. CS292 Software Engineering II (Mandatory)
- Cycle: 7th Sem.
- Credits: 4
- Hour of this course: Theory: 2 hours; Practice: 2 hours; Laboratory: 2 hours;
- Syllabus:


Español (Latinoamérica)

English - Prerrequisites:
- CS291 Software Engineering I (5th Sem)
- ES Español (Latinoamérica)

- EN English

3.37.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.
- ES Español (Latinoamérica)

- EN English

3.37.2. Generales Goals Back to top


- Apply advanced software design principles and patterns to solve complex architectural problems.
- Master software configuration management and collaborative development practices.
- Understand the principles of software evolution, refactoring, and maintenance.
- Implement systematic testing strategies and understand software reliability.
- Develop professional skills for team-based software development and stakeholder management.
- ES Español (Latinoamérica)

- EN English

3.37.3. Contribution to Outcomes Back to top


- AG-C03) Individual and Team Work: Performs effectively as an individual and as a member or leader in diverse teams. (Usage)
- AG-C09) Design and Development of Solutions: Designs, implements, and evaluates solutions for complex computing problems. (Usage)
- ES Español (Latinoamérica)

- EN English

3.37.4. Content Back to top


- ES Español (Latinoamérica)

- EN English

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


Bibliography: (Sommerville, 2015; Pressman and Maxim, 2019)
Topics
- 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
- Common causes of team conflict, and approaches for conflict resolution.
- Cooperative programming:
- Pair programming or Swarming
- Code review
- Collaboration through version control
- 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
- Advantages of teamwork
- Risks and complexity of such collaboration
- Team processes - responsibilities for tasks, effort estimation, meeting structure, work schedule
Learning Outcomes
- Follow effective team communication practices [Analyze]
- 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]
- Facilitate a conflict-resolution and problem-solving strategy in a team setting [Analyze]
- Collaborate effectively in cooperative development/programming [Analyze]
- Propose and delegate necessary roles and responsibilities in a software development team [Propose]
- Compose and follow an agenda for a team meeting [Compose]
- 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]
- ES Español (Latinoamérica)

- EN English

3.37.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
- System design principles. System Reliability
- Levels of abstraction (e.g., architectural design and detailed design)
- Separation of concerns
- Information hiding
- Coupling and cohesion
- Software architecture. System Reliability
- Design paradigms
- Top-down functional decomposition/layered design
- Data-oriented architecture
- Object-oriented analysis and design
- Event-driven design
- Standard architectures (e.g., client-server and microservice architectures including REST discussions, n-layer, pipes-and-filters, Model View Controller)
- Identifying component boundaries and dependencies
- Design paradigms
- Programming in the large vs programming in the small. System Reliability
- 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
- Identify the standard software architecture of a given high-level design [Analyze]
- 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]
- Adapt a flawed system design to better follow principles such as separation of concerns or information hiding [Create]
- Identify the dependencies among a set of software components in an architectural design [Analyze]
- ES Español (Latinoamérica)

- EN English

3.37.4.3. Coding Practices (14 hours) [Skills AG-C03,AG-C09] Back to top


Bibliography: (Sommerville, 2015)
Topics
- Practical small-scale testing Software Development Practices
- Unit testing
- 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.
- Documentation Software Development Practices
- Interface documentation - describe interface requirements, potentially including (formal or informal) contracts, pre and post conditions, invariants.
- 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.)
- Clarify dataflow, computation, etc., focusing on what the code is.
- Identify subtle/tricky pieces of code and refactor to be self-explanatory if possible or provide appropriate comments to clarify.
- Coding style Software Development Practices
- Style guides
- Commenting
- Naming
- "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
- Defensive coding practices
- Secure coding practices and principles
- Using exception handling mechanisms to make programs more robust, fault-tolerant
- Debugging Software Development Practices
- Logging
- Use of libraries and frameworks developed by others Software Development Practices
Learning Outcomes
- Write appropriate unit tests for a small component (several functions, a single type, etc.) [Write]
- Write appropriate interface and (if needed) implementation comments for a small component [Write]
- Describe techniques, coding idioms and mechanisms for implementing designs to achieve desired properties such as reliability, efficiency, and robustness [Describe]
- Write robust code using exception handling mechanisms [Write]
- Describe secure coding and defensive coding practices [Describe]
- Select and use a defined coding standard in a small software project [Use]
- Compare and contrast integration strategies including top-down, bottom-up, and sandwich integration [Compare]
- Describe the process of analyzing and implementing changes to code base developed for a specific project [Describe]
- Describe the process of analyzing and implementing changes to a large existing code base [Describe]
- ES Español (Latinoamérica)

- EN English

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


Bibliography: (Pressman and Maxim, 2019)
Topics
- Verification and validation concepts
- Verification: Are we building the thing right?
- Validation: Did we build the right thing?
- Why testing matters: Does the component remain functional as the code evolves?
- Testing objectives
- Usability
- Reliability
- Conformance to specification
- Performance
- Security
Learning Outcomes
- Explain why testing is important [Explain]
- Distinguish between program validation and verification [Distinguish]
- Describe different objectives of testing [Describe]
- ES Español (Latinoamérica)

- EN English

3.37.4.5. Testing Tools and Analysis (4 hours) [Skills AG-C03,AG-C09] Back to top


Bibliography: (Sommerville, 2015; Pressman and Maxim, 2019)
Topics
- Verification and validation tooling and automation
- Static analysis
- Code coverage
- Fuzzing
- Dynamic analysis and fault containment (sanitizers, etc.)
- Fault logging and fault tracking
- Test planning and generation
- Fault estimation and testing termination including defect seeding
- Use of random and pseudo random numbers in testing
- Testing asynchronous, parallel, and concurrent systems
- Verification and validation of non-code artifacts (documentation, training materials)
- Behavior-driven development (BDD)
- Expressing acceptance criteria as Gherkin Given/When/Then scenarios
- Executing BDD scenarios as automated end-to-end tests
- Mutation testing and static code-quality analysis
- Mutation testing to assess test-suite effectiveness
- Static detection of code smells and excessive cyclomatic complexity
Learning Outcomes
- Describe and compare different tools for verification and validation [Describe]
- Automate the use of different tools in a small software project [Design]
- Explain how and when random numbers should be used in testing [Explain]
- Describe approaches for fault estimation [Describe]
- Estimate the number of faults in a small software application based on fault density and fault seeding [Estimate]
- Describe techniques and issues with testing asynchronous, concurrent, and parallel software [Describe]
- 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]
- Describe techniques for the verification and validation of non-code artifacts [Describe]
- Write Gherkin Given/When/Then scenarios for a feature's acceptance criteria and execute them as automated end-to-end tests [Write]
- Analyze a test suite's mutation score and refactor tests to kill surviving mutants [Analyze]
- ES Español (Latinoamérica)

- EN English

3.37.4.6. Performance Testing and Benchmarking (4 hours) [Skills AG-C03,AG-C09] Back to top


Bibliography: (Bondi, 2015; Gregg, 2020)
Topics
- Performance testing and benchmarking
- Throughput and latency
- Degradation under load (stress testing, FIFO vs LIFO handling of requests)
- Speedup and scaling
- Amdahl's law
- Gustafson's law
- Soft and weak scaling
- Identifying and measuring figures of merits
- Common performance bottlenecks
- Compute-bound
- Memory-bandwidth bound
- Latency-bound
- Statistical methods and best practices for benchmarking
- Estimation of uncertainty
- Confidence intervals
- Analysis and presentation (graphs, etc.)
- Timing techniques
Learning Outcomes
- Describe throughput and latency and provide examples of each [Describe]
- Explain speedup and the different forms of scaling and how they are computed [Explain]
- Describe common performance bottlenecks [Describe]
- Describe statistical methods and best practices for benchmarking software [Describe]
- Explain techniques for and challenges with measuring time when constructing a benchmark [Explain]
- Identify the figures of merit, construct and run a benchmark, and statistically analyze and visualize the results for a small software project [Analyze]
- ES Español (Latinoamérica)

- EN English

3.37.4.7. Reliability Concepts (10 hours) [Skills AG-C03,AG-C09] Back to top


Bibliography: (Sommerville, 2015)
Topics
- Concept of reliability as probability of failure or mean time between failures, and faults as cause of failures
- Identifying reliability requirements for different kinds of software
- 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.)
- Software reliability, system reliability and failure behavior
- Defect injection and removal cycle, and different approaches for defect removal
- Compare the "error budget'' approach to reliability with the "error-free'' approach and identify domains where each is relevant.
Learning Outcomes
- Describe how to determine the level of reliability required by a software system [Describe]
- Explain the problems that exist in achieving very high levels of reliability [Explain]
- Understand approaches to minimizing faults that can be applied at each stage of the software lifecycle [Explain]
- ES Español (Latinoamérica)

- EN English

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