OOSE

Course Goal: Improve your ability to build a medium scale piece of software working in a team

The standard design methodology for building real things

There is a standard design methodology whenever you want to build buildings, devices, etc.

1. Get the requirements the e.g. bridge is supposed to meet
2. Make a complete design (blueprints, materials, building method, etc)
   -- this is broken down as an initial design plus numerous refining iterations on it
3. Build (implement) it
4. Test it to make sure its going to work.

Modern Software Design Methodology

• Requirements-design-implement-test are still key tasks
• But, they are never performed in a perfectly monolithic sequence
  --you should change requirements as understanding of the domain and what the app can do evolves, and refactor the design in light of any new requirements.
• Provide multiple releases of the software, with ever increasing functionality

Schools of Object-Oriented Software Development

In this course we cover ideas representing a synthesis of best practices from many schools, including:

• The Classic Object Oriented Design of Jakobson, Wirfs-Brock, et al
• Extreme Programming (XP), and Agile Software Development
• Refactoring methodology
• Design Patterns by the Gang of Four
• UML, the Unified Modeling Language, for drawing pictures of designs.

Extended Syllabus and Project iterations

Here we give a more wordy version of the syllabus and of the project iteration structure. The lecture topics and project iterations are in synch.

See the projects homepage for details beyond what is covered here »

Requirements (Project Iteration 1)

Find out from the customers what the software product really should do.

Use-case-driven requirements

• The primary driver for fleshing out what is required by the software are use-cases: scenarios of what the application is supposed to accomplish.
• So, the main task of requirements is writing use-cases
• There are also several other important tasks: sketching user interfaces, researching architecture, tools, and platforms, etc.

Design (Project Iteration 2)

Find and refine the classes/packages/architecture, starting from requirements.

• Domain analysis is figuring out your initial object structure given your use-cases, feature lists, etc.
• In Object-Oriented Design, progress is eased by focusing on objects and their responsibilities for and relationships with one another

Related design topics

• Design patterns are advanced object relationships that are often useful in object-based design
  -- covered at the end of the course due to lack of room earlier
• Use object-based UML diagrams in the design: a picture is worth a thousand words
  
  • UML is the Unified Modeling Language, the diagramming standard
  • UML will not be the topic of any one lecture, it will be spread throughout the course
• Also, we cover use of object-based design techniques and UML on the underlying problem domain itself: domain modeling

Implementation and Testing (Project Iterations 3-6)

Implementation

• We will cover some Java-specific implementation principles.

Unit Testing

• Code unit (individual feature) tests as you write code
• Keep testing completely automated so you will find it easy to run the tests regularly

Iterating

• Don't be a hero and implement everything at once: divide into manageable iterations (iterations 3-6 for the project).
• Make a plan on what features or use-cases you want to implement, in what order.
• Improve existing code by refactoring it: change code in very small ways without changing overall functionality
  --refactoring will be a distinct lecture topic