Home Books Software Projects Forums

Object-Oriented Analysis and Design
Study Notes

Section 1 - Development Process

Reposted with permission from the original author:
Ezequiel Cuellar of CrossLogic Corporation http://www.crosslogic.com

Object-Oriented Analysis

  • Emphasis is on finding and describing the objects or concepts of the problem domain. Focus on what the system must do. Do the right thing.

Object-Oriented Design

  • Emphasis is on defining software objects and how they collaborate to fulfill requirements. Focus on how the system will do it. Do the thing right.
  • A critical, fundamental ability in OOA/D is to skilfully assign responsibilities to software components.

Iteration

  • Is a short, time-boxed and risk-driven mini project whose outcome is a tested, integrated and executable system. Each iteration includes its own requirements analysis, design, implementation and testing activities.
  • An iteration length is recommended to be between two and six weeks unless the team size is massive.
  • For a large team of developers (200) an iteration length is months instead of weeks.
  • If it seems that it will be difficult to meet an iteration deadline, the recommended response is to remove tasks or requirements to a future iteration. Date slippage is discouraged.

Refactoring

  • Refactoring is about changing the internal structure of the system in order to make it easier to understand and work with.
  • Refactoring is made easier by the following steps:
    • Don't refactor a program and add functionality to it at the same time.
    • Make sure you have a good test in place before you begin refactoring.
    • Take short, delivered steps.
  • During Refactoring is a good idea to keep an eye on the amount of code thrown away in each iteration.
  • Be suspicious if less that 10 percent of the previous code is discarded each time.
  • Full integration should be done daily.

Iterative and Incremental Development

  • During the iterative and incremental development the system grows incrementally over the time iteration by iteration.
  • Feedback and Adaptation plus short iterations are the core drivers of iterative and incremental development.
  • Early iterations are farther from the true path of the system. In late iterations a significant change in requirements is rare.
  • While implementing code an early activity to do at the start of every iteration is to synchronize the design diagrams. The earlier diagrams of the iteration will not match the final code and they need to be synchronized before being extended with new design results.
  • There can be iterations in all phases (inception, elaboration, construction and transition) but Construction is the key phase in which to iterate.

Inception

  • The intent of inception is to establish some initial common vision for the objectives of the project and decide if it is worthwhile to proceed doing deeper exploration that occurs in elaboration or stop.
  • Inception is 1 week long for most projects.
  • During inception lightweight use case analysis is performed at least the names of most use cases and actors should be identified.
  • Most use cases are written in brief format.
  • Most influential and risky quality requirements are identified.
  • Technical proof of concept prototypes of any tricky parts of the use cases are written.
  • High-level architecture and components are proposed.
  • Plan for the first iteration is written.
  • Recommendations are made on what components to buy/build/reuse.

Elaboration

  • Build the core architecture, resolve the high-risk elements, define most requirements and estimate the overall schedule and resources.
  • Adaptively design, implement and test the core and risky parts of the architecture during early iterations.
  • Programming and testing should be started early.
  • Adapt based on feedback from test, users and developers.
  • Elaborations consist of between two and four iterations long and have heavy use case analysis.
  • In elaboration 80-90% of the use cases are written in detail.
  • Elaboration takes about a fifth (20%) of the total length of the project.
  • Two events are key indicators that elaboration is complete:
    • The developers can feel comfortable providing estimates to the nearest person-week of effort of how long it will take to build each use case
    • all the significant risks have been identified and the major ones are understood to the extent that you know how you intend to deal with them.

Construction

  • Iterative implementation of the remaining lower risk and easier elements, and preparation for deployment.

Transition

  • Beta tests, deployment, performance tuning and user training.
  • Optimization (performance improvement) should be left always at the end.
  • During transition there is no development to add functionality unless is small and absolutely essential.

Planning and Project Management

  • The criteria used to rank requirements as high, medium and low across iterations is based on:
  • Risks are classified in requirements, technological, skill and political.
  • Coverage implies that all major parts of the system are at least touched on in early iterations.
  • Criticality refers to functions of high business value.
  • Early iterations must implement high ranking scenarios
  • Use Case implementation may be spread across iterations.
  • The essence of building a plan involves setting up a series of iterations for construction and defining the functionality to deliver in each one.
  • The customer should divide the use cases according to their business value into three piles: high, medium and low.
  • The developers then divide the use cases according to the development risk.
  • The next step is to estimate the length of the time each use case will require.
  • To perform a calculation of how many iterations are needed for the project multiply the number of developers by the iteration length and the divide the result by the load factor, this will give you how much development you can do in an iteration, then add up your time for all use cases, divide the effort per iteration and add 1 for luck and this will give you the first estimate of how many iterations are needed. For example:
  • 5 developers and iteration length is 2 weeks = 10 person-weeks
  • Sum of use cases = 200 person-weeks
  • 200 / 10 + 1 = 21 iterations (42 weeks elapse time)
  • For transition allocate 10 % to 35 % of the construction time for tuning and packaging for delivery.
  • Then add a contingency factor: 10 percent to 20 percent of the construction time depending how risky things look.
  • Add this factor to the end of the transition phase. You should commit to deliver at the end of contingent time.

Credits:

Reposted with permission from the original author:
Ezequiel Cuellar of CrossLogic Corporation http://www.crosslogic.com

Contributors:

  • cfw
  • SZ



Valid XHTML 1.0!