|
umlmdl |
Data Modelling with UML |
14小时 |
This course has been created for Subject Matter Experts which are required to model their data with UML.
It covers consistent modelling techniques without going into implementation details.
Short Introduction to Data Modelling in General
Languages used to describe data
ERD and other pre UML notations
Why data modelling is not database modelling
Concepts of storing the data (Relational, Hierarchical, Object Oriented, etc...)
UML and Data Modelling
Class Diagram
Association
Aggregation
Composition
Inheritance (Generalization and Specialization)
Attributes
Attribute and attribute types
Attributes and relations
Data Types
Constraints on data
Constraints on relations
Views of data models
Business View
Modeller View
Architect View
Designers View
Implementers Views (just short explanation)
Other useful UML diagrams
Composite structure diagram
Profile diagram
Avoid Redundancies
Stereotyping vs Inheritance
Tags
Design Patterns (just introduction)
|
|
umlea |
UML in Enterprise Architect (workshops) |
21小时 |
The course is designed for analysts, designers, developers, testers and project managers.
The workshop presents a problem analysis, design and documentation systems using UML and Enterprise Architect of Sparx Systems. During the training will be presented to the advanced capabilities of the program (such as MDA, profiles, XMI), and best practices that can greatly simplify and accelerate modeling.
The training method:
Lecture 10%, 90% workshop
Create and configure EAP file
Create and save a Enterprise Architect project file
File structure of the project
Types of views
Program interface: menus, toolbars, Toolbox, Project Browser and other windows
Docking and hiding windows
Working with a model, diagram
Predefined models
Packages (views) and diagrams
Adding elements to the model and diagram
Different ways of removing the items and their consequences
Saving diagrams
Requirements Management
Methods of requirements gathering
FURPS requirements categories
Requirements Diagram
Relationships between requirements
aggregation
dependency
realization
How to improve the appearance of a diagram?
layout diagram
colour status requirements
enable / disable the package names
Create and manage a matrix relationship
Documenting requirements
HTML pages
printable version
Advanced requirement management
custom types of requirements
custom requirements status
tracking requirements
requirements documenting
Business process modeling, architecture
Activity Diagram
Compound activities
Control flows, object flows
Handling exceptions, interrupt flow
Partitions
Concurrent flows and decision-making
How to improve the appearance of a diagram?
different levels of detail
reducing the amount of detail
complexity of the process
Components and Deployment diagrams
The initial architecture of the system - logical and physical
nested components
delegation and assembly
port, part
interface
communication paths
Security, performance, reliability of the system requirements modelling
Non-standard implementation of stereotypes in diagrams
stereotypes graphic library
adding the library to the project
custom graphics stereotypes
Use Cases and their documentation
Functional requirements modeling
Scope of the system
Actors and the relationships between them
Identifying use cases
Association "actor - use case" and its properties
Relationship between use cases: include, extend, generalization
Auto names
Use Case scenarios and diagrams generated based on them them (activity, state machine, sequence)
Use Case scenarios from external files
Documentation generation
Document Templates
Domain model
Main classes/objects of a system
Communication Diagram
message types: asynchronous, synchronous, return
messages numbering
stereotypes: Boundary, Control and Entity
System design introduction
Static model
Class Diagram
Class diagram and source code generation
association and its characteristics
other relationships: aggregation, composition, generalization, dependency, association class
naming convention for classes and their elements
show/hide classes
Forward/Reverse engineering
source code generating from the diagram
diagram generation from source code
source code and diagram synchronization
Object Diagrams
Dynamic Model
Static model verification
clarify the method signatures
verification of the class diagram
Dynamic modeling at the level of method calls (sequence diagram) based on use cases and static analysis model
How to improve the appearance of a diagram?
reducing the number of modeled scenarios
reducing the number of lifelines
avoiding complex nested blocks
hiding details
State Machine diagram
states and sub-states
transitions between states - trigger, condition and action
internal actions (entry, do, exit)
How to improve the appearance of a diagram?
line style
state decomposition
Patterns and profiles
"Gang of Four" patterns
Patterns defined in the project
Collaboration
User patterns
Importing profiles from XML files
MDA, source code
Class Diagram to database schema transformation
SQL script generation based on class diagram
Source code generation - available options
Group work
Enterprise Architect package versioning
Differences in the versions of the project, documentation
Using a repository to store the model
Collaboration tools
|
|
UML |
Object-Oriented Analysis and Design using UML |
21小时 |
This course is intended for analysts, designers, developers, testers and project managers. It is an introduction to system modeling using UML.
Based on selected systems (case study) following phases of system modeling are presented: from modeling requirements, through business process modeling and documentation of functional and non-functional requirements, to the analytical model. The next step is the design phase - static and dynamic modeling using project classes and the interaction between the system components.
Training can be the basis for a comprehensive process modeling in enterprise systems through the use of UML in all phases of software development.
Introduction to UML
A brief History of UML
Overview of issues in the field of object-oriented modeling
UML Specification (OMG)
UML diagrams overview
Requirements management
Requirements Types
Requirements Categories (FURPS)
Methods for gathering requirements
Modeling requirements using UML
The relationship matrix for the requirements
Creating a requirements specification
Modeling business processes
Activity Diagram
Business process modeling in UML
The definition of a business process
Concurrent flows and decisions
Exceptions and Exception Handling
Partitions, path
Modeling non-functional requirements
Components and Deployment diagrams
The initial architecture of the system - logical and physical
Modeling requirements for security, performance, reliability, ...
Modeling functional requirements
Modeling functionality with the Use Case diagram
Determining the scope of the system
Actors and the relationships between them
Identifying use cases
Association "actor - use case" and its properties
The relationship between use cases: include, extend, generalization
Creating a use case scenarios and generate diagrams from them (activity, state machine)
Analytical model of the system
Using communication diagram to identify the main system objects
The types of messages: asynchronous, synchronous, reply
Specify the numbering sequence of messages
Categories of objects: Boundary, Control and Entity
Introduction to the project system
Modeling the interaction
Static Modeling
Class Diagram and source code generation
Association relationship and its characteristics.
Other relationships: aggregation, composition, generalization, dependency, association class
Forward/Reverse engineering
Generating source code from the model
Generating diagram based on the source code
Synchronizing code and diagram
Object Diagrams, Composite Structure Diagrams, and Package Diagrams
Dynamic Modeling
Verification of the static model
Clarification of method signatures
Verification of the class diagram
The dynamic modeling at the level of method calls
Diagrams: Sequence, State Machine, Timing, and Interaction
|
|
bpmnuml |
BPMN和UML建模业务流程 |
14小时 |
This training course aims at helping business analysts to learn to model efficiently their business processes using BPMN as well as resources that are handled by their activities. Being conducted by an agile enterprise framework, business analysts learn during this course how to use appropriate BPMN notations and business extensions of UML in order to deal with their "business requirements" and coherently drive underlying design level activities.
Introduction
Definition of BPM for an Agile Enterprise
Place of the OMG's BPMN 2.0 in this context
Elements of the BPMN 1.x
Basic Notions
Process and Collaboration Diagrams,
Participants : Pool, Lane
Diagram repartition on the basis of abstraction levels
Process, Sub-Process, Activity, Task
Events and Gateways typology,
Synchronisations,
Connectors, Message Flows, Data Objects,
Best Practices,
Case Study : Model the Business Process and establish the corresponding bridge toward an Organised Process
Advanced Elements using BPMN 2.0
BPMN 2.0 advanced concepts
Choreography, Collaboration and Conversation Diagrams,
Detailed events and gateway typologies,
Interruption Management, Incident Management,
Multi-instance Elements,
Transaction and Compensation,
Workflow Patterns,
Case Study : Update the previous diagrams considering Interruption and Compensation mechanisms
Simulate and Execute BPMN Models
Process Models Simulation,
Correspondences BPMN and UML,
BPMN tools,
Business Analysis Monitoring (BAM),
Case Study : Check for the previous business process correctness and adjust them
Conclusion
Steps of an efficient BPMN and Resource Modeling,
Key Elements of the BPMN within Zachman frameworks,
Using BPMN for SOA
Evolution Management : the Roadmap
Notice : The above training-mentoring sessions are conducted interactively using Business Modeling tools in order to ensure good level of traceability between business specifications and their execution. Concepts are first explained using basic examples and are then followed by solution drafts to your own problems. After this session, we can accompany you by reviewing and validating your solutions depending on your needs. |
|
eraamauml |
Efficient Requirement Management using Agile Methods and Agile UML Modeling |
21小时 |
Objective:
This training course aims at helping product managers, products owners, business analysts, system architects and developers understand how to efficiently Manage Requirements on the basis of the product vision till guiding developers accurately in implementing them.
More in detail, this course aims at assisting product managers in better defining the value propositions of their products on the basis of strategies and stakeholder needs. Business Analysts and product owners understand how to describe requirements of the product backlog then discover appropriate epics and user stories of the system while contributing to the required value creation. Along interactive case study exercises, participants learn how to describe in detail such requirements in order to validate correct understanding of needs and prepare system acceptance tests. Thus, only using a very common and productive UML profile, they learn to structure requirements in order to communicate efficiently with architects and developers through an iterative requirement gathering process.
Audience:
Product Managers
Product Owners
Business Analysts
Anyone interetsted in the Requirements Management Process
Introduction
What is the Requirement Management Process ? Why Agile ?
Business agility and agile software delivery : Definitions
Linking Agile to Business : Business Motivation Model vs. Business Model Canvas,
How to effciently use the Value Proposition Canvas for defining the Product Vision ?
Business agility vs. agile software delivery principles
What is Agile Not ? Impacts of alignment with strategies and capabilities
Requirement Management in an Agile Context
Scrum Life Cycle : Issues about completeness of requirements and traceability
How productive models enhance communication in 'Agile' ?
Business Extensions of Agile : Structuring Business Value Contribution of a User Story
A Panorama of UML diagrams for modeling requirements
Frameworks for tracing requirements toward software implementation and tests
The 5 levels planning of an agile project (from Clarifying the Vision and Product Backlog to Tasks… and the Architecture Walking Skeleton)
Managing Requirements within Agile Methods (Scrum, DAD) vs. the Unified Process (RUP)
Roles, teams, environments
Presentation of the Case Study for Structuring requirements and managing them using an iterative process
How to describe the business vision and needs via traceable models ?
Qualification of the requirements : The Kano model vs. the Value Proposition Canvas
Structuring the Vision of the Product on the basis of strategies, environmental forces and trends
Value proposition, key activities, key resources, revenue streams and cost structures,
Discovering the business scope of the product using the customer needs, gains and pains
Describing business use cases using 'value streams' and 'value stages'
Bridging the business scope of the product with expected 'value contributions'
Case Study : Describing the vision of the product
How to describe user needs via agile use case modeling (epics and user stories) ?
Agile Estimating and Planning
Building and managing the product backlog / granularity of requirements
Ahead of the sprint planning
Creation of the sprint backlog
Agile User Story Pattern : system scope (the subject), actors, use cases, user stories, acceptance criteria, the INVEST model
The Walking Skeleton using Disciplined Agile Delivery : From Processes to Technology
How to find out epics and user stories on the basis of value streams ?
Value contribution of epics and user stories
Writing tasks : granularity and size using the SMART model
Case Study : Discovering epics and user stories on the basis of value streams
Validating and testing correct understanding of detailed specifications
Using an incremental requirement gathering process and the sprint backlog
Rules for efficient epic, user story and architecture descriptions
Diagrams for validating epics and user story descriptions
How to choose the right diagram ?
Refining features using use cases and relationships modeling
Testing correct understanding of requirements using Test-Driven Requirements
Given/When/Then structures and Operation Contracts for guiding developers in implementing requirements
Coverage analysis and change management
Case Study : Validating, testing and communicating detailed requirements to developers
Conclusion
Steps of efficient requirement gathering and system analysis processes
Traceability between requirements and analysis models
Patterns for gathering and testing requirements
Notice: The above training-mentoring sessions are conducted interactively using examples from Requirement Engineering and Modeling tools in order to ensure good level of traceability between requirements and underlying solutions. Concepts are first explained using basic examples and are then followed by solution drafts to your potential case. After this session, we can also accompany you by reviewing and validating your solutions depending on your needs. |
|
sysengsysmluml2 |
System Engineering using SysML and UML 2 |
21小时 |
Objective:
Helping Analysts and Designers of the System Engineering domain to understand how to efficiently gather requirements then go through the embedded software design implementation on the basis of system specifications using UML 2 and SysML.
This 3 days training aims at assisting system analysts to express efficiently their needs and designers to make the appropriate architectural design of the system on the basis of these needs.
The resulting system architecture provides a good level of agility to the embedded system software in face of changes as it allows a coherent traceability of the business rules encapsulated in system functions and those of the usage choices (use cases) of the end-users toward the software implementation level.
Introduction
The System Development Life Cycle with the Harmony Process (IBM/Telelogic)
Overview of the UML/SysML diagrams used in requirements gathering, system analysis and design of the System Engineering domain
A Method based Framework for requirement gathering, system analysis and design
Gathering Requirements and Transforming them into System Specifications
Making business and system requirements traceable using the SysML requirement diagram
Define the scope of the system composed of functions and use cases that invoke these functions
Model the Life Cycle of the System that orchestrates transitions between its states where functions are triggered
Prepare test cases using scenarios that realize Use Cases and System Functions
Case Study : Model the System Scope and the usage of the system functions on the basis of requirements
Transforming System Specifications into Design Level Components
Model the Block Diagram of the system and refine it using internal blocks
Elaborate the Communication Architecture between Sub-System using Parts, Ports and Interfaces
Case Study : Elaborate the block and Internal Block diagrams on the basis of system specifications and by considering design level choices
Model the description of white box Interactions at the design level
Case Study : Model interactions between blocks and Internal Blocks on the basis of design level choices
Mapping of Operations on the Components (Parts) of Blocks
Elaborate the Parametric Diagram of the System Functions
Case Study : Update the Block and Internal Block Diagrams on the basis of design level scenarios
Conclusion
Steps of requirement analysis and system specifications in system engineering
Traceability between requirements and the software
System Integration and Acceptance Tests of the requirements
Notice: The above training-mentoring sessions are conducted interactively using Requirement Engineering and Modeling tools like Enterprise Architect (EA) in order to ensure good level of traceability between requirements and underlying solutions. Concepts are explained first using basic examples and are then followed by solution drafts to your own problems. After this session, we can accompany you by reviewing and validating your solutions depending on your needs. |
|
umlocl1 |
UML OCL |
7小时 |
UML language architecture
UML 2.0 Language Architecture
OCL within architecture
Object Constraint Language (OCL)
OCL
OCL Language Description
Abstract Syntax
Concrete Syntax
Semantics Described using UML
OCL Standard Library
Use of OCL Expressions in UML Models
Semantics Page
Other OCL concepts
Example usage and Exercises
Typical cases in each diagaram type
Exercises
|
|
usecase |
Use Case Modeling |
14小时 |
This course is designed for business analysts, managers, team leads and process owners to provide them with the required competencies for creating use case diagrams and use case scenarios, which serve as a vehicle for eliciting, analyzing, documenting and communicating functional requirements. Delegates will practice creating use cases in the Unified Modeling Language (UML) to graphically represent the interactions between use cases and actors.
Introduction to Use Case Modeling
Brief background and context for use cases
Use case definitions, elements, and components
Benefits of use case modeling
Organizing requirements with use cases
Use case diagrams as a UML notation
Organizing the model with packages
Use case actors
Users and Actors
Business and system actors
Identifying actors and mapping stakeholders
Use Cases - Indentify and Describe
Identifying use cases and writing description
Use Case Controls:
preconditions
postconditions
assumptions
scenarios
Use Case Scenarios
Main success scenario
Alternates and exceptions
Indicating iteration
Advanced Techniques
<<include>> relationship
<<exclude>> relationship
Generalization
Specialization
Multiplicity
Practical Use Cases Concepts
Flows of events and their purpose: primary, alternate, and exception paths
Methods for documenting primary flows
Documenting alternate and exception flows
Documenting scenarios
Narrative flow examples
Use Cases and Test Cases
Relationship between use cases and test cases/scenarios
Translating use cases into test cases
Use cases and user interfaces/prototyping
Prototyping roles, preparation, and execution
UML Concepts
UML notation
Class and object relationships
Extracting classes from use cases
Verifying a class: attributes, operations, and associations/multiplicity
Include relationship and example
Referring to includes in flows
Extend relationship and example
Referring to extends in flows
Generalization relationship and example
Use case documentation
|
|
designpat |
Design Patterns |
14小时 |
There are plenty of tried and tested patterns widely available to everyone. Sometimes it is a matter of changing the names and implementing the pattern in a specific technology. It can saves hundreds of hours, which otherwise would be spent on design and testing.
Training Goals
This course has two goals: first, it allows you to reuse widely-known patterns, second, it allows you to create and reuse patterns specific to your organization.
It helps you to estimate how patterns can reduce costs, systematize the design process and generate a code framework based on your patterns.
Audience
Software designers, business analysts, project managers, programmers and developers as well as operational managers and software division managers.
Course Style
The course focuses on use cases and their relationship with a specific pattern. Most of the examples are explained in UML and in simple Java examples (the language can change if the course is booked as a closed course). It guides you through the sources of the patterns as well as showing you how to catalogue and describe patterns which can be reused across your organization.
Introductions
Patterns and tiered architectures
Pattern description
Design patterns and design
Finding and selecting design patterns
Design pattern implementation
Well-known patterns
Object Creation
Factory
Builder
Factory Method
Prototype
Singleton
Structural Patterns
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Behavioural Patterns
Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor
Observer
Creating Patterns
To pattern or not to pattern
Formal pattern description
Organizing the pattern catalogue
Particular goal and abstracted goal
Publishing your patterns to a pattern community
|
|
soamlad |
Analysis and Design with SoaML |
14小时 |
This course explains the OMG SoaML standards and shows how to model the SOA landscape. It introduces the language and then shows how to discover, design and implement services and infrastructure for SOA.
This course always covers the newest version of the SoaML specification.
Motivation behind SoaML
Standards before SoaML
Vendors standards and Open Source standards
The IT and the business perspective on SOA
Contracts and Interfaces
Top-down and bottom-up approaches
Service classification
Compliance Level for SoaML
SoaML UML Profile Specification
Agent
Attachment
Capability
Consumer
Collaboration
Collaboration Use
Expose
MessageType
Milestone
Participant
Port
Property
Provider
Request
ServiceChannel
ServiceContract
ServiceInterface
Service
ServiceArchitecture
Categorization
Catalog
Categorization
Category
CategoryValue
RAS Placeholders
BMM Integration
MotivationElement
MotivationRealziation
SoaML Metamodel |
|
umlitba |
UML for the IT Business Analyst |
21小时 |
One of the fastest growing roles in the IT industry is the IT Business Analyst. Business Analysts are found in almost organizations and are important members of any IT team whether in the private or public sector.
This course provides a clear, step-by-step guide to how the Business Analyst can perform his or her role using state-of-the-art object-oriented technology.
Overview of Software Development Process and Modelling
Methodologies and their impact on the work of a Business Analyst
Waterfall steps Analysis, Design, Implementation, Testing, Maintenance
Agile approach to business analysis
Who Are Business Analysts?
Perspective on the BA Role
The Dynamic (Behavioral) Model
The Static (Structural) Model
Structured Analysis
The BA’s Perspective on Object Orientation
Object Oriented Programming and its impact on modelling
The UML Standard
Cognitive Psychology and OO?
Objects
Attributes and Operations
Operations and Methods
Encapsulation
Classes
Relationships
Generalization
Association
Aggregation
Composition
Polymorphism
Use Cases and Scenarios
Business and System Use Cases
An Overview of Business Object-Oriented Modeling (B.O.O.M.)
B.O.O.M. and SDLCs
The B.O.O.M. Steps
Sequencing the Steps
What Do You Define First—Attributes or Operations?
Analyzing End-to-End Business Processes
Interviews During the Initiation, Analysis, and Test Phases
Step 1: Initiation
Business Requirements Document Template
Step 1a: Model Business Use Cases
Step 1a i: Identify Business Use Cases (Business Use-Case Diagram)
Putting Theory into Practice
Note to Rational Rose Users
Case Study D1: Business Use-Case Diagrams
Step 1a ii: Scope Business Use Cases (Activity Diagram)
Case Study D2: Business Use-Case Activity Diagram with Partitions
Scoping the IT Project with System Use Cases
Step 1b: Model System Use Cases
Case Study E1: Role Map
Step 1b ii: Identify System Use-Case Packages (System Use-Case Diagram)
Case Study E2: System Use-Case Packages
Step 1b iii: Identify System Use Cases (System Use-Case Diagram)
Case Study E3: System Use-Case Diagrams
Step 1c: Begin Static Model (Class Diagrams for Key Business Classes)
Step 1d: Set Baseline for Analysis (BRD/Initiation)
Storyboarding the User’s Experience
Step 2: Analysis
The Use-Case Description Template
Documenting the Basic Flow
Use-Case Writing Guidelines
Basic Flow Example: CPP System Review Case Report
Documenting Alternate Flows
Documenting Exception Flows
Guidelines for Conducting System Use-Case Interviews
Activity Diagrams for System Use Cases
Related Artifacts
Decision Tables
Case Study F1: Decision Table
Decision Trees
Case Study F2: Decision Tree
Condition/Response Table
Business Rules
Advanced Use-Case Features
Case Study F3: Advanced Use-Case Features
Life Cycle Requirements for Key Business Objects
What Is a State Machine Diagram?
Step 2a ii: 1. Identify States of Critical Objects
Case Study G1: States
Step 2a ii: 2. Identify State Transitions
Case Study G2: Transitions
Step 2a ii: 3. Identify State Activities
Case Study G3: State Activities
Step 2a ii: 4. Identify Composite States
Case Study G4: Composite States
Step 2a ii: 5. Identify Concurrent States
Gathering Across-the-Board Rules with Class Diagrams
Step 2b: Static Analysis
Step 2b i: Identify Entity Classes
Case Study H1: Entity Classes
Step 2b ii: Model Generalizations
Case Study H2: Generalizations
Step 2b iii: Model Transient Roles
Case Study H3: Transient Roles
Step 2b iv: Model Whole/Part Relationships
The Composite Structure Diagram
Case Study H4: Whole/Part Relationships
Step 2b v: Analyze Associations
Case Study H5: Associations
Step 2b vi: Analyze Multiplicity
Case Study H6: Multiplicity
Optimizing Consistency and Reuse in Requirements Documentation
Step 2b vii: Link System Use Cases to the Static Model
Case Study I1: Link System Use Cases to the Static Model
Case Study I1: Results
Step 2b viii: Add Attributes
Meta-Attributes
Case Study I2: Add Attributes
Step 2b ix: Add Look-Up Tables
Case Study I5: Analyze Look-Up Tables
Step 2b x: Add Operations
Case Study I7: Distribute Operations
Step 2b xi: Revise Class Structure
Case Study I8: Revise Structure
Designing Test Cases and Completing the Project
Step 2c: Specify Testing
Structured Walkthroughs
Decision Tables for Testing
Case Study J1: Deriving Test Cases from Decision Tables
Boundary Value Analysis
Case Study J2: Select Test Data Using Boundary Value Analysis
System Tests
Beyond the System Tests
Step 2d: Specify Implementation Plan
Step 2e: Set Baseline for Development
What Developers Do with Your Requirements
Object Oriented Design Patterns
Visibility
Control Classes
Boundary Classes
Sequence Diagrams
Communication Diagrams
Other Diagrams
Layered Architecture
Interfaces
Mix-Ins
Implementing OO Using an OO Language
Implementing OOA Using Procedural Languages
Implementing a Database from OOA Using a RDBMS
|
|
umlad |
UML Analysis and Design |
21小时 |
This course has been created for software architects, programmers, software developers, project managers, analysts and anyone interested in understanding analysis and designing in UML.
The course shows how to analyse clients' needs, formalize them in UML diagrams, create a model and ultimately design the implementation of the software.
This is a general course covering all aspects of UML. Please browse our catalogue to see more specific courses.
This course uses the newest version of the standard (http://www.omg.org/spec/UML) and is taught by an OMG Certified UML Professional (OCUP) trainer.
There are no specific tools for this course, each of the delegates can use their favourite tool. By default, Sparx Enterprise Architect is used.
Introduction to Modelling
Models and Modelling
Idea of meta-modelling
UML documentation
Inheritance
Analysis and Design
Actors and Use Cases
Class and Object Diagrams
Classes, objects, types of relations
Object and Class Relationships
Association, Aggregation, Composition
Inheritance
Dependency
Interaction
Communication diagram
Interaction overview diagram
Sequence diagram
Timing diagrams
Activity Diagrams
State Diagrams
Packages
Component and Deployment
Workshop
From Analysis to Implementation
Introduction to design patterns |
|
ocup-2-f100 |
OCUP2 UML 2.5 Certification - Foundation Exam Preparation |
21小时 |
OCUP2 Content Developer
NobleProg has official OMG OCUP 2 Content Developer status, which means that our course outlines and training materials were developed by the same experts who prepared questions for OCUP 2 exams.
Audience
Developers, programmers, business analysts, project managers, software architects, testers, people responsible for documentation or anyone involved in the software development process.
Objectives
Prepares you to work with the most commonly encountered UML elements
Teaches you how to create simple UML models
Prepares you to be a member of a UML Development Team
Why we model
The Class Diagram
Common Structure
Type
Dependency
Namespace
VisibilityKind (public, private, protected)
MultiplicityElement
Constraint
Comment
Simple Classifiers
PrimitiveType
DataType
Enumeration
EnumerationLiteral
Interface
InterfaceRealization
Signal
Reception
Structured Classifiers
Association
Class
Classification
Generalization
Feature
Structural Feature
Behavioral Feature
Property
Operation
Parameter
AggregationKind (Composition, Aggregation)
Values
LiteralBoolean
LiteralInteger
LiteralReal
LiteralUnlimitedNatural
LiteralNull
LiteralString
Opaque Expression
The Object Diagram
InstanceSpecification
Slot
The Package Diagram
Packages
Package
PackageImport
The Use Case Diagram
Use Cases
UseCase
Actor
Include
The Activity Diagram
Activities
Activity
ActivityFinalNode
ActivityParameterNode
ControlFlow
InitialNode
DecisionNode
FlowFinalNode
ForkNode
JoinNode
MergeNode
ObjectFlow
ObjectNode
Actions
Action
CallBehaviorAction
CallOperationAction,
SendSignalAction
AcceptEventAction
Pin
InputPin, OutputPin
OpaqueAction
The Sequence Diagram
Interactions
Interaction
OccurrenceSpecification
ExecutionSpecification
ExecutionOccurrenceSpecification
DestructionOccurrenceSpecification
Lifeline
Message
MessageOccurrenceSpecification
MessageSort
MessageEnd
Common Behavior
CallEvent
SignalEvent
Trigger
OpaqueBehavior
The State Machine Diagram
State Machines
StateMachine
State
Transition
Pseudostate: choice, junction, initial
FinalState
|
|
uml2itmprep |
OCUP2 UML 2.5 Certification - Intermediate Exam Preparation |
14小时 |
Audience:
Developers, programmers, business analysts, project managers, software architects, testers, people responsible for documentation or anyone involved in the software development process.
Objectives:
Prepares you to work with a broad range of UML elements
Teaches you how to create complex UML models
Prepares you to become a qualified senior member of a UML Development Team.
Basic Structure
Backus-Naur Form (BNF)
Namespaces
Types & Multiplicity
Constraints
Dependencies
Time
Intervals
Packages
Information Flows
Classification
Classifiers
Properties
Operations
Generalization Sets
Instances
Structured Classifiers
Structured Classifiers
Classes
Associations
Collaborations
Components
Encapsulated Classifiers
Components
Deployments
Artifacts
Nodes
Common Behavior
Signals
Receptions
Behaviors
Events
Activities and Actions
Activities
Control Nodes
Object Nodes
Activity Groups
Actions
Invocation Actions
Structured Actions
Expansion Regions
Interactions
Interactions
Lifelines
Messages
Fragments
Interaction Uses
Sequence Diagrams
Communication Diagrams
State Machines and Use Cases
Statemachine topics
Protocol Statemachines
Interfaces
Use Cases
|
|
uml2advprep |
UML 2.0 Certification - Advanced Exam Preparation |
14小时 |
Audience:
Developers, programmers, business analysts, project managers, software architects, testers, people responsible for documentation or anyone involved in the software development process.
Objectives:
Prepares you to work with a broad range of UML elements
Teaches you how to create complex UML models
Allows you become a qualified to be a senior member of a UML Development Team.
Class Diagrams
Association Classes
Power Types
Generalization set
Power type
Composite Structure Diagrams
Collaborations
Collaboration
Collaboration Occurrence
Component Diagrams
Packaging Components
Component (for Packaging Components)
Actions Modelling
Complete Actions
Accept Event Actions
Object Actions
Link Identification
Read Link Actions
Write Link Actions
Raise Exception Action
Other Complete Component concepts
Activity Diagrams
Complete Activity Structures
Elements
Constraints
Flows
Object Nodes
Data Stores
Parameter Sets
Control Nodes
Interruptible Regions
Other Complete Activity concepts
Structured Nodes
Structured Nodes
Exceptions and Expansion Regions (Extra Structured Activities)
Exceptions
Expansion Regions
Deployment Diagrams (with Components)
Component Deployments
Deployment
Deployment Specification
State Machine Diagrams (Protocol state machines)
Protocol State Machines
Protocol State Machine
Constraints (In protocol state machine)
Other Protocol State Machine concepts
Miscellaneous Advanced Constructs
Flow Diagrams
Information Item
Information Flow
Physical System
Model
Templates
Template
Template Parameters
Language Architecture
UML language architecture
UML 2.0 Language Architecture
Infrastructure library
Relationship to other MDA standards
OCL within architecture
Diagram interchange
Object Constraint Language (OCL)
OCL
OCL Language Description
Abstract Syntax
Concrete Syntax
Semantics Described using UML
OCL Standard Library
Use of OCL Expressions in UML Models
Semantics Page
Other OCL concepts
|
|
bpaumlbpmn |
Business Process Analysis with UML and BPMN |
14小时 |
Course Audience:
Managers who want to understand BPMN diagrams, Business Consultants, Business Analysts, Business Process Engineers, System Analysts and anyone who is involved in analyzing and planning Business Processes using standardized, unified modelling notation.
Course Goals:
Produce high-quality process diagrams
Model in the BPMN process notation
Capture as-is process information
Implement optimized process flows for people-intensive processes
Simplify complex process definitions and break them into more manageable pieces
UML
Business use case diagrams
UML activity diagrams detailing the use case
Business Entities definitions depicted with Class Diagrams
Map the model into system use cases
BPMN
BPMN modelling techniques
BPMN modelling shape overview
Swimlane generation and viewing
BPMN text objects, data objects, annotations, and attributions
Basic Process optimization
Process design best practices
|
