Steps
Step 1
Requirements & Quality Attributes
This step conducts requirements elicitation and analysis, clarifying functional and non-functional requirements of the Software Architecture project. Requirements analysis is the starting point of software projects, and accurate requirement definition is the foundation for subsequent design and development. Elicit and organize requirements through user interviews, scenario analysis, use case modeling and other methods, establish requirements specification. Use UML use case diagrams, activity diagrams and other tools to visually express requirements, ensuring consistent understanding among all parties.
• Requirements elicitation and organization: collect requirements through user research and scenario analysis, distinguish functional and non-functional requirements
• Requirements modeling and analysis: use UML use case diagrams, activity diagrams, class diagrams to build requirements models, identify actors and use cases
• Requirements specification: write requirements specification document, define acceptance criteria, conduct requirements review and confirmation
Deliverable: Requirements specification document (use case diagrams, activity diagrams, requirements list, acceptance criteria) | Quality standard: Complete and clear requirements, verifiable and traceable, reviewed and approved
Step 2
Architecture Design
This step conducts architecture design and detailed design for Software Architecture. Architecture design determines the overall structure and quality attributes of the system, and is the corestep of software projects. Apply design patterns and architectural principles to design layered architecture, module division, and interface definitions. Detailed design phase refines internal structure of each module, designs core algorithms and data structures. Use UML class diagrams, sequence diagrams, state diagrams to precisely express design intent.
• Architecture design: design layered architecture (presentation layer, business layer, data layer), select appropriate architecture patterns (MVC/MVVM/Microservices)
• Detailed design: design class structure, interface definitions, core algorithms, data structures, apply design patterns (Singleton, Factory, Observer, etc.)
• Design documentation: write architecture design document and detailed design document, including UML diagrams, design description, technology selection
Deliverable: Design document (architecture design, detailed design, UML diagrams, database design) | Quality standard: Reasonable architecture, clear design, follows design principles and patterns
Step 3
4+1 View Modeling
This step performs coding implementation based on design documents, using Software Architecture related tech stack to build the software system. Implementation phase transforms design into runnable software product, requiring strict adherence to coding standards and design documents. Adopt object-oriented programming concepts, apply encapsulation, inheritance, polymorphism and other features. Use version control tools (Git) to manage code, ensure code quality through CI/CD pipelines. Write unit test cases to ensure code quality.
• Code implementation: use Java/C#/Python etc., follow SOLID principles, apply design patterns, write highly readable code
• Database implementation: design database table structure, write SQL statements, use ORM frameworks (Hibernate/MyBatis/SQLAlchemy)
• Version control and quality: use Git for version management, write unit tests (JUnit/Mockito/PyTest), conduct code review
Deliverable: Source code (business code, database scripts, unit tests) | Quality standard: Standardized code, clear structure, qualified test coverage
Step 4
Prototype Implementation
This step conducts software testing and quality assurance, ensuring Software Architecture project quality meets requirements. Software testing is a keystep of discovering defects and ensuring quality, requiring systematic testing strategy and plan. Conduct multi-level testing including unit testing, integration testing, system testing, acceptance testing. Use automated testing tools to improve testing efficiency, track defect resolution through defect management. Analyze test results, evaluate product quality and release risk.
• Test strategy formulation: determine test scope, test methods, test environment, develop test plan and test cases
• Multi-level testing: unit testing (JUnit/TestNG), integration testing, system testing, performance testing (JMeter/LoadRunner)
• Defect management and quality assessment: use Jira for defect management, analyze test coverage and defect density, assess release risk
Deliverable: Test report (test plan, test cases, defect report, quality assessment) | Quality standard: Comprehensive test coverage, timely defect fixing, quality meets standards
Step 5
ATAM Evaluation & Documentation
This step conducts project summary and documentation improvement, completing final delivery of the Software Architecture course project. Summarize the entire project process, sort out technical solutions and implementation details, form complete project documentation. Deploy software system, prepare demo environment and user manual. Summarize project experience and lessons, reflect on gains and losses in technology selection and development process. Good documentation and summary skills are essential qualities for software engineers.
• Documentation improvement: write user manual, deployment manual, operation manual, improve API documentation and technical documents
• System deployment and demo: deploy to test/production environment, prepare demo data and demo script, conduct function demo
• Project summary: write project summary report, analyze successful experience and shortcomings, propose improvement suggestions and future outlook
Deliverable: Final deliverables (complete documents, deployment package, demo system, summary report) | Quality standard: Complete documentation, stable system, in-depth summary