Object Oriented Analysis and Design using UML

Unit 3

Unit 3
Structure: 3.1 Introduction Objectives

Object Oriented Systems Development Life Cycle

3.2 The software development process 3.3 Building high-quality software 3.4 Object-oriented systems development: A use case approach 3.5 Reusability 3.6 Summary 3.7 Terminal Questions

3.1 Introduction
The essence of software development process which consists of analysis, design, implementation, testing, and refinement is to transform users needs into a software solution that satisfies those needs. You may see the code only after 25 percent of the development time, because you need to spend more time gathering requirements, developing the requirements model and an analysis model, then turning them into the design model. Now you can develop code quickly. However, you should construct a prototype. The emphasis is intended to promote the building of high-quality software. Objectives: After studying this unit, you will understand The software development process How to build quality software? Use case driven approach to object oriented systems development Software reusability
Page No. 21

Sikkim Manipal University

Object Oriented Analysis and Design using UML

Unit 3

3.2 The Software Development Process

System development can be viewed as a process. Furthermore, the development itself, in essence, is a process of change, refinement, transformation, or addition to existing product. The process can be divided into small, interacting phases subprocesses. Each subprocess must have the following: A description in terms of how it works Specification of the input required for the process Specification of the output to be produced

Generally, the software development process can be viewed as a series of transformations, where the output of one transformation becomes the input of the subsequent transformation Transformation 1 (analysis) translates the users needs into system requirements and responsibilities. Transformation 2 (design) begins with a problem statement and ends with a detailed design that can be transformed into an operational system. Transformation 3 (implementation) refines the detailed design into the system deployment that will satisfy users needs. An example of the software development process is the waterfall approach, which starts with deciding what is to be done. Once the requirements have been determined, we next must decide how to accomplish them. This is followed by a step in which we do it, whatever it has required us to do. We then must test the result to see if we have satisfied the users requirements. Finally, we use what we have done. In the real world, the problems are not always well-defined and that is why the waterfall model has limited utility.

Sikkim Manipal University

Page No. 22

Object Oriented Analysis and Design using UML

Unit 3

Problem Transformation 1 What are the uses of the system? Analysis Transformation 2

Statements

Design Transformation 3

System

Implementation

Software

Detail

Product

Fig. 3.1: Software process reflecting transformation from needs to a software product that satisfies those needs

What How Do It Test Use

Fig. 3.2: The waterfall software development process

Sikkim Manipal University

Page No. 23

Object Oriented Analysis and Design using UML

Unit 3

3.3 Building high-quality software

To achieve high quality in software we should be able to answer the following questions: How do we determine that the system is ready for delivery? Is it now an operational system that satisfies users needs? Is it correct and operating as we thought it should? Does it pass an evaluation process?

Blum describes a means of system evaluation in terms of four quality measures: Correspondence measures how well the delivered system matches the needs of the operational environment, as described in the original requirements statement. Validation task of predicting correspondence. Correctness measures the consistency of the product requirements with respect to the design specification. Verification exercise of determining correctness.

Verification: Am I building the product right? Validation: Am I building the right product? Validation begins as soon as the project starts, but verification can begin only after a specification has been accepted.

Sikkim Manipal University

Page No. 24

Object Oriented Analysis and Design using UML

Unit 3

Validation

Verification

Needs

Requirements Correctne ss

Design

Software

Correspondenc e Fig. 3.3: Four quality measures (correspondence, correctness, validation, and verification) for software evaluation.

3.4 Object oriented systems development: A use-case driven approach

The object-oriented software development life cycle (SDLC) consists of three macro processes: object-oriented analysis, object-oriented design, and object-oriented implementation. Object oriented systems development includes these activities: Object-oriented analysis use-case driven Object-oriented design Prototyping Component-based development Incremental testing

Sikkim Manipal University

Page No. 25

Object Oriented Analysis and Design using UML

Unit 3

Build a use case model Object Analysis Iteration & Reuse Analysis Validate / Test

Using Tools CASE and / or OO Programming Languages Implementation User Satisfaction, Usability & QA Tests

Design Classes, define attributes & methods

Build object & dynamic model

Build user interface & Prototype

User Satisfaction Test, Usability Test & QA Test Design

Fig. 3.4: The object-oriented systems development approach. Object-oriented analysis corresponds to transformation 1; design to transformation 2, and implementation to transformation 3 of Fig. 3.1.

Sikkim Manipal University

Page No. 26

Object Oriented Analysis and Design using UML

Unit 3

OOA: Use Case Model

OOA: Courses of action Use Case Models

OOA: Identify Actors

Object interaction diagrams, etc OOA: Object Model

Design Classes UI

Dynamic Model

OOD: Dynamic Model

Testing: Usage Scenarios

Fig. 3.5: By following the life cycle model of Jacobson et al, we produce designs that are traceable across requirements, analysis, implementation, and testing.

Object-oriented analysis Use-case driven The object-oriented analysis phase of software development is concerned with determining the system requirements and identifying classes and their relationships to other classes in the problem domain. Actors: The users of the system. Use case: A typical interaction between a user and a system that captures users goals and needs. You capture a use case by talking to typical users, discussing the various things they might want to do with the system. Scenarios: Used to help analysts understand requirements. Scenarios are a great way of examining who does what in the interactions among objects and what role they play, that is, their interrelationships. Collaboration: The intersection among objects roles to achieve a given goal is called collaboration. The scenarios represent only one possible

example of the collaboration. To understand all aspects of the collaboration

Sikkim Manipal University Page No. 27

Object Oriented Analysis and Design using UML

Unit 3

and all potential actions, several different scenarios may be required, some showing usual behaviors, others showing situations involving unusual behavior or exceptions. Use-case modeling: Expressing these high-level processes and

interactions with customers in a scenario and analyzing it is referred to as use-case modeling. In a payroll system, the tangible objects might be paycheck, employee, worker, supervisor, office administrator; and the intangible objects might be tables, data entry screen, data structures, and so forth. The 80-20 rule generally applies for documentation: 80 percent of the work can be done with 20 percent of the documentation. Object-oriented design The goal of object-oriented design is to design the classes identified during the analysis phase and the user interface. During this phase, we identify and define additional objects and classes that support implementation of the requirements. The activities and focus of object-oriented analysis and object-oriented design are intertwined grown, not built. First, build the object model based on objects and their relationships, then iterate and refine the model: Design and refine classes Design and refine attributes Design and refine methods Design and refine structures Design and refine associations

Sikkim Manipal University

Page No. 28

Object Oriented Analysis and Design using UML

Unit 3

Here are a few guidelines to use in your object-oriented design: Reuse, rather than build, a new class. Know the existing classes. Design a large number of simple classes, rather than a small number of complex classes. Design methods. Critique what you have proposed. If possible, go back and refine the classes. Prototyping Although the object-oriented analysis and design describe the system features, it is important to construct a prototype of some of the key system components shortly after the products are selected. Essentially, a prototype is a version of a software product developed in the early stages of the products life cycle for specific experimental purposes. A prototype enables you to fully understand how easy or difficult it will be to implement some of the features of the system. It also can give users a chance to comment on the usability and usefulness of the user interface design and it lets you assess the fit between the software tools selected, the functional specification, and the users needs. Prototype can further define the use cases, and it actually makes usecase modeling much easier. Prototypes have been categorized in various ways: A horizontal prototype is a simulation of the interface (that is, it has the entire user interface that will be in the full-featured system) but contains no functionality. A vertical prototype is a subset of the system features with complete functionality. The principal advantage of this method is that the few

Sikkim Manipal University

Page No. 29

Object Oriented Analysis and Design using UML

Unit 3

implemented functions can be tested in great depth. prototypes are hybrid between the two.

Generally

An analysis prototype is an aid for exploring the problem domain. It is used to inform the user and demonstrate the proof of a concept. In full featured system, only the concept is used and not the code.

A domain prototype is an aid for the incremental development of the ultimate software solution. This can evolve into a deliverable product.

The purpose of the prototype review is threefold: 1. To demonstrate that the prototype has been developed according to the specification and that the final specification is appropriate. 2. To collect information about errors or other problems in the system, such as user interface problems that need to be addressed in the intermediate prototype stage. 3. To give management and everyone connected with the project the first (or it could be second or third ) glimpse of what the technology can provide. Implementation: Component-based development CASE Tools: Computer Aided Software Engineering (CASE) tools allow their users to rapidly develop information systems. The main goal of CASE technology is the automation of the entire information systems development life cycle process using a set of integrated software tools, such as modeling, methodology, and automatic code generation. However, most often, the code generated by CASE tools is only the skeleton of an application and a lot needs to be filled in by programming by hand. A new generation of CASE tools is beginning to support Component Based Development. Component Based Development: CBD is an industrialized approach to the software development process. Application development moves from custom development to assembly of prebuilt, pretested, reusable software
Sikkim Manipal University Page No. 30

Object Oriented Analysis and Design using UML

Unit 3

components that operate with each other. Two basic ideas underlie component-based development. First, the application development can be improved significantly if applications can be assembled quickly from prefabricated software components. Second, an increasingly large collection of interpretable software components could be made available to developers in both general and specialist catalogs. Put together, these two ideas move application development from a craft activity to an industrial process fit to meet the needs of modern, highly dynamic, competitive, global businesses. Software Components: The software components are the functional units of a program, building blocks offering a collection of reusable services. A software component can request a service from another component or deliver its own services on request. The delivery of services is independent, which means that components work together to accomplish a task. In short, the object-oriented concept addresses analysis, design, and programming, whereas component-based development is concerned with the

implementation and system integration aspects of software development. Rapid Application Development: RAD is a set of tools and techniques that can be used to build an application faster than typically possible with traditional methods. The term often is used in conjunction with software prototyping. RAD does not replace the system development life cycle but complements it, since it focuses more on process description and can be combined perfectly with the object-oriented approach. The task of RAD is to build the application quickly and incrementally implement the design and user requirements, through tools such as Delphi, Visual Age, Visual Basic, or Power Builder.

Sikkim Manipal University

Page No. 31

Object Oriented Analysis and Design using UML

Unit 3

Legacy Programs

Legacy Data

Open Connectivity

Legacy Screens

Legacy S/W packages

Fig. 3.6: Reusing legacy system via component wrapping technology

Incremental testing If you wait until after development to test an application for bugs and performance, you could be wasting thousands of dollars and hours of time. Testing should be integral part of SDLC.

3.5 Reusability
A major benefit of object-oriented system development is reusability, and this is the most difficult promise to deliver on. You must effectively evaluate existing software components for reuse by asking the following questions as they apply to the intended application: Has my problem already been solved? Has my problem been partially solved? What has been done before to solve a problem similar to this one?

The reuse strategy can be based on the following: Information hiding (encapsulation) Conformance to naming standards Creation and administration of an object repository Encouragement by strategic management of reuse as opposed to constant redevelopment
Sikkim Manipal University Page No. 32

Object Oriented Analysis and Design using UML

Unit 3

Establishing targets for a percentage of the objects in the project to be reused (i.e. 50 percent reuse of objects)

3.6 Summary
This unit has given an overview of software development process with emphasis on use case driven approach. Also object oriented analysis and design concepts were discussed.

3.7 Terminal Questions

1. Give the criteria for building high quality software. 2. Explain the use case driven approach to object oriented systems development process. 3. What do you mean by prototyping? 4. Explain the various tools for software implementation. 5. Discuss software reusability in detail.

Sikkim Manipal University

Page No. 33