Lectures: Wednesdays 18:30 to 21:00 FG-355
Tutorial: Wednesdays 17:30 to 18:20 in H-823
Laboratory: Wednesdays 21:00 to 23:00 in H-823 (unstaffed)
Instructor: Dr Greg Butler S-EV-3.219 gregb AT cse DOT concordia DOT ca
TA: Christine Kehyayan
This course is a 4-credit course with 3 contact hours (2.5 class hours) of lecture, 1 hour of tutorial and 2 hours of lab. Material is covered during lectures, tutorials and labs. Through these three types of instruction you are taught the different perspectives of Software Engineering discipline : basic principles, formalisms, tools and team work. You will be learning a disciplined process of developing software and practicing it in a small project.
You should expect to average a total of 10 to 12 hours per week on this course. For individual weeks it will be much higher depending on your role in the project and the phase of the project. So plan your time accordingly.
Craig Larman, Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development, 3rd edition, Prentice-Hall, 2005.
There will be three quizzes. Each quiz is a 60 minute closed book written examination. Each is worth 20% of the total mark for the course.
There is a team project with four components. Each component is worth 10% of the total mark for the course.
The emphasis of the project is on experiencing a complete software lifecycle rather than producing a gee-whiz final product. We want you to see how the phases and documents of the project relate to each other, to appreciate the point of trying to get it right the first time, but also having review mechanisms in place to catch mistakes (as they are bound to happen).
This semester there will be three teams of 5-6 students doing three different projects:
The project is done in a iterative fashion. Each iteration develops a working system. The first is a very basic system. The second has more features, but still basic in approach and scope. The third is close to a realistic system in scope, design, usability, and robustness.
Each iteration is allocated about four weeks during the semester.
There are three iterations to the project and there is a final demonstration of the project.
Component 1: The first iteration of the project is to think about the domain entities and data that will be processed. Also to think about potential features of the system, how much you can achieve in a semester, how the work will be distributed across the three versions, and how you will organize testing and quality control.
Deliverable 1 - Document: A description of your system scope, features, versions, and test plan. The role to be played by each team member during each iteration is included.
Deliverable 1 - System: A spreadsheet layout to capture and manage the data.
Component 2: A stand-alone Java application which a minimal set of functionality and features. Data should be stored using java serialization of objects, but be designed with the future needs of using a relational database.
Deliverable 2 - Document: A requirements document which includes the domain model and the major use cases.
Deliverable 2 - System: Submit your Eclipse project for this version of the system. To include Java code and JUnit tests.
Component 3: A stand-alone Java application which a usable set of functionality and features. Data should be stored in a mySQL relational database.
Deliverable 3 - Document: A design document showing the architecture, major classes, and a sample of major sequence diagrams.
Deliverable 3 - System: Submit your Eclipse project for this version of the system. To include Java code and JUnit tests.
Component 4: The last iteration should not be adding any new functionality, but concentrate on eliminating bugs and improving usability and robustness to the previous version.
Deliverable 4 - Document: A status report of the project which includes a test report.
Deliverable 4 - System: A demonstration of the final system to the class by the team.
Submit your Eclipse project for this version of the system. To include Java code and JUnit tests.
Week 1 May 6, 2009: Introduction
Introduction to course, software engineering, projects.
Software engineering: projects, phases, milestones, deliverables, people, tools, problems,
and some solutions.
Major problems: requirements, architecture, change, complexity.
Read Larman chapters 1,2,3.
Also read Introduction to Software Engineering, Software Development Phases, Software process.
And ... Twelve Requirements Basics for Project Success
Week 2 May 13, 2009: Basic Software Engineering.
Agile, iterative development; test-driven development; the V model.
Read Larman chapters 2
Test driven development slides (1)
Test driven development slides (2)
Agile development slides
Also read Agile software development, Test-driven development, V-model
Week 3 May 20, 2009: Project Discussion.
Management, planning, scope, risks.
Unified Process approaches to the problems.
Inception: major risks and use cases.
Elaboration: complete risk analysis, most use cases, architectural baseline, development plan.
Construction: incremental construction.
Transition: deployment to customer.
Read Larman chapters 2,4,5.
Project Management slides
Rational Unified Process slides
Also read Project management, Unified process, Risk management
Week 4 May 27, 2009: Requirements.
Domain Model, use cases, scenarios, system operations and contracts.
Importance of domain model for data processing applications.
Read Larman chapters 4-7; chapters 9-11.
Larman requirements, domain model, use cases, scenarios, sys ops slides
Also read: requirements, use case approach
Week 5 June 3, 2009: Quiz 1. Architecture.
Layered architecture - layers, virtual machines, data gateways, data mappers.
Project Deliverables 1 Due midnight Saturday June 6, 2009.
Week 6 June 10, 2009: Architecture (continued).
Typical Java application (the Model-View-Control architecture).
Typical web application (Fowler's EAA architecture).
Read Larman chapters 12, 13, 33.
Design: responsibility-driven design,layered architecture,model-view-control
Week 7 June 17, 2009: Design.
Object-oriented development. Classes, objects, responsibilities.
Design: responsibility-driven design; GRASP principles; design patterns; use case realization; design rationale.
June 24, 2009: Public holiday. No lecture, tutorial, or lab.
July 1, 2009: Public holiday. No lecture, tutorial, or lab.
Week 8 July 8, 2009: Quiz 2. Discussions of Project.
Project Deliverables 2 Due midnight Saturday July 11, 2009.
Week 9 July 15, 2009: Implementation and Testing.
Coding standards. Refactoring.
Introduction to testing: error, fault, failure; verification, validation;
correctness, robustness, reliability.
Introduction to testing: test plan, test suite, test case, test data.
Test infrastructure.
Read Larman chapters 17-19, 25, 26 (GRASP principles; design patterns;)
Read Larman chapter 21 (test--driven development and refactoring)
Read Software testing
Slides: GRASP Principles and Design
Slides: GoF Design Patterns
Slides:Validation and Verification; Testing
Week 10 July 22, 2009: Testing (continued).
Approaches to creating test suites/test cases/test data.
Slides:Validation and Verification; Testing
Slides:Principles
Week 11 July 29, 2009: Quiz 3. Project discussion.
Project Deliverables 3 Due midnight Saturday August 1, 2009.
Week 12 August 5, 2009: Recap: putting it all together.
Aligning priorities on qualities.
Recognizing risks early.
Working system early.
Testing early.
Week 13 August 12, 2009: Project demonstrations.
Project Deliverables 4 Due midnight Saturday August 15, 2009.
A time slot of 45 minutes will be scheduled for each team for the project demonstration.
Bring prepared a powerpoint presentation with the three items included in the presentation:
(1) Individual contributions (2) Project features (3) Outcomes.
Be prepared to demo your system for its features (as described in (2) of the presentation) as well.
All members of the team need to attend. Everyone's individual contribution must be part of the presentation.
We will schedule this in H-823.
Tutorials begin in week 2.
Basic tools: Java, Eclipse, JUnit.
Basic Java project in Eclipse.
Java object serialization.
Java tools for spreadsheets in .csv and .xls formats
More on JUnit and developing test cases, test suites.
Data Gateways, data mappers, and the data management layer.
MVC architecture: Java Swing, the Domain Model package.
Introduction to mySQL and JDBC.
2009-08-11: The fourth project deliverables are due Saturday August 15, 2009 at 11:59pm via electronic submission. Submit a .tar.gz version of your source code (including JUnit tests) as 'program 4' and a short summary of your test plan and test results: basically telll me how thoroughly you tested and whether there are still outstanding bugs or issues.
2009-08-11: Demos will take place in H-823 on Wednesday August 12, 2009. 17:45 Team 3; 18:45 Team 2; 19:45 Team 1.
A time slot of 45 minutes will be scheduled for each team for the project demonstration.
Bring prepared a powerpoint presentation with the three items included in the presentation:
(1) Individual contributions (2) Project features (3) Outcomes.
Be prepared to demo your system for its features (as described in (2) of the presentation) as well.
All members of the team should attend if possible. Everyone's individual contribution must be part of the presentation.
2009-08-11: Quiz 3 Marks are available.
2009-06-20: Quiz 3 will take place in FG-355 on Wednesday July 29 starting at 18:45. It is a closed book exam lasting 60 minutes. It will cover all the material to date, with emphasis on design, testing, verification and validation. It will also cover GRASP principles and design patterns relevant to your project. Questions wil be similar in style to Quiz 1 and Quiz 2.
2009-06-20: Quiz 2 Marks are available.
2009-07-15: The third project deliverables will be due Saturday August 1, 2009 at 11:59pm via electronic submission. Submit a .tar.gz version of your source code (including JUnit tests) as 'program 3' and a design document as 'project 3'.
2009-06-28: The second project deliverables will be due Saturday July 11, 2009 at 11:59pm via electronic submission. Submit a .tar.gz version of your source code (including JUnit tests) as 'program 2', and the use case document as 'project 2'. The use case document (see an example) should contain a use case diagram to provide the context for the overall system, together with a description of the actors and the major use cases. Choose an appropriate level of detail for each use case. The document should also include a (problem) domain model consisting of a UML class diagram and explanatory text.
Quiz 2 will take place in FG-355 on Wednesday July 8 starting at 18:45. It is a closed book exam lasting 60 minutes. It will cover all the material to date, with emphasis on requirements, domain model, uses cases and scenarios, layered architecture, model-view-control, and responsibilities. Questions wil be similar in style to Quiz 1, however, Quiz 2 may also include true/false questions.
2009-06-17: Marks are available.
2009-06-06: The link for the electronic submission systems is here. Documents should be submitted as "Project 1" and Source code as "Program 1".
2009-05-27: Quiz 1 will take place in FG-355 on Wednesday June 3 starting at 18:45.
It is a closed book exam lasting 60 minutes. It will cover all the material to date: week 1 to 4.
Requirements will be included, but not the domain model, use cases, scenarios, and systems operations.
Here are some
sample questions.
2009-05-20: According to official class list, no one has dropped the course.
2009-05-06: Note change of room for tutorial.