Applying UML and Patterns An Introduction to Object Oriented Analysis and Design and Iterative Development 2nd Edition by Craig Larman 0130925691 9780130925695

Applying UML and Patterns An Introduction to Object Oriented Analysis and Design and Iterative Development 2nd Edition by Craig Larman – Ebook PDF Instant Download/Delivery. 0130925691, 9780130925695

Full download Applying UML and Patterns An Introduction to Object Oriented Analysis and Design and Iterative Development 2nd Edition after payment

Product details:

ISBN 10: 0130925691

ISBN 13: 9780130925695

Author: Craig Larman

The world’s no.1 best-selling introduction to object-oriented analysis/design, iterative development, and the UML-now completely updated Applying UML and Patterns, second edition, helps any developer or student master the core principles and best practices of object-oriented analysis and design (OOA/D)-not just drawing UML, but really applying it in the context of software design. Renowned object technology and iterative methods leader Craig Larman presents three iterations of a single, cohesive case study, incrementally introducing the critical skills of OOA/D, while emphasizing the most essential activities, principles, and patterns. Coverage includes: *Requirements and Use Cases: Identifying and recording requirements *Domain Object Modeling: Understanding domain objects of interest, their attributes, and relationships *Architecture: Creating layered architectures that maximize applicationflexibility, robustness, and maintainability *Essential Object Design: Mastering key skills, including assigning responsibilities to objects, and designing collaborations with principles such as Information Expert, Indirection, and Protected Variations *Design Patterns: Creating robust objec, For all undergraduate courses in object-oriented analysis and design. Builds on the overwhelming success of the First Edition. The topics covered in this book are increasingly recognized as core competencies by virtually all contemporary computer science departments, and in virtually all computer science curricula. This book teaches object-oriented analysis and design through iterations of a single, cohesive case study incrementally introducing key OO&AD skills while emphasizing practical activities and principles. Renowned object technology leader Craig Larman introduces the popular UML 1.4 diagramming notation as a superior vehicle for expressing OO&AD thoughts. Since OOA&D should be taught (and practiced) within a coherent process, he presents a lightweight, agile version of the market-leading Unified Process (UP). Within his case study’s context, he also introduces patterns robust, best-practice solutions to the most widely encountered design problems., An update to the bestselling UML classic, this title has been revised to cover the unified process and Rational Software’s processes. Larman also shows developers how to make practical use of the most significant recent developments in object-oriented analysis and design.

Applying UML and Patterns An Introduction to Object Oriented Analysis and Design and Iterative Development 2nd Table of contents:

 

Introduction

Object-Oriented Analysis and Design

Applying UML and Patterns in OOA/D

Assigning Responsibilities

What Is Analysis and Design?

What Is Object-Oriented Analysis and Design?

An Example

The UML

Further Readings

Iterative Development and the Unified Process

Introduction

The Most Important UP Idea: Iterative Development

Additional UP Best Practices and Concepts

The UP Phases and Schedule-Oriented Terms

The UP Disciplines (was Workflows)

Process Customization and the Development Case

The Agile UP

The Sequential “Waterfall” Lifecycle

You Know You Didn’t Understand the UP When…

Further Readings

Case Study: The NextGen POS System

Introduction

The NextGen POS System

Architectural Layers and Case Study Emphasis

The Book’s Strategy: Iterative Learning and Development

Inception

Inception

Introduction

Inception: An Analogy

Inception May Be Very Brief

What Artifacts May Start in Inception?

You Know You Didn’t Understand Inception When…

Understanding Requirements

Introduction

Types of Requirements

Further Readings

Use-Case Model: Writing Requirements in Context

Introduction

Goals and Stories

Background

Use Cases and Adding Value

Use Cases and Functional Requirements

Use Case Types and Formats

Fully Dressed Example: Process Sale

Explaining the Sections

Goals and Scope of a Use Case

Finding Primary Actors, Goals, and Use Cases

Congratulations: Use Cases Have Been Written, and Are Imperfect

Write Use Cases in an Essential UI-Free Style

Actors

Use Case Diagrams

Requirements in Context and Low-Level Feature Lists

Use Cases Are Not Object-Oriented

Use Cases Within the UP

Case Study: Use Cases in the NextGen Inception Phase

Further Readings

UP Artifacts and Process Context

Identifying Other Requirements

Introduction

NextGen POS Examples

NextGen Example: (Partial) Supplementary Specification

Commentary: Supplementary Specification

NextGen Example: (Partial) Vision

Commentary: Vision

NextGen Example: A (Partial) Glossary

Commentary: Glossary (Data Dictionary)

Reliable Specifications: An Oxymoron?

Online Artifacts at the Project Website

Not Much UML During Inception?

Other Requirement Artifacts Within the UP

Further Readings

UP Artifacts and Process Context

From Inception to Elaboration

Introduction

Checkpoint: What Happened in Inception?

On to Elaboration

Planning the Next Iteration

Iteration 1 Requirements and Emphasis: Fundamental OOA/D Skills

What Artifacts May Start in Elaboration?

You Know You Didn’t Understand Elaboration When…

Elaboration Iteration 1

Use-Case Model: Drawing System Sequence Diagrams

Moving on to Iteration 1

Introduction

System Behavior

System Sequence Diagrams

Example of an SSD

Inter-System SSDs

SSDs and Use Cases

System Events and the System Boundary

Naming System Events and Operations

Showing Use Case Text

SSDs and the Glossary

SSDs Within the UP

Further Readings

UP Artifacts

Domain Model: Visualizing Concepts

Introduction

Domain Models

Conceptual Class Identification

Candidate Conceptual Classes for the Sales Domain

Domain Modeling Guidelines

Resolving Similar Conceptual Classes—Register vs. “POST”

Modeling the Unreal World

Specification or Description Conceptual Classes

UML Notation, Models, and Methods: Multiple Perspectives

Lowering the Representational Gap

Example: The NextGen POS Domain Model

Domain Models Within the UP

Further Readings

UP Artifacts

Domain Model: Adding Associations

Introduction

Associations

The UML Association Notation

Finding Associations—Common Associations List

Association Guidelines

Roles

How Detailed Should Associations Be?

Naming Associations

Multiple Associations Between Two Types

Associations and Implementation

NextGen POS Domain Model Associations

NextGen POS Domain Model

Domain Model: Adding Attributes

Introduction

Attributes

UML Attribute Notation

Valid Attribute Types

Non-primitive Data Type Classes

Design Creep: No Attributes as Foreign Keys

Modeling Attribute Quantities and Units

Attributes in the NextGen Domain Model

Multiplicity From SalesLineItem to Item

Domain Model Conclusion

Use-Case Model: Adding Detail with Operation Contracts

Introduction

Contracts

Example Contract: enterItem

Contract Sections

Postconditions

Discussion—enterItem Postconditions

Writing Contracts Leads to Domain Model Updates

When Are Contracts Useful? Contracts vs. Use Cases?

Guidelines: Contracts

NextGen POS Example: Contracts

Changes to the Domain Model

Contracts, Operations, and the UML

Operation Contracts Within the UP

Further Readings

From Requirements to Design in this Iteration

Introduction

Iteratively Do the Right Thing, Do the Thing Right

Didn’t That Take Weeks To Do? No, Not Exactly.

On to Object Design

Interaction Diagram Notation

Introduction

Sequence and Collaboration Diagrams

Example Collaboration Diagram: makePayment

Example Sequence Diagram: makePayment

Interaction Diagrams Are Valuable

Common Interaction Diagram Notation

Basic Collaboration Diagram Notation

Basic Sequence Diagram Notation

GRASP: Designing Objects with Responsibilities

Introduction

Responsibilities and Methods

Responsibilities and Interaction Diagrams

Patterns

GRASP: Patterns of General Principles in Assigning Responsibilities

The UML Class Diagram Notation

Information Expert (or Expert)

Creator

Low Coupling

High Cohesion

Controller

Object Design and CRC Cards

Further Readings

Design Model: Use-Case Realizations with GRASP Patterns

Introduction

Use-Case Realizations

Artifact Comments

Use-Case Realizations for the NextGen Iteration

Object Design: makeNewSale

Object Design: enterItem

Object Design: endSale

Object Design: makePayment

Object Design: startUp

Connecting the UI Layer to the Domain Layer

Use-Case Realizations Within the UP

Summary

Design Model: Determining Visibility

Introduction

Visibility Between Objects

Visibility

Illustrating Visibility in the UML

Design Model: Creating Design Class Diagrams

Introduction

When to Create DCDs

Example DCD

DCD and UP Terminology

Domain Model vs. Design Model Classes

Creating a NextGen POS DCD

Notation for Member Details

DCDs, Drawing, and CASE Tools

DCDs Within the UP

UP Artifacts

Implementation Model: Mapping Designs to Code

Introduction

Programming and the Development Process

Mapping Designs to Code

Creating Class Definitions from DCDs

Creating Methods from Interaction Diagrams

Container/Collection Classes in Code

Exceptions and Error Handling

Defining the Sale–makeLineItem Method

Order of Implementation

Test-First Programming

Summary of Mapping Designs to Code

Introduction to the Program Solution

Elaboration Iteration 2

Iteration 2 and its Requirements

Iteration 2 Emphasis: Object Design and Patterns

From Iteration 1 to 2

Iteration 2 Requirements

Refinement of Analysis-oriented Artifacts in this Iteration

GRASP: More Patterns for Assigning Responsibilities

Introduction

Polymorphism

Pure Fabrication

Indirection

Protected Variations

Designing Use-Case Realizations with GoF Design Patterns

Introduction

Adapter (GoF)

“Analysis” Discoveries During Design: Domain Model

Factory (GoF)

Singleton (GoF)

Conclusion of the External Services with Varying Interfaces Problem

Strategy (GoF)

Composite (GoF) and Other Design Principles

Facade (GoF)

Observer/Publish-Subscribe/Delegation Event Model (GoF)

Conclusion

Further Readings

Elaboration Iteration 3

Iteration 3 and Its Requirements

Iteration 3 Requirements

Iteration 3 Emphasis

Relating Use Cases

Introduction

The include Relationship

Terminology: Concrete, Abstract, Base, and Addition Use Cases

The extend Relationship

The generalize Relationship

Use Case Diagrams

Modeling Generalization

Introduction

New Concepts for the Domain Model

Generalization

Defining Conceptual Superclasses and Subclasses

When to Define a Conceptual Subclass

When to Define a Conceptual Superclass

NextGen POS Conceptual Class Hierarchies

Abstract Conceptual Classes

Modeling Changing States

Class Hierarchies and Inheritance in Software

Refining the Domain Model

Introduction

Association Classes

Aggregation and Composition

Time Intervals and Product Prices—Fixing an Iteration 1 “Error”

Association Role Names

Roles as Concepts vs. Roles in Associations

Derived Elements

Qualified Associations

Reflexive Associations

Ordered Elements

Using Packages to Organize the Domain Model

Adding New SSDs and Contracts

New System Sequence Diagrams

New System Operations

New System Operation Contracts

Modeling Behavior in Statechart Diagrams

Introduction

Events, States, and Transitions

Statechart Diagrams

Statechart Diagrams in the UP?

Use Case Statechart Diagrams

Use Case Statechart Diagrams for the POS Application

Classes that Benefit from Statechart Diagrams

Illustrating External and Interval Events

Additional Statechart Diagram Notation

Further Readings

Designing the Logical Architecture with Patterns

Introduction

Software Architecture

Architectural Pattern: Layers

The Model-View Separation Principle

Further Readings

Organizing the Design and Implementation Model Packages

Introduction

Package Organization Guidelines

More UML Package Notation

Further Readings

Introduction to Architectural Analysis and the SAD

Introduction

Architectural Analysis

Types and Views of Architecture

The Science: Identification and Analysis of Architectural Factors

Example: Partial NextGen POS Architectural Factor Table

The Art: Resolution of Architectural Factors

Summary of Themes in Architectural Analysis

Architectural Analysis within the UP

Further Readings

Designing More Use-Case Realizations with Objects and Patterns

Introduction

Failover to Local Services; Performance with Local Caching

Handling Failure

Failover to Local Services with a Proxy (GoF)

Designing for Non-Functional or Quality Requirements

Accessing External Physical Devices with Adapters; Buy vs. Build

Abstract Factory (GoF) for Families of Related Objects

Handling Payments with Polymorphism and Do It Myself

Conclusion

Designing a Persistence Framework with Patterns

Introduction

The Problem: Persistent Objects

The Solution: A Persistence Service from a Persistence Framework

Frameworks

Requirements for the Persistence Service and Framework

Key Ideas

Pattern: Representing Objects as Tables

UML Data Modeling Profile

Pattern: Object Identifier

Accessing a Persistence Service with a Facade

Mapping Objects: Database Mapper or Database Broker Pattern

Framework Design with the Template Method Pattern

Materialization with the Template Method Pattern

Configuring Mappers with a MapperFactory

Pattern: Cache Management

Consolidating and Hiding SQL Statements in One Class

Transactional States and the State Pattern

Designing a Transaction with the Command Pattern

Lazy Materialization with a Virtual Proxy

How to Represent Relationships in Tables

PersistentObject Superclass and Separation of Concerns

Unresolved Issues

Special Topics

On Drawing and Tools

Introduction

On Speculative Design and Visual Thinking

Suggestions for UML Drawing Within the Development Process

Tools and Sample Features

Example Two

Introduction to Iterative Planning and Project Issues

Introduction

Ranking Requirements

Ranking Project Risks

Adaptive vs. Predictive Planning

Phase and Iteration Plans

Iteration Plan: What to Do in the Next Iteration?

Requirements Tracking Across Iterations

The (In)Validity of Early Estimates

Organizing Project Artifacts

Some Team Iteration Scheduling Issues

You Know You Didn’t Understand Planning in the UP When…

Further Readings

Comments on Iterative Development and the UP

Additional UP Best Practices and Concepts

The Construction and Transition Phases

Other Interesting Practices

Motivations for Timeboxing an Iteration

The Sequential “Waterfall” Lifecycle

Usability Engineering and User Interface Design

The UP Analysis Model

The RUP Product

The Challenge and Myths of Reuse

More UML Notation

General Notation

Implementation Diagrams

Template (Parameterized, Generic) Class

Activity Diagrams

People also search for Applying UML and Patterns An Introduction to Object Oriented Analysis and Design and Iterative Development 2nd: 

applying uml and patterns 3rd

applying uml and pattern

applying uml and patterns 3rd edition

purpose of uml diagrams