State Table Overview – State Machine modeling with the new State Table View.

Model Transformations – MDA Transforms, Platform Independent Model (PIM), Platform Specific Models (PSM).

Pan & Zoom – Pan and Zoom feature of EA to get an overview of large diagrams.

Basic Use Case Demonstration – A guide how to constructing a Use Case model with use cases, notes and issues.

HTML Generator – Overview of the HTML Documentation Generator.

Sequence Diagrams – Enhancements to Sequence Diagrams.

Bezier Lines and Triggers – Support for Bezier curves in StateMachine Diagrams.

Model Patterns – How to use the model patterns improving your modeling.

A deployment diagram models the run-time architecture of a system. It shows the configuration of the hardware elements (nodes) and shows how software elements and artifacts are mapped onto those nodes.

Features:

Node
A Node can either be a hardware or a software element and is shown via a three-dimensional box shape.

Node Instance
For example, node instances are shown on diagrams. You can distinguishe an instance from a node, if its name is underlined and has a colon before its base node type. An instance can or can not have a name before the colon.

Node Stereotypes

There are a lot standard stereotypes provided for nodes:
«cdrom»
«cd-rom»
«computer»
«disk array»
«pc»
«pc client»
«pc server»
«secure»
«server»
«storage»
«unix server»
«user pc»
Displayed by an appropriate icon in the top right corner of the node symbol.

Artifacts
Artifacts are products of a software development process including  process models, source files, executables, design documents, test reports, prototypes and user manuals.

Association
The association represents a communication path between nodes.

Node as Container
Within a node you can also contain other elements, like components or artifacts.

Role Binding
The role binding connector draws from a collaboration to the classifier that fulfils the role, shown by a dashed line.

Represents
Represents are drawn from a collaboration to a classifier showing that a collaboration is used in the classifier. Graphically viewed by a dashed line with arrowhead and the keywort “represents”.

Occurrence
To show that a collaboration represents its classifier, an occurrence connector is drawn from a collaboration to a classifier, shown as adashed line with arrowhead and the keyword “occurrence”.

Here you can read part 1 of the UML 2 composite structure diagram.

Part
Parts are elements which represent a set of one or more instances that are owned by a containing classifier instance and it is shown as an unadorned rectangle contained within the body of a class or component element.

Ports
Ports are defining interaction between a classifier and its environment, shown with a named rectangle on the boundary edge of its owning classifier.

Interfaces
Interface operations are public and abstract and they are similar to a class having a lot of restrictions. It can be shown as a circle.

Delegate Connector
The delegate connector connects an external contract of a component as shown by its ports to the internal realization of the behavior of the component’s part to view an internal working of a component’s external ports and its interfaces.

Don’t miss part 2 of the UML2 composite structure diagram.

Generalizations
With a generalization you indicate inheritance. If it’s drawn from a specific classifier to a general classifier, the generalize implication is that the source inherits the target’s characteristics.

Aggregations
Aggregations are depicting elements which are made up of smaller components. This aggregation relationships will be shown by a white diamond-shaped arrowhead pointing towards the target or parent class.

Association Classes
With an association class you can construct an association connection to make operations and attributes.

Dependencies
If you need to model a wide range of dependent relationships between model elements you use dependencies. This will be done early in the design process. Later on the dependencies will be stereotyped or replaced with more specific data.

Traces
With traces yo can easily track requirements or model changes, because it is a specialization of a dependency, linking model elements or sets of elements, representing the same idea across models.

Realizations
A realization expresses traceability and completeness in a model.

Nestings
Nestings are connectors showing source elements within a target element.

Click to read part 1 of the UML 2 Class Diagram

Definitions:
Classes
Classes are elements that define the attributes and behaviors of an object . A behavior describes possible messages of the class along with operations. Within classes you can also define constraints, tagged values and stereotypes.

Class Notation
A class shows the name of the class and optionally the name of the operations and attributes. The compartments divides the class name,  attributes and operations.

Interfaces
The interface is a contract with a specification of behaviors that implementers agree to meet. In an interface, classes are guaranteed to support the required behavior. You may draw the interface in a similar style to a class, specified with operations, or you draw it as a circle with no details to explicit operations.

Tables
Tables are not a part of the base UML, it’s more an example of what can be done with stereotypes. When a table is drawn you can see a small table icon in the upper right corner.

Following in part 2 of the UML Class Diagram.

With components you define boundaries and group elements into logical structures. These component diagrams are similar in practice to package diagrams, the differences between package diagrams and component diagrams are, that component diagrams are offering  more semantically rich grouping mechanism and  in component diagrams all elements of the model are private, whereas package diagrams are displaying public items.

Comprehensive support for UML 2.1
	Support for all 13 UML 2.1 diagrams
	Behavioral diagrams includes: Use Case, Activity, State, Interaction Overview, Sequence and Communication
	Structural diagrams include: Package, Class, Object, Composite, Component and Deployment
	Support for UML 2.0 style Profiles
	See UML 2.0 Tutorial for more information
	See also:
	Use Case Model
	Business Process Model
	Dynamic Models
	Logical Model
	Component and Deployment diagrams
	Custom Extensions
	Collaborations
Intuitive and great looking User Interface
	Extensive range of toolbars, dockable windows and visual styles
	Save and restore custom window layouts
	Modify and customize toolbars and menus
	Create your own accelerators
	“Slide away” style docked windows to maximize screen space and improve work effectiveness
	Comprehensive menuing system for ultimate control of your model
	Quick Linker allows fast, context-sensitive creation of diagram elements and connections.
MDA Transformation support
	Model Driven Architecture support for transforming simple model elements into complex targets
	Fully template driven transformations
	Easy to write and modify transform templates
	Built in transforms for DDL, Java, C#, EJB, XSD
	Forward generate and synchronize your Platform Specific Model from your Platform Independent Model
	Each PIM can support multiple PSMs
Comprehensive and flexible documentation
	Full WYSIWYG template driven RTF generator
	Templates support all EA model elements properties and extended data (such as Tests, Risks, Resources, Changes etc.)
	Templates support headers, footers, table of contents, embedded images, title pages, complex nested tables and more
	Output in rich text format
	Flexible output options with filters and selection criteria
	Save report templates for later re-use
	Word compatible documentation for post-editing and linking in to Word Master Documents
	Additional HTML report generator for creating detailed HTML reports
	Post your model on the internet or on a local intranet using the HTML report generator
	Additional reports including for use case metrics, tests and more
	Rich text Documents can be linked to model elements and edited directly using built-in Rich Text editor
Forward and Reverse Code Engineering
	Fully template driven code generation engine – modify inbuilt templates or write your own from scratch
	Add additional target languages
	Syntax highlighted source code editor with quick “save and synch” capability
	Inbuilt support for C++, Java, C#, VB.Net, Visual Basic, Delphi, PHP, Python and ActionScript
	Support for CORBA also available as free plug-in
Plug-ins to link EA to Visual Studio .NET or Eclipse
	MDG Link adapters available as separate add-ons
	Link to your favorite IDE
	Use EA to navigate, reverse engineer and track complete model – use your IDE for development
	Locate source code for classes, attributes and operations in your IDE directly from EA
	Build and Run your project from EA’s plug-in menu
	View compilation errors in EA
Support for “pluggable technologies” using MDG (Model Driven Generation) Technologies
	Add support for new languages, modeling profiles and more
	Easy to build and maintain
	Single import for complete set of templates, grammars, data types, Profiles, Patterns and more
	Distribute domain specific solutions with ease
	MDG Technology wizard built in to make assembling Technology files easy
Database modeling
	Reverse engineer from many popular DBMS systems, including Oracle 9i and 10g, SQL Server, My SQL, Access, PostgreSQL and others
	Model database tables, columns, keys, foreign keys and complex relationships using UML and inbuilt data modeling Profile
	Forward generate DDL scripts to create target database structures
Ability to Share models in different ways
	Share .EAP files by placing on a shared network drive (small workgroups)
	Use .EAP file replication for complex distributed development
	Support for several different DBMS based repositories, including Oracle 9i and 10g, SQL Server, My SQL, PostGreSQL
	Support for XMI import export to manage distribution and update of frameworks and other package based model structures
	Version control repository support
	Data transfer wizard to allow up- and down- sizing of complete models for maximum flexibility
	Ability to export and Import basic reference data to avoid setting up the same information multiple times
Version Control Support
	Integration with Subversion, CVS and SCC-compliant version control repositories
	Package level versioning
	Excellent support for nested version controlled packages
	Compare utility allows viewing changes in current model to latest file on disk
	All versioned packages stored in standard XMI format for portability and ease of manipulation
	Get All Latest feature plus nested package support allows complex models to be built from single imported package
XML Schema Support
	Built-in profile for XSD to simplify development of XML schemas using UML
	Generate complex XML Schema from UML models
	Transform simple models into XSD models using MDA transformations, then generate XSD to file
	Reverse Engineer XML schema into UML models
	Forward Engineer XML schema from UML models
Compare (diff) Utility
	A comprehensive differencing engine based on comparing current model content to a standard XMI file
	Full support for model element properties, connectors, attributes, methods, extended data (tests, changes, requirements, constraints etc)
	For version controlled packages, instantly compare with latest file on disk
	Compare a package with any XMI file – great for model to model comparisons
	Compare current package to stored Baseline
Baseline support
	Store a snapshot of a current package branch within EA
	Data is stored in compressed format within the current model for ease of reference and portability
	Use the Compare function to compare a Baseline to the current version of a package in the model
	Great for managing change, especially to critical areas such as requirements and use case models
Reverse Engineer binary files from Java and .NET
	Support for importing .JAR files in java
	Import .NET assemblies and more
	.NET import supports both reflection based import and import of files decompiled to IL using the .NET decompiler
	Debug facility allows automatic generation of sequence diagrams from a running application
Requirements Management support
	Custom “Requirements” elements as Profiled UML class
	Support aggregation, composition, nesting and other complex relationships between requirements
	Hierarchy view to show detailed interconnections between elements
	Full traceability support using Hierarchy and Matrix views
	Ability to attach requirements to other model elements and view traceability from requirement right through to deployed components
	Compare utility to manage requirement change
	Baseline support to capture requirements at a “point in time”
	Version control support to help manage the development and change to requirements
Import/Export of Models in XML format
	Support for XMI 1.0, 1.1 and 1.2
	Export complete EA models to XMI
	Standard XML for use by 3rd party tools, such as MDA generators and report writers
	Import from other XMI compliant tools in UML 1.1 or 1.3 format
User Security support
	Built in user security
	Support for groups as well as users
	Many different permissions can be set
	2 basic models:
	- User must “lock” to edit (checkout model)
	- Free editing with ability for user to “lock” elements/packages as required (free model)
Support for Testing
	Unit tests
	Integration tests
	System tests
	Acceptance tests
	Scenarios
	Reporting of details fully supported in RTF document generator
Support for Maintenance
	Change control details
	Maintenance and fault recording
	Track issues and defects
	Reporting of details fully supported in RTF document generator
Support for Project Management
	Detailed support for attaching resources to elements such as Use Cases, components, packages, sub-systems etc.
	Support for detailing Risk items
	Support for detailing effort items attached to a model element
	Support for attaching custom Metric types to any model element
	Reporting of details fully supported in RTF document generator
	Support for Use Case Metrics – allows project resource and time estimation based on given metrics
Support for System status information
	Glossary support for defining key project terms
	System Tasks to track important work items
	System Issues to track model level changes and problems
	Reporting of details fully supported in RTF document generator
Fully featured Automation interface for scripting EA and writing complex plug-ins
	Very detailed automation interface with access to most element features and attached information
	Most properties fully writable from automation client
	Great support for plug-ins with the ability to embed automation client windows in the main diagram view
	Access to major EA functions such as XMI import/export
	Interface accessible from any automation aware client language – such as VB, C#, C++. Delphi etc.
WSDL Engineering Support
	Built-in profile for WSDL to simplify development of Web Services using UML
	Reverse Engineer WSDL documents into UML
	Forward Engineer WSDL from UML
	Transform simple models into XSD models using MDA transformations, then generate XSD to file
Business Process Execution Language (BPEL) Support
	Support for generating BPEL 1.1 from BPMN 1.1 models
	BPMN 1.1 Technology and BPEL diagram type
	Specific property dialogs for BPMN 1.1 elements when placed on BPEL diagrams
Business Rules Modeling and Code Generation
	Support for defining Fact and Rule Flow models
	Rule Composer traces executable business logic from Rule Tasks to natural language business rules
	Support for executable code generation from business rules
Systems Engineering
	Advanced Behavioral Modeling and executable Code Generation
	SysML 1.1 and Parametric Model simulation
	Hardware Description Language support for SystemC, VHDL and Verilog
High Performance Collaborative modeling and remote access
	Load on demand using the Lazy Load feature for massive-scale DBMS models
	WAN Optimizer service for enhanced performance over slow or remote network connections to repository
	Lazy Load and WAN Optimizer service combine to reduce load times and improve response times for large-scale, shared models
Plus lots more …
	Traceability reporting
	Excellent search facilities
	Flexible appearance, color and display options
	Spell Checker
	Many different image formats for saving diagrams

Note: Features sets will vary by edition. Please check the feature matrix to ensure a required feature is present in the edition you purchase.

A tool is only as good as the craftsman who’s using it.

Our training corresponds to the highest of requirements. Our experienced coaches are professionals and specialists in their area and successfully use Enterprise Architect in the field.

Sparxsystems offers high end customized UML trainings with Enterprise Architect for people who are involved in the development of information technology, like project managers, system designers or developers.

Just must not be a guru, but it is helpful to have fundamental knowledge concerning the concepts of object-oriented programming and basic comprehension of CASE-Tools and their functionality.

Contents:

• Knowledge of the most important types of UML diagrams
• Implementation of the analysis by means of UML in EA considered as example project
• Construction of a data model in EA
• Development of a UML class model based on the diagrams of the analysis phase
• Forward and reverse engineering (i.e. automated construction of source code in Delphi oder C# as well as the extraction of UML diagrams from source code)
• Metrics for quality assurance (overview), Relationship Matrix
• Testing and issue tracking functions
• Automated development of project documentation (HTML, RTF)
• Team collaboration in EA
• Application of user-oriented patterns
• UML profiles
• Data migration of other UML tools (such as Together, Rational)

Do not hesistate to contact us for an individual date or request an offer: sales(at)sparxsystems.at.

To load and work with different profiles, Enterprise Architect uses a generic UML Profile mechanism. UML Profiles for EA are specified in XML files, which may be imported into EA in the resource page of the project browser. Now you can drag and drop profile elements and EA attaches the stereotypes, tagged values and default values, notes and even metafiles to the new element.

UML Profiles for SPEM v1.0 (beta) (from “Software Process Engineering Metamodel Specification” by the OMG) Defines a set of stereotypes, process definitions and components based on the SPEM specification.

UML Profile for XSD Schema (from “Modeling XML Applications with UML” by David Carlson) This profile defines a set of stereotypes and tagged values for defining XSD Schemas. XSDDataTypes.xml und XSDDataTypes.xml

UML Profile for Web Modeling (from “Building Web Applications with UML” by Jim Conallen) Defines a set of stereotypes for working with Web pages, Servers, Scripts, ASP, JSP and more.

UML Profile for Business Process Modeling – UML Profile for Business Modeling derived from the example profile in the UML 1.4 Specification.

Eriksson-Penker Extensions for Business Process Modeling (from “Business Modeling with UML” by Hans-Erik Eriksson and Magnus Penker).
This profile is used to define a set of stereotypes for working with Business Activities, Processes, Objects and Information flows.