Jump to course:
iact

OO Analysis & Design using UML

Overview

UML is a standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems. UML (Unified Modeling Language) is a pictorial language used to make software blue prints.

Although UML is generally used to model software systems but it is not limited within this boundary. It is also used to model non software systems as well like process flow in a manufacturing unit etc.


UML is not a programming language but tools can be used to generate code in various languages using UML diagrams.

This course provides the foundations to designing software systems using the UML language.

Specify and design Object Oriented software systems using the UML language.  

Why we need the Object Oriented Approach
Characteristics of modern, real world complex distributed systems. Issues in modern systems development. Managing complexity, mission critical systems. Industrial strength software & the bottom-line. Differences between traditional systems and complex systems. Why we need more than the structured approach for modern systems. The track record of OO – does it deliver?

Object Oriented Concepts
The OO recursive architecture and basic rules of OO Programming. The four fundamental OOAD principles. Objects: attributes, behaviors, types, states and identity. Classes: abstraction, inheritance and hierarchies Polymorphism and encapsulation. Object and class decompositions. OO and agented systems. Managing complexity with OO.

Modeling and the OO SDLCs
The role of modeling in building systems. Overview of the Unified Modeling Language (UML). Software SDLCs and why we use them. SEI Capability Maturity Model The Unified Software Development Process. Incremental and iterative – how it works. USDP differences from the old waterfall SDLC. Major workflow overview and associated models. Use case driven and Architecture-centric.

Architectural Design
OO Concepts for Architectural Modeling. Architectural Design. The hands-on drawing exercises will teach you to. Perform domain analysis. Create Actors and Use Cases. Develop primary and secondary scenarios. Use CRC cards to discover potential domain objects. Create sequence diagrams. Create class and object interaction diagrams. Create a component based Architecture for the problem domain. Utilize state transition and activity diagrams. Create package and deployment diagrams. Discover opportunities for applying Design Patterns.
Requirements Workflows

Client perceived needs, root causes and real needs. System description & the associated risk analysis. Identifying stakeholders. Identifying candidate requirements. Prioritizing requirements for development. Modeling business process. Identifying and documenting non-functional requirements.

Using Use Cases
Constructing the Use Case Model to document functional requirements. Discovering actors and their use cases. Refining and prioritizing use cases. Primary and secondary scenarios. Diagramming and documenting use cases. Identifying and documenting exceptions and “abuse” cases.
Analysis Workflow and Business Modeling

The conceptual domain model – business objects. Discovering analysis classes and relationships. Analysis objects and stereotypes. Business workflows, analysis packages and system services. Robustness analysis – rationalizing the analysis model. Business actors and business use cases. Discovering and documenting collaborations.

Design Workflow
Use-case driven design – tracing design classes back to analysis classes. Developing design subsystems from analysis packages. Architecture-centric prioritizing of use cases for implementation. Using interfaces in design for effective development. Creating architectural based design classes and subsystems. Class diagrams as lueprints – detailing classes and using statecharts. Interaction modeling and describing functionality. Verifying the design models – use case realization

Implementation Workflow
Moving from design to code: design classes to components. Implementing design classes, subsystems and interfaces in Java. Implementing designs as reusable components. Object construction – aggregation and inheritance. Multithreaded implementations. Developing robust code and a testing model. Using Java interfaces for flexibility and reuse. Frameworks, themes and patterns.

Design Patterns
What patterns are and why we use them. Major themes in patterns -decoupling and objectification. Levels of patterns and anti-patterns. Overview of the major design patterns. Writing patterns, pros and cons of patterns.

Systems Analysts and Software Designers who wish to work with UML to design and develop software systems. 
This five day workshop tests your mettle with comprehensive team exercises and drawing labs, laying a solid groundwork for any developer to easily move into an object-oriented programming environment. Course participants are provided with a manual containing fully worked examples and explanations of the techniques covered in this course.

5 Days
 

Course Testimonials

“The trainer’s knowledge of the subject matter was impeccable and this, matched with the very relevant course materials, ensured the course was a big success. We would certainly use Software Paths again for training in the future.”

Kainos

 
 

Start Dates

Looking for course dates? Find dates for your course here.


Find a Date