|
softeng |
Software Engineering |
35小时 |
Software Engineering starts where programming stops. In this course you will learn a solid foundation in Software Engineering. It builds a bridge from programming to solid engineering practices. The course gives you an overview of basic concepts and vocabulary typically used in the field. During the course, you will learn to use many techniques to plan, implement and validate software projects and to evaluate and improve development processes.
Audience:
This course is intended for software developers with various backgrounds who know at least one programming language.
Day 1: Process
Introduction
What is Systems Engineering?
What is Software Engineering?
Why is Software Engineering difficult?
System requirements
System modeling
Software Engineering Processes
What is a Software Development Process?
Traditional Processes
Agile Processes
Processes for building High-Integrity Systems
Standards & certification systems
High-Integrity Systems
What are High-Integrity Systems?
The role of QM culture
Reasons for errors
Critical systems standard
Reliability engineering
Software Maintenance
Day 2: Planning
Requirements
User requirements
Elicitation/analysis of user requirements
System requirements
Software requirements
Specification of software
Requirements process
Tools to manage requirements
Software Design
Conways Law
Design patterns
Textual modeling tools
Principles of OO design
Design tools
Common architectures
Modeling
Planning an architecture
UML graphical representations
Non-UML graphical representations
Day 3: Code
Software Construction
How to take a design into code
Programming best practices
Abstraction of code
Programming workflow
Configuration Management
What is Configuration Management?
Configuration Management in ISO9000 and CMMI
CASE tools for planning, design & QA
CASE tools for writing software
Version control with SVN
System Integration
Code for High-Integrity Systems
Preventing errors
Catching errors
Reducing the impact of errors
Typical problems with code for High-Integrity Systems
Code quality metrics
Code size metrics
Code complexity metrics
Non-code metrics
Static analysis
Day 4: Verification & Validation
Reviews
Fundamentals of VV
Independent Verification & Validation
Design and requirement reviews
Code inspections
Software Walkthroughs
Audits
Other V & V methods
Testing High-Integrity Systems
Documents regarding safety
Scenarios
Argumentation for safety
Reviews of High-Integrity Systems
Predicting reliability
Formal methods
Costs of V + V
Automated Testing
Why test?
Automatic vs manual tests
Incremental testing
Types of tests
Testing tools
Test Harnesses
Day 5: Management
Project Management
What is Project Management?
Customer handover
Standards (PMP, PRINCE2)
Time management
Cost management
Risk management
Project documentation
Process Evaluation
The function of process evaluation
Acting on the metric
Process metrics
Process evaluation standards & frameworks (CMMI, ISO 9001, TickIt+)
Process evaluation meetings
Summary and Conclusions |
|
softengret |
Software Engineering, Requirements Engineering and Testing |
63小时 |
Software Engineering 5 days
Day 1: Project Management
Project versus line management and maintenance and support
Project definition and project forms
Management – general rules and project management
Management styles
What is special for IT projects?
Basic project process
Iterative, incremental, waterfall, agile and lean project process
Project phases
Project roles
Project documentation and other artefacts
Soft factors and peopleware
PRINCE 2, PMBOK, PMI, IPMA and other project standards
Day 2: Business Analysis and Requirements Engineering Fundamentals
Defining business goals
Business analysis, business process management, business process improvement
The boundary between business and system analysis
System stakeholders, system users, system context and system boudaries
Why are requirements necessary?
What us requirements engineering
The boundary between requirements engineering and architectural design
Where is requirements engineering often hidden?
Requirements engineering in iterative, lean, and agile development and in continuous integration – FDD, DDD, BDD, TDD
Basic requirements engineering process, roles and artefacts
Standards and certifications: BABOK, ISO/IEEE 29148, IREB, BCS, IIBA
Day 3: Architecture and Development Fundamentals
Programming languages – structural and object-oriented paradigms
Object-oriented development – how much is history, how much is the future
Modularity, portability, maintainability and scalability of architectures
Definition and type of software architectures
Enterprise architecture and system architecture
Programming styles
Programming environments
Programming mistakes and how to avoid and prevent them
Modelling architecture and components
SOA, Web Services and micro-services
Automatic build and continuous integration
How much architecture design is there on a project?
Extreme programming, TDD and re-factoring
Day 4: Quality Assurance and Testing Fundamentals
Product quality: what is it? ISO 25010, FURPS etc.
Product quality, user experience, Kano Model, customer experience management and integral quality
User-centred design, personas and other ways to make quality individual
Just-enough quality
Quality Assurance and Quality Control
Risk strategies in quality control
The components of quality assurance: requirements, process control, configuration and change management, verification, validation, testing, static testing and static analysis
Risk-based quality assurance
Risk-based testing
Risk-driven development
Boehm’s curve in quality assurance and in testing
The four testing schools – which suits your need?
Day 5: Process Types, Maturity and Process Improvement
The evolution of IT process: from Alan Turing through Big Blue to lean startup
Process and process-oriented organization
The history of processes in crafts and industries
Process modelling: UML, BPMN and more
Process management, process optimization, process re-engineering and process management systems
Innovative process approaches: Deming, Juran, TPS, Kaizen
Is (process) quality free? (Philip Crosby)
The need and history of maturity improvement: CMMI, SPICE and other maturity scales
Special types of maturity: TMM, TPI (for testing), Requirements Engineering Maturity (Gorschek)
Process maturity versus product maturity: any correlation? any causal relationship?
Process maturity versus business success: any correlation? any causal relationship?
A forsaken lesson: Automated Defect Prevention and The Next Leap in Productivity
Attempts: TQM, SixSigma, agile retrospectives, process frameworks
Requirements Engineering - 2 days
Day 1: Requirements Elicitation, Negotiation, Consolidation and Management
Finding requirements: what, when and by whom
Stakeholder classification
Forgotten stakeholders
Defining system context – defining requirements sources
Elicitation methods and techniques
Prototyping, personas, and requirements elicitation through testing (exploratory and otherwise)
Marketing and requirements elicitation – MDRA (“Market-Driven Requirements Engineering”)
Prioritising requirements: MoSCoW, Karl Wiegers and other techniques (including agile MMF)
Refining requirements – agile “specification by example”
Requirements negotiation: types of conflicts, conflict-solving methods
Solving internal incongruence between some types of requirements (e.g. security versus ease of use)
Requirements traceability – why and how
Requirements status changes
Requirements CCM, versioning and baselines
Product view and project view on requirements
Product management and requirements management in projects
Day 2: Requirements Analysis, Modelling, Specification, Verification and Validation
Analysis is the thinking and re-thinking you do between elicitation and specification
Requirements process is always iterative, even in sequential projects
Describing requirements in natural language: risks and benefits
Requirements modelling: benefits and costs
The rules for using natural language for requirements specification
Defining and managing requirements glossary
UML, BPMN and other formal and semi-formal modelling notations for requirements
Using document and sentence templates for requirements description
Verification of requirements – goals, levels and methods
Validation – with prototyping, reviews and inspections, and testing
Requirements validation and system validation
Testing - 2 days
Day 1: Test Design, Test Execution and Exploratory Testing
Test design: after risk-based testing, choosing the optimum way to use the time and resources available
Test design “from infinity to here” – exhaustive testing is not possible
Test cases and test scenarios
Test design on various test levels (from unit to system test level)
Test design for static and for dynamic testing
Business-oriented and technique-oriented test design (“black-box” and “white-box”)
Attempting to break the system (“negative testing”) and supporting the developers (acceptance testing)
Test design to achieve test coverage – various test coverage measures
Experience-based test design
Designing test cases from requirements and system models
Test design heuristics and exploratory testing
When to design test cases? – traditional and exploratory approach
Describing test cases – how much detail?
Test execution – psychological aspects
Test execution – logging and reporting
Designing tests for “non-functional” testing
Automatic test design and MBT (Model-Based Testing)
Day 2: Test Organization, Management and Automation
Test levels (or phases)
Who does the testing, and when? – various solutions
Test environments: cost, administration, access, responsibility
Simulators, emulators and virtual test environment
Testing in agile scrum
Test team organization and role
Test process
Test automation – what can be automated?
Test execution automation – approaches and tools
|
|
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. |
|
technicalarc |
Technical Architecture and Patterns |
21小时 |
With the emergence of very complex distributed systems, complexity of a single system moved to the complexity of the architecture of the group of systems. This course covers the relationship of Software Architecture with Technical Enterprise Architecture. These two areas are interrelated in a way which currently is not well described. For example, splitting complex monolithic system into two systems communicating via web services will trigger substantial changes to both the new systems, and the architecture between them.
This course will cover trade-offs, currently common patterns and solutions for managing complex systems and communication within and between them.
Overview
System and Component Cohesion
System/component Dependencies
Software Architecture
Technical Architecture
Enterprise Architecture
SOA and Micro services architecture
Relationships between above concepts
Logic redudancy vs dependency
Data reduancy vs dependency
Software Architecture
Fundamentals
clarification of terms: architecture, design, modeling
orthogonality
conways Law
Common Architectures
modular decomposition
hierarchical architecture
centralised (Mediator Pattern)
event-based architecture
interrupt-based
OSI
client/server
layer model
Principles of OO Design
DRY, SRP
encapsulation
program against an interface
Liskovs principle
Law of Demeter
Design Patterns
what are Design Patterns
Creational Patterns
Structural Patterns
Behavioural Patterns
Model-Controller-View (MCV)
Design Tools
Domain specific language
Lexical Analysis
CRC cards
scenarios
Use Case descriptions
UML Graphical Representations
Class Diagram
Sequence Diagram
aggregation diagram
UML tools
Non-UML Graphical Representations
ER-modeling
State Machine
data flow
architectural model
Design and Maintenance
Lehmanns Laws
Architectural Antipatterns
Refactoring Strategies
SOA and Integration Patterns
Integration technologies and methods
Synchronous/Asynchronous
More details direct communication patterns
Direct and brokered communication
Message Queuing
ESB
Deployment Patterns
Code Deployment
Immutable deployment
Availability, Scaleability, High Performance, Fault tolerance patterns
Data and messages replication and clustering (CAP theorem)
|
|
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
|
|
sysml |
Systems Modelling with SysML |
21小时 |
This course is offered in two variants to provide a practical understanding of how systems can be modelling using the OMG's Systems Modelling Language (SysML) newest version 1.4. The notation and underlying semantics of SysML are explained in a way that allows students to apply what they learn to any suitable system modelling method or tool.
Introduction to System Modelling
What is a system model?
The four pillars of system modelling
Model centric vs document centric
What is SysML?
Relationship between SysML and UML
The four pillars of SysML
Common and Crosscutting Constructs
Profiles, stereotypes and tags
Diagram frames
Comments
Allocations
Requirement Diagrams
What is a requirement?
Modelling atomic requirements
Requirement traceability
Activity Diagrams
Modelling flow-based logic
Actions vs activities
Understanding token flow
Control flow vs object flow
Modelling decisions · Modelling concurrency
Swimlanes and responsibility
Use Case Diagrams
The system as a black box
Identifying the system boundary with actors
Use cases as system services
Behind the use case diagram
Use case structure · Nominal and alternative scenarios
Handling common behaviour
Extended and specialised behaviour
Block Definition Diagrams
What is a block?
Block features
Modelling types
Modelling system hierarchy
Generalising system elements
Internal Block Diagrams
Parts revisited
Ports with Flow Properties
Standard ports and interfaces
Proxy ports and interface blocks
Full ports
Parametric Diagrams
What is a constraint block?
Constraining system properties
Package Diagrams
What is a package?
Structuring the model with packages
Package containment
Package dependencies
Representing the model structure
Views and viewpoints
Sequence Diagrams
Interaction-based behaviour
Simple sequences
Synchronous vs asynchronous
Fragment nodes
Interaction use nodes
State Machine Diagrams
States and their syntax
Transitions between states
Pseudo state notation (initial, decision, history, end)
Decomposing states
Modelling concurrent states
System Modelling Resources and Further Reading
Suggested web resources
Recommended literature
|
|
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
|
|
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 |
|
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
|
