Object-Oriented Software Engineering

Course Overview

Your Course Goal: Refine your methdology of building software in a team

As with everything else in life, organization is key
We study fundamental concepts and principles of how to build software

Engineering design methodology

Let us first consider how "real engineers" work: its time to build a bridge/robot/building.

Get the requirements the bridge is supposed to meet
Make a complete design (blueprints, materials, building method, etc)
Build (implement) it
Test it to make sure its going to work.

Building software is not building bridges

Classic engineering design methods are "one pass": get a pretty much complete design, then implement (build) it.
And with good reason: building a wall and then ripping it down to redo it is expensive!
- (in practice this does happen because there always are a few mistakes in the design that are so bad that they need to be redone)
Initial software design methods borrowed from engineering design: the waterfall model of software design (the four phases above)
But, the cost of tearing down and rebuilding software is orders of magnitude less, so it is not the best methodology

Modern Software Design Methodology

Here is a summary of the way good software is designed today

Requirements-design-implement-test are the core tasks
But, don't do them in monolithic sequence; iterate instead
--add/change requirements as system evolves, modify design to increase flexibility, etc
Provide multiple releases of the software, with ever increasing functionality
Have a plan, but it too will evolve so don't over-plan at the start. Plan and then replan, replan, replan.

The Tasks of Software Design

Let us reflect on everything we are spending time on when developing software -- we want to better organize these activities.

The four core production tasks are again:

Produce requirements; design; implement; test.

Other tasks include

Plan what to do and in what order; start with some plan and evolve it to an improved plan
Research the problem space and the
- software architecture -- what existing software libraries/packages/applications to use
- hardware and other infrastructure to use
- programmer tools (CASE tools) to use
commercially available to solve the problem
Structure and restructure the team so things are working well
Document what you are doing in the four core tasks so everyone is clear how things are proceeding.

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
The Unified Software Development Process (USDP / RUP) (by the Three Amigos, Booch, Rumbaugh, Jacobson)
Bertrand Meyer's Object-Oriented Software Construction 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

Requirements are expressed in the form of use-cases: scenarios of what the application is supposed to accomplish.
The act of building use-cases brings out more details about what the software is supposed to be doing.
(Alternative to use-cases: feature-driven development -- similar but express capabilities in terms of application features)

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
OO Design Principles show better ways to solve common problems, in both design and implementation

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