A study of design methods and their use in the correct implementation, maintenance and evolution of software systems. Topics include design, implementation, testing, documentation needs and standards, support tools. Students design and implement components of a software system. Weekly 1.5 hour laboratory.

1. EECS2001
2. EECS2031
3. MATH1090
4. General prerequisites
   1. EECS2011
   2. GPA of 4.5 or better over all completed major CS courses

See here.

Software designers are experts at developing software products that are correct, robust, efficient and maintainable. Correctness is the ability of software products to perform according to specification. Robustness is the ability of a software system to react appropriately to abnormal conditions. Software is maintainable if it is well-designed according to the principles of abstraction, modularity, and information hiding. At the end of the course, students will be able to:

1. Specification: Describe software specifications via Design by Contract, including the use of preconditions, postconditions, class invariants, loop variants and invariants

2. Construction: Implement specifications with designs that are correct, efficient and maintainable.

3. Testing: Develop systematic approaches to organizing, writing, testing and debugging software.

4. Analysis: Develop insight into the process of moving from an ambiguous problem statement to a well-designed solution.

5. Architecture: Design software using appropriate abstractions, modularity, information hiding, and design patterns.

6. Tools: Develop facility in the use of an IDE for editing, organizing, writing, debugging, testing and documenting code including the use of BON/UML diagrams for documenting designs. Also the ability to deploy the software in an executable form.

7. Documentation: Develop the ability to write precise and concise software documentation that also describes the design decisions and why they were made.

• Core Object-oriented Concepts and Techniques including genericity, polymorphism, multiple inheritance, strong typing and dynamic binding
• Design by Contract (preconditions, postconditions, class invariants, and loop variants and invariants). Command-query separation principle.
• Hoare logic, structured development and reasoning about program properties
• Design Documentation and UML/BON diagrams
• Separation of concerns, modularity, clean interfaces, information hiding, single choice principle, and programming to interfaces not implementations
• Debugging, Unit Testing and Test Driven Development
• Abstract Data Types, Modularity and Information Hiding
• Design Patterns
• Documenting Design Decisions and demonstrating that code satisfies the design