Overview
This course introduces fundamental software engineering knowledge, professional standards, and practical methods for requirements analysis, software design, implementation, testing, deployment, maintenance, and team collaboration.
Learning Objectives
- Understand fundamental software engineering knowledge and related professional and industry standards.
- Master large-scale software development processes and techniques for requirements analysis, design, implementation, testing, and deployment.
- Apply software engineering concepts, methods, and tools in laboratory work to solve practical software engineering problems.
- Integrate into a project team, fulfill role responsibilities, and communicate effectively during collaborative development.
Theory Course Content
Theory teaching builds the conceptual frame for course projects and laboratories, with attention to method selection, artifact quality, engineering evidence, and reflective design decisions.
6 hours
Software engineering, process, and management
Introduce software as an engineered socio-technical product and explain how process, organization, risk, and quality management shape real development outcomes.
Topics
- Software characteristics, software crisis, engineering thinking, and professional responsibility
- Lifecycle models including waterfall, incremental, iterative, agile, DevOps, and hybrid processes
- Project planning, estimation, risk management, configuration management, and quality assurance
- Team roles, communication mechanisms, documentation discipline, and engineering ethics
Class Activities
- Compare process choices for different project contexts and risk profiles.
- Analyze a failed or delayed software project from process, requirement, quality, and communication perspectives.
- Build a lightweight project plan that connects milestones, artifacts, roles, and quality gates.
Learning Outcomes
- Select an appropriate development process for a given project scenario.
- Explain how management decisions affect technical quality and delivery risk.
- Use basic project-management vocabulary when planning team laboratory work.
6 hours
Software requirements engineering
Develop the ability to move from stakeholder goals and informal problem descriptions to analyzable, negotiable, and testable requirements.
Topics
- Stakeholders, goals, scope, business rules, functional requirements, and quality requirements
- Elicitation methods including interview, observation, questionnaire, workshop, and document analysis
- Use cases, user stories, domain concepts, system events, and requirements prioritization
- Requirements ambiguity, conflict, validation, change control, and traceability
Class Activities
- Rewrite vague natural-language statements into clearer requirement candidates.
- Construct use cases and user stories from a shared project scenario.
- Review requirements against completeness, consistency, feasibility, testability, and stakeholder value.
Learning Outcomes
- Distinguish problem-domain facts from solution-domain design choices.
- Produce requirements artifacts that can drive modeling, design, testing, and acceptance.
- Manage requirement changes with explicit rationale and traceability.
8 hours
Software design
Explain how requirements are transformed into architecture, components, interfaces, data models, and detailed object-oriented designs that support maintainability and evolution.
Topics
- Architectural views, component decomposition, deployment concerns, and design constraints
- Object-oriented analysis and design, class responsibility assignment, interfaces, and collaborations
- UML diagrams including package, component, class, sequence, activity, and state diagrams
- Design principles, coupling and cohesion, design patterns, refactoring, and review techniques
Class Activities
- Compare alternative architectures for the same requirement set.
- Refine domain models into design models and identify responsibility boundaries.
- Review model diagrams for consistency, missing interfaces, excessive coupling, and unhandled scenarios.
Learning Outcomes
- Translate requirements into architecture and detailed design artifacts.
- Justify key design decisions using quality attributes and trade-off reasoning.
- Use diagrams as engineering communication tools rather than decorative documentation.
6 hours
Implementation and testing
Connect implementation discipline with defect prevention and systematic testing, emphasizing that code quality, test design, and maintainability are inseparable.
Topics
- Coding standards, modular implementation, code review, defensive programming, and technical debt
- Defect concepts, fault-error-failure chain, debugging strategy, and regression risk
- Black-box testing, equivalence partitioning, boundary-value analysis, decision tables, and scenario testing
- White-box testing, control-flow coverage, unit testing, integration testing, and test management
Class Activities
- Derive test cases from requirements and design artifacts.
- Inspect code snippets for maintainability, robustness, and hidden defect risks.
- Compare manual testing, automated unit testing, integration testing, and continuous testing roles.
Learning Outcomes
- Design tests that are traceable to requirements and design decisions.
- Explain why coverage alone is not enough for quality assurance.
- Use implementation and testing evidence to support project assessment.
6 hours
Deployment, maintenance, and evolution
Introduce software delivery after implementation, including release, deployment, operation, maintenance, and evolution under changing requirements and environments.
Topics
- Release planning, deployment strategies, environment configuration, and rollback thinking
- Corrective, adaptive, perfective, and preventive maintenance
- Software evolution, refactoring, reuse, versioning, and compatibility management
- DevOps, CI/CD, containerization, monitoring, incident response, and operational feedback
Class Activities
- Map project artifacts from development into release and deployment evidence.
- Analyze maintenance requests and classify their impact on requirements, design, code, and tests.
- Discuss how operational data feeds back into the next iteration of requirements and architecture.
Learning Outcomes
- Understand deployment and maintenance as core parts of the software lifecycle.
- Plan evolution work without breaking existing behavior and quality guarantees.
- Connect laboratory deployment practice with broader engineering operation concepts.
Experiment Course Content
Laboratory teaching turns the theory modules into concrete engineering artifacts, including models, code, tests, deployment evidence, verification records, and project reports.
Laboratory
Lab 01: Software project development fundamentals
4 hours
Understand Markdown, Git version control, remote repositories, code hosting platforms, and course project organization.
Tasks
- Practice Git operations and team collaboration workflows.
- Complete initial project guidance and repository setup.
Deliverables
- Project repository
- Markdown documentation
- Team collaboration record
Laboratory
Lab 02: Software project management tools
4 hours
Use CodeArts-style project, repository, pipeline, test, and modeling management tools.
Tasks
- Configure project management, code repository management, pipeline management, test management, and modeling management.
- Connect tool usage with project process management.
Deliverables
- Tool configuration records
- Project management artifacts
Laboratory
Lab 03: Software requirements analysis and modeling
4 hours
Model structured natural-language requirements and requirements models.
Tasks
- Write user stories and use case descriptions.
- Draw use case diagrams, system sequence diagrams, conceptual class diagrams, and system operation contracts.
Deliverables
- Requirements specification
- Use case model
- Domain model
Laboratory
Lab 04: Software architectural and detailed design
4 hours
Practice architectural and detailed design modeling.
Tasks
- Draw package diagrams, component diagrams, and component sequence diagrams.
- Draw design class diagrams, sequence diagrams, and activity diagrams for detailed design.
Deliverables
- Architecture model
- Detailed design model
- Project guidance record
Laboratory
Lab 05: Front-end development fundamentals
4 hours
Understand HTML, CSS, JavaScript, and common front-end development frameworks such as Vue.js.
Tasks
- Design front-end pages with basic functionality.
- Apply front-end development tools in project work.
Deliverables
- Front-end pages
- Project implementation record
Laboratory
Lab 06: Back-end development fundamentals
4 hours
Master basic use of common back-end frameworks such as Django, Spring Boot, or NestJS.
Tasks
- Implement back-end services for project functions.
- Connect back-end implementation with project guidance.
Deliverables
- Back-end service code
- Interface implementation record
Laboratory
Lab 07: Software testing
4 hours
Understand the software testing process and front-end/back-end testing tools.
Tasks
- Use unit testing tools such as Pytest and JUnit.
- Design and execute tests for project functions.
Deliverables
- Test cases
- Test execution results
- Testing report
Laboratory
Lab 08: Software integration, delivery, and deployment
4 hours
Practice software integration, delivery, deployment, Docker, and Kubernetes.
Tasks
- Use Docker for containerized development practice.
- Use Kubernetes for software deployment practice.
Deliverables
- Containerized application
- Deployment configuration
- Deployment verification record
Assessment
| Item | Weight | Focus |
|---|---|---|
| Team project | 30% | Functionality, documentation, code quality, presentation, and teamwork. |
| In-class assignments | 20% | Application problems and regular learning performance. |
| Experiments | 20% | Laboratory attendance, experiment results, and tool-based practice. |
| Final examination | 30% | Open-book application-oriented exam. |
References and Source
- Peng Rong, Liang Peng, Cao Jian, Fan Guoxiang, Wang Liang, Tan Xin, Yang Yilong, et al. Software Engineering. Tsinghua University Press, 2024.
- Roger S. Pressman. Software Engineering: A Practitioner's Approach.
- Ian Sommerville. Software Engineering.
Source syllabus: en.pdf