20101007 how smart use cases drive web development

Sander HoogendoornPrincipal Technology Officer

Capgemini

HOW SMART USE CASES DRIVE WEB DEVELOPMENT

2HOW SMART USE CASES DRIVE WEB DEVELOPMENT©2010 Capgemini. All Rights Reserved

Capgemini

� Principal technology officer

� Global agile thought leader

� Chief architect Accelerated Delivery Platform (ADP)

Other

� Author books and +200 articles in international magazines

� Appreciated speaker at +80 international conferences

� Microsoft Partner Advisory Council .NET

� Capping IT Off Blog

� Columns in Software Release Magazine, SDN Magazine

� Editorial boards Software Release Magazine, TiTM

� Advisory board @Portunity

Web

� www.sanderhoogendoorn.com

� www.smartusecase.com

� Twitter / LinkedIn : aahoogendoorn

SANDER HOOGENDOORN


AGENDA

Comparing requirements

techniques

Modeling

smart use cases

Smart use case driven

software architecture

Introducing

the task pattern

Generating code

from smart use cases

Unit testing

smart use cases


AGENDA


techniques

Modeling

smart use cases



Introducing

the task pattern

Generating code


Unit testing

smart use cases

User stories, huge cases and smart use cases

REQUIREMENT TECHNIQUES COMPARED


USER STORIES – APPLES AND PEARS

Often too unstructured

Unsuitable in complex

environments


COMPLEX IT LANDSCAPES


HUGE CASES Hard to build,

impossible to test


DIFFERENT LEVELS OF USE CASES

Cloud level

Kite level

Sea level

Fish level

Clam level

High summary

Summary

User goal

Sub-function

Too low

Products

Selling products

Search

book

Insert

orderline

Sell book


Traditional

use cases

Smart

use cases

Format Textual Visual

Granularity Different Unified

Estimate Hard Easy

Unit of work Lousy Good

Reuse Incidental Normal

Traceability Possible Normal

Testability Poor Good

Traditional use cases

� Only user goal level use cases

� Use cases ‘as they are intended’

� A single use case describesa single elementary business process

� Differ in granularity too much

� Law of Large Numbers does not apply

Smart use cases

� User goal and sub function level use cases

� Good unit of work and estimation

� A single elementary business process is modeledin a single use case diagram

� A single user goal level use case + auxiliary use cases at sub-function level

� Very similar granularity



AGENDA


techniques

Modeling

smart use cases



Introducing

the task pattern

Generating code


Unit testing

smart use cases

A YAGNI approach to requirements

SMART USE CASES


In traditional software development

� Analysis and design is done upfront

� Development only starts after all design is complete and perfect

Consequences

� No room for new or changing insights

� Possibly unnecessary work

Therefore

� Eliminate waste

� Maximize the amount of work not done

� Postpone work until you really need it

Benefits

� No unnecessary analysis and design work

� Allows for new and changing insights

� No handover, immediate feedback

YAGNI. YOU AIN’T GONNA NEED IT


AGILE REQUIREMENTS - APPROACH

D

E

F

SmartUse Cases

A

Project

Scope

D

Use Cases

A

B C

Hierarchical

Processes

B

D

D

Hierarchical

Processes

Chronological

Processes

Cloud Level Kite Level Sea Level Fish Level

C


CLOUD LEVEL


KITE LEVEL


Guidelines

� Identify re-use

� Model one form per use case

� Model one use case per web part

� Isolate unknown or complex functionality

� Model complex calculations

� Identify reports and analysis

� Isolate interaction with others

� Model services in service orientation

� Avoid low level interaction

(database, technical services)

IDENTIFYING SUB-FUNCTION LEVEL USE CASES


MODELING SMART USE CASES


MODELING SMART USE CASES – SEA AND FISH LEVEL


DESCRIBING USE CASES – SEA AND FISH LEVEL

Stereotypes

SMART USE CASES


Stereotypes in UML

� Marking model items gives explicit meaning to

the model

� Predefined stereotypes

� Custom definable stereotypes

Smart use case stereotypes

� Standardize analysis and design

� “This is a master-detail on product and order”

� “This service on customer is an aggregate”

� “We need a file import for handling the XMI”

� Facilitate easy estimation

� Commoditize realization of smart use case

� Facilitate easier (and automated) testing

SMART USE CASE STEREOTYPES


AGENDA


techniques

Modeling

smart use cases



Introducing

the task pattern

Generating code


Unit testing

smart use cases

An overview

SMART USE CASE DRIVEN ARCHITECTURE


Database consumer

� Domain oriented

� Data provided by database(s)

� But often database independent

Service consumer

� Domain oriented

� Data provided by service or middleware

� But protocol independent (SOAP or REST?)

Service provider

� Service oriented

� Data provided by contacts

� But domain oriented using data contracts

USING REFERENCE ARCHITECTURES


Presentation

Process

Domain

Data / Services

Outside world

Pages

UserControls

Panels

Use cases

Workflow

Domain objects / Entities

Factories / Repositories

Enums / Value objects / Smart references

[Mapping]

Table Gateways

Queries

[Mapping]

Database


Exact SAP BizTalk Java

Presentation

Process

Domain

Data / Services

Outside world

Pages

UserControls

Panels

Use cases

Workflow




[Mapping]

Service gateways

Service locators

[Mapping]

Services / ESB


Presentation

Process

Domain

Data / Services

Outside world

Service contracts

Operation contracts

Data contracts

Use cases

Services




[Mapping]

Table Gateways / Service Gateways

Queries / Service Locators

[Mapping]

Database

Services / ESB

Exact SAP BizTalk Java


ARCHITECTURE IN CODE

Web

� Pages, controls

Process

� Use cases / Tasks / Flow

Domain

� Factories / Repositories

� Domain Objects / Business rules

� Enums / Value Objects / References

� Search Objects

Data / Services

� Gateways

� Mappings / Describers

Database


AGENDA


techniques

Modeling

smart use cases



Introducing

the task pattern

Generating code


Unit testing

smart use cases

Introducing the Task Pattern



Presentation

Process

Domain

Data / Services

Outside world

Pages

UserControls

Panels

Use cases

Workflow




[Mapping]

Table Gateways

Queries

[Mapping]

Database


Smart use cases

� Act as primary unit of work

� Model process and work flow

� Make traceable in code

� Interact with presentation and domain layers

� Create layer supertype (task)

� Create classes for individual smart use cases

Why?

� Create traceability

� Facilitate reuse

� Implement model view controller

� Facilitate easier functional testing

� Cheapen application maintenance

SMART USE CASES IN CODE


SMART USE CASES IN CODE


Command pattern – Definition

� Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations

Task pattern – Definition

� Encapsulate a smart use case as an object, thereby letting you parameterize it from different requests.

In practice

� Implement smart use cases independently

� Define a navigation mechanism

� Use smart use cases independently

� Allows for reuse of your smart use cases!

Useful when

� Always ☺

� Create a task manager!

TASK PATTERN


TASK PATTERN


TASK PATTERN IN PRACTICE


TASK PATTERN IN PRACTICE – RUNNING A USE CASE


TASK PATTERN


TASK PATTERN – START FIRST USE CASE


TASK PATTERN – START SECOND USE CASE


TASK PATTERN – WEB PAGE WITH SECOND USE CASE


TASK PATTERN – POST CONDITIONS SECOND USE CASE


TASK PATTERN – CONTINUE FIRST USE CASE


TASK PATTERN – WEB PAGE WITH FIRST USE CASE


TASK PATTERN – POST CONDITIONS FIRST USE CASE

Task management with the Manager-Provider Pattern



Definition

� Create a simple static facade (manager) for a

(set of) interfaced implementations (providers)

In practice

� Manager holds one or a collection of providers

� Provider implement a particular interface

� Manager has methods to call methods from

interface

� At run-time, using dependency injection, actual

providers are injected

MANAGER-PROVIDER PATTERN


MANAGER – VALIDATIONMANAGER


INTERFACE


MANAGER – INITIALIZATION (USING DEPENDENCY INJECTION)


CONFIGURATION OF IMPLEMENTATION


MANAGER - EXECUTING METHODS


CLIENT – CALLING METHODS


Useful when

� Generic services need to be called, which may have different implementations

� Manager prevents having to loop through each of a list of providers

� Flexibility to add or remove providers without changing application code

� Providers differ e.g. in development code, test code or deployed code

Use for

� Task Management

� View Management

� Binding and Persisting

� Resource Management

� State Management

� Logging

� Datasource interaction

� Testing!

MANAGER-PROVIDER PATTERN


AGENDA


techniques

Modeling

smart use cases



Introducing

the task pattern

Generating code


Unit testing

smart use cases

An introduction to pragmatic model driven development

GENERATING CODE FROM SMART USE CASES


Forms

Use cases

Domain

objects

Data / Serviceclasses

Databases

Software Architecture

TobagoMDA

Test

scenario’s

Frameworks

Specifications

Existing

Applications

Businessmodels

DomainModel

Smartuse cases

User interface

specification1. Map your

business processes

to smart use cases

1. Map your

business processes

to smart use cases

2. Set up your

domain model

2. Set up your

domain model3. Establish

your software

architecture(s)

3. Establish

your software

architecture(s)

4. Generate

your code using

a text template

engine

4. Generate

your code using

a text template

engine

5. Finalize your

application

5. Finalize your

application


Characteristics

� Load UML model (expressed in XMI)

� Load templates (from flat files)

� Combine elements from UML model with templates to generate deliverables

Templates

� Templates contains code that runs in template engine

� Templates might use a folder model

Generation process

� Ability to generate all or individual UML model elements

� Which UML model elements are supported?

� Generated deliverables can be code but also any other document type

MODEL DRIVEN DEVELOPMENT – TEMPLATE ENGINES


MODEL DRIVEN DEVELOPMENT - TEMPLATE ENGINES

Template engine knows (part of) the UML meta

model

Template engine knows (part of) the UML meta

model

Properties can be used in templates

Properties can be used in templates


MODEL DRIVEN DEVELOPMENT - TEMPLATES


GENERATE MANY THINGS E.G. TABLE CREATE SCRIPTS

A quick example

GENERATING CODE


A SIMPLE SMART USE CASE MODEL

uc Manage Customer

Site Administrator

(from A ctors)

«master detail»

Manage Customer

«search»

Select Customer

«define»

Define Contact

«extend»

«incl ude»


A SIMPLE DOMAIN MODEL

class Budapest.Business

«business class»

Cust omer

+ Name: string

+ Address: string

+ Postcode: Postcode

+ City: string

+ Country: SmartRef

+ Website: Url [0..1]

«business class»

Contact

+ Name: string

+ Email: Email [0..1]

+ Phone: PhoneNumber [0..1]

+ Department: Departments

«enumeration»

Depart ments

Sal es

Purchasing

Helpdesk

Management

*


USING TOBAGO MDA


GENERATED CODE IN ASP.NET


GENERATED CODE IN SILVERLIGHT


AGENDA


techniques

Modeling

smart use cases



Introducing

the task pattern

Generating code


Unit testing

smart use cases

Unit testing at the right level

UNIT TESTING SMART USE CASES


Presentation

Process

Domain

Data / Services

Outside world

Pages

UserControls

Panels

Use cases

Workflow




[Mapping]

Table Gateways

Queries

[Mapping]

Database



Unit test what?

� Methods from the task pattern

� Methods that are called from presentation

� Methods that collaborate with other use cases

� Methods that interact with domain

How?

� Create unit test for each smart use case

� Run methods from smart use case

� Validate outcome (using asserts)

Why?

� Great code coverage

� Regressions testing on smart use cases

� Code generation makes light work



Test methods from Task Pattern

Run method

Validate outcome



Test methods that interact with domain

Set up (in)valid domain object

Run method from use case

Validate outcome

Introducing a light weight smart use case unit testing framework



Test environment

� Create test manager (using manager-provider)

� Mock actual use case environment

� Log events from environment to test manager

� Asserts by querying test manager

Task management

� (Possibly) avoid other task getting started

View management

� Don’t request actual web pages or forms

� Method calls from web pages are tested

Domain

� Handle actual validation, saves, removes

� Make sure business rules validate

Validation

� Validate, but handle by logging

A LIGHTWEIGHT SMART USE CASE UNIT TESTING FRAMEWORK


CONFIGURING TEST ENVIRONMENT


TEST MANAGER – LOGGING EVENTS


MOCKING ENVIRONMENT – LOGGING EVENTS


TEST MANAGER – QUERYING EVENTS


TEST MANAGER – RUNNING TESTS

Test methods that interact with domain

Set up (in)valid domain object

Run method from use case

Validate outcome

TAKEAWAYS


Smart use cases

� Solid unit of work in agile projects

� Easy estimation

� Identifying functional re-use early in projects

� Guarantee front-to-back traceability

� Great unit for (automated) testing

� Apply stereotypes for even more

standardization

� Use a REAL modeling tool

Software architecture

� Provide separate smart use cases layer

� Handles process, interaction and work flow

� Controller ++

TAKEAWAYS


Coding

� Implement task pattern

� Implement task management

� Modeling provides for model driven

development

Testing

� Smart use cases allow for automated testing

� Great code coverage on all layers

� Mock actual task environment

� Run tests automated in nightly builds

TAKEAWAYS

www.accelerateddeliveryplatform.com

WWW.SMARTUSECASE.COM

[email protected]

www.sanderhoogendoorn.com

www.smartusecase.com

@aahoogendoorn

REFERENCES AND QUESTIONS

20101007 how smart use cases drive web development

Technology

smart use cases unit

requirements smart use

auxiliary use cases

smart use cases user

user goal level use

subfunction level use

single use case

use case model