OO Development using UML and Java

Note. This course follows a Quality or Test First process and includes writing code as part of the course. If you need to use a process that is compatible with the Unified Process, then the OO Development using UML will be more appropriate.

All Software Development methods use feedback from the delivered code to improve both the product and the process. With the move to Object Technology, teams are finding that the shorter the feedback cycle, the better the results. Peter Coad's latest Java book talks about "Delivering frequent, tangible, working results". The new eXtreme Programming methodology typically uses a 3 week development increment going from requirements to tested running code on a subset of the system requirements.

In part these (and other) methodologies are a reaction against the long, slow and risky waterfall development process. Due to the inherent uncertainty in software development, projects often end up in the unfortunate position of running out of time towards the end of a project. Too much time is spent up front doing requirements capture and design for features that eventually have to be dropped or delivered in a later release.

This course is different. It uses an incremental, iterative process together with Incremental Requirements to ensure that the requirements are captured just in time for development to start working on them. Starting with a vision for the system, low precision use cases are prioritized, then the implementation details for a few Use Cases are captured, acceptance tests created and used to drive the development process. Unit tests are written for all code prior to writing the code, UML diagrams are used where appropriate to communicate and evaluate design decisions.

The intention behind this course is to allow experienced developers to leverage their current knowledge to gain a fast start in Object Oriented Development. The course provides developers with the tools needed to talk about the Quality of Requirements and Designs in Object Projects.

The course focuses on the needs of small development teams through the use of relatively "low ceremony" techniques and methods. The use of models for communicating ideas is emphasized, as is the need for an iterative, incremental development lifecycle.

Why this course teaches the UML

The Unified Modeling Language (UML) is the successor to the wave of Object Oriented Analysis and Design notations that appears in the 80’s and 90’s. The UML 1.1 was ratified by the OMG (Object Management Group) as the standard modeling language for use in Object Oriented Development. This course addresses the needs of practitioners for a fast start in the basics of the UML to improve the Quality and Productivity of Object Technology Projects. CASE tools are used where appropriate to assist in the construction of the UML diagrams.

Why this course uses Java

Although this course does not teach Java, it uses Java so participants see the entire development process from capturing requirements using Use Cases to testing running code using JUnit. This end to end coverage of the whole development process enables developers to see where particular parts of the UML are appropriate and ensures that by the end of the course they have practiced all of the necessary activities and techniques.

Why cover the entire process? Because teams need to see how all of the techniques fit together so that they can learn how all of the activities interrelate. Teams also learn how to effectively manage the different levels of precision and accuracy as they move from requirements to tested running code.

Course Format and Style

The course is fast paced and interactive, using "toy" problems and a small case study to give participants hands-on experience in the use of the various techniques. Initially the focus is on getting familiar with the Object terminology and learning what makes a project truly Object Oriented. The focus then shifts to using Use Cases for Requirements Capture, and validating these by the use of a Business Object Model.

Using these Use Cases and the Business Object Model, the focus then shifts to the design of the implementation, using Responsibility Driven Design to design the Classes within the implementation packages. The focus of the last part of the course is on Quality Assurance and Testing, how can the design and implementation be validated against the Requirements.

Duration and intended Audience

4 Days (tailored versions for companies can also be provided, in-house versions of this course require a minimum of 6 participants)

Experienced Analysts and software designers/developers with some knowledge of Object Concepts or who will soon be undertaking an Object project. Some knowledge of Java is useful if participants want to be able to implement and test their designs in code. Some out of class work is useful to allow participants to build a more complete system.

Course Goals

In addition to the formal aspects of OO Development, this course also covers the creative aspects of object modeling.

Course Content

  1. The realities of Objects
    • Understanding the Basic OO Concepts
    • Understanding OO development process
    • How OO Methodologies manage risks
    • Moving from Classes to Code is a design activity
    • The role of the UML in Software Development
  2. Capturing Requirements for Prioritization
    • Project initiation and scoping
    • Risk Management
    • Managing uncertainty and scope creep
    • System Envisioning
  3. Project planning and estimation
    • Managing uncertainty
    • Evaluating the Economic Feasibility of a Project
    • Acceptance Testing and Planning Releases
  4. Capturing Requirements for Implementation
    • Capturing Requirements using Use Cases
    • Creating acceptance test plans
    • Understanding the need for Test Harnesses
  5. Designing with tests
    • Using informal OO Design techniques to create effective application architectures
    • Capturing Requirements Using Use Cases
    • Using CRC Cards to create OO Designs
    • Documenting designs using the UML
    • Creating Test cases from Use Cases
  6. Coding, Testing and Refactoring in Java
    • Understanding what testing means
    • Understanding why testing must be automated
    • Recognizing the limitations of testing
    • Using the JUnit testing framework to test classes
  7. Communicating and evaluating the design
    • Evaluating the Technical Feasibility of a Project
    • Quality Assurance
    • Documenting Designs using CASE tools
  8. Pragmatic Issues
    • Understanding the Impact of Evolutionary Delivery
    • The realities of OO Development
    • The limitations of OO CASE tools
    • Pitfalls in OO Development

Recommended texts