Enterprise Architect version 15.0

download
purchase

enzh-CNcsnlfrdehiiditkoplptruskessv

My Profile

Social Media Channels

facebook  twitter  youtube   linkedin

doug rosenberg

doug rosenberg

doug rosenberg

Parallel Agile, Inc. (Founder, Chief Technology Officer) - formerly ICONIX (CEO)
After running ICONIX for 35 years and writing 7 books on UML, use cases, and agile software development, Doug discovered a new way to improve productivity by leveragng parallel development, and founded Parallel Agile (www.parallelagile.com) in 2018 after 4 years of test projects at the USC Center for Software and Systems Engineering, where he's been working with Prof. Barry Boehm.   A new book "Parallel Agile - Faster Delivery, Fewer Defects, Lower Cost" is mostly written and will be released during 2019.   We're also developing a Parallel Agile Add-In for Enterprise Architect and are available for training and consulting.  
In his previous lifetime...
 
Doug Rosenberg founded ICONIX in his living room in 1984 and began training companies in object-oriented analysis and design around 1990. ICONIX specializes in JumpStart training for UML and SysML, and offers both onsite and open-enrollment courses.
Doug developed a Unified Booch/Rumbaugh/Jacobson approach to modeling in 1993, several years before the advent of UML, and began writing books around 1995. Design Driven Testing is his 6th book on software engineering. He’s also authored numerous multimedia tutorials (including Enterprise Architect for Power Users) and several eBooks, including Embedded Systems Development with SysML.
Doug has spent the last few years doing "deep dive" consulting into cutting-edge technology including cross-platform mobile app development, REST APIs, and NoSQL databases, and gaining first-hand experience on some "hardcore agile" projects of varying sizes.  He's also been working with dozens of graduate students at the University of Southern California Center for Systems and Software Engineering (USC CSSE), managing Directed Research projects and developing/piloting the Parallel Agile process.

 

 

Doug Rosenberg, ICONIX

 

At ICONIX, we’ve had pretty good success when we defined an unambiguous development process, and presented that development process in “roadmap” form. We’ve developed process roadmapsfor use case driven software development, business modeling, design-driven testing, and algorithm-intensive software design. In this article we’re going to do it again, this time using SysML to describe embedded systems that involve a combination of hardware and software.

Figure 1 – ICONIX Process Roadmap for Embedded Systems Development

Figure 1 – ICONIX Process Roadmap for Embedded Systems Development

Figure 1 shows the top level roadmap for ICONIX Process for Embedded Systems.  As you can see, our roadmap starts off by defining requirements, proceeds through modeling of system behavior and block structure, and then through definition of constraints and parametrics, simulation, and then implementation in both hardware and software. We’ll illustrate our roadmap using an example model, developed by Sam Mancarella from Sparx Systems, that describes an Audio Player.

We’ll also introduce you to some unique capabilities of Enterprise Architect Systems Engineering edition, which supports advanced features such as executable code generation from UML models (including support for hardware description languages such as Verilog and VHDL), executable SysML Parametric diagrams and advanced scripting.

Each of these capabilities, taken standalone, adds a significant amount of “horsepower” to a systems engineering effort. We’ll combine these capabilities into a single process roadmap that’s greater than the sum of its parts.

The Four Pillars of SysML - Requirements, Structure, Behavior, and Parametrics

Our Embedded System Development Process Roadmap is built around producing a SysML model that is organized into four sections. These parts of the overall system model (Requirements, Structure, Behavior, and Parametrics) are sometimes referred to as “The Four Pillars of SysML”.[1] As with UML, Packages are used to organize the model.

SysML Pillar #1: Requirements

Requirements are generally categorized as Functional Requirements, which represent capabilities of a system, and Non-Functional Requirements, which cover such areas as Performance and Reliability. You can organize Requirements into hierarchies on requirement diagrams (see Figure 2).

EA supports allocation of requirements to other elements using a simple drag-and-drop, and automatic generation of traceability matrices.

Figure 2 – Requirements for the Audio Player include Performance, Durability and

Figure 2 – Requirements for the Audio Player include Performance, Durability and User Friendliness

 

Figure 3 shows the steps for Requirements definition from our process roadmap. Note that allocation of Requirements to System Elements is really an ongoing process as the model is developed, and largely occurs within other roadmap activities.

Figure 3 – Roadmap: Define System Requirements

Figure 3 – Roadmap: Define System Requirements

SysML Pillar #2: Structure

Blocks can be used to represent hardware, software, or just about anything else. Block definition diagrams represent system structure. Internal block diagrams describe the internals of a block such as parts, ports, and connectors.

Figure 4 – Block Structure for the Audio Player

Figure 4 – Block Structure for the Audio Player

 

Figure 5 shows how our process roadmap approaches defining system structure.

Figure 5 – Roadmap: Model System Structure

Figure 5 – Roadmap: Model System Structure

If you think of a Block as an electronic circuit (one of many things that a Block can describe), the Ports define the input/output signals to and from the circuit. SysML allows you to describe the I/O signals and transformations in great detail, and EA contains a built-in simulator that allows you to plot the output graphically.


SysML Pillar #3: Behavior

SysML provides four main constructs to represent different aspects of system behavior; use cases, activity diagrams, sequence diagrams, and state machines. As shown in Figure 6, our roadmap shows two parallel branches for modeling system behavior.

Figure 6 – Roadmap: Model System Behavior

Figure 6 – Roadmap: Model System Behavior

One branch starts with use cases[2], which describe scenarios of how users will interact with the system. Use cases generally consist of a “sunny-day” part, which describes a typical success-path for the scenario, and multiple “rainy-day” parts which describe unusual conditions, exceptions, failures, etc. Figure 7 shows a Use Case Diagram which organizes the scenarios in listening to the Audio Player.

Figure 7 – Audio Player Use Cases

Figure 7 – Audio Player Use Cases

Use cases are typically detailed on Interaction (Sequence) Diagrams, which can also be drawn at a higher level.  Figure 8 shows Interactions between the Listener and the Audio Player.  Note the use of parallel paths on the Interaction Diagram.

Figure 8 – Audio Player Interactions, showing interactions occurring in parallel

Figure 8 – Audio Player Interactions, showing interactions occurring in parallel

 

The other branch on the roadmap involves defining event-driven, finite-state behavior of some part of a system using state machines. As a simple example, Figure 9 shows some finite state behavior associated with Playlist Maintenance for our Audio Player.

Figure 9 – Finite State Behavior for Playlist Maintenance

Figure 9 – Finite State Behavior for Playlist Maintenance

One of EA’s unique capabilities is the ability to generate functional (algorithmic) code from state machines. As you’ll see, these state machines can be realized in software or in hardware using Hardware Description Languages (HDLs).

Requirements are allocated to both use cases and states.

 

 

SysML Pillar #4: Parametrics

Parametrics allow us to define detailed characteristics, physical laws, and constraints on system blocks that allow us to simulate how a system will behave, then make engineering tradeoffs, and re-simulate until our design meets the specified requirements.

Figure 10 – Roadmap: Define Constraints and Parametrics

Figure 10 – Roadmap: Define Constraints and Parametrics

Our roadmap provides two high-level activities in this area; the first to define constraint blocks and parametric diagrams (shown in Figure 10 and illustrated in Figures 11 and 12), and the second to configure and execute the simulations (shown in Figure 13).

Figure 11 – Constraint Blocks for the Audio Player’s “Echo” signal processing fu

Figure 11 – Constraint Blocks for the Audio Player’s “Echo” signal processing function

 

Figure 12 – Parametric model for the Audio Player’s “Echo” signal processing fun

Figure 12 – Parametric model for the Audio Player’s “Echo” signal processing function


Simulation

The ability to configure and execute simulations within EA, eliminating the need to export the model to external simulation software, is one of the unique capabilities of the Sparx SysML solution.

Figure 13 – Roadmap: Simulate

Figure 13 – Roadmap: Simulate

EA’s built-in support for scripting and graphical display of simulation results tightens the feedback loop on making engineering tradeoffs in the model to rapidly ensure that all system requirements are met.

Figure 14 – Results of simulating the “Echo” function are displayed within Enter

Figure 14 – Results of simulating the “Echo” function are displayed within Enterprise Architect and do not require the use of external simulation software.

Implement Hardware

Hardware Description Languages allow the specification of electronic circuits in a software-like representation. According to Wikipedia[3]:

In electronics, a hardware description language or HDL is any language from a class of computer languages and/or programming languages for formal description of electronic circuits, and more specifically, digital logic. It can describe the circuit's operation, its design and organization, and tests to verify its operation by means of simulation.

 

Figure 15 – Roadmap: Implement Hardware

EA’s long-proven ability to generate code has been extended to support code generation in VHDL, Verilog, and System C in the Systems Engineering Edition. While code generation is independent of SysML usage, from a process roadmap standpoint, this means we can drive both hardware and software implementation from our SysML model. Once code is generated in an HDL, it’s possible to “compile to silicon” to realize the hardware solution on a chip.  This process is shown in Figures 16 and 17, which show how a playback controller can be generated in VHDL.

Figure 16 – SysML model of hardware component for controlling audio playback

Figure 16 – SysML model of hardware component for controlling audio playback

 

Figure 17 – Audio playback controller, generated in VHDL

Figure 17 – Audio playback controller, generated in VHDL

Implement Software

Software implementations can leverage a variety of powerful capabilities that are included with the System Engineering Edition of EA. Two of the more important and unique capabilities are:

  • The ability to generate functional (algorithmic) code from behavioral models (state machines, activity diagrams,  and interaction diagrams)
  • The ability to integrate EA models into development environments such as Eclipse and Visual Studio.

Figure 18 shows a high-level look at the Software Implementation activity from the roadmap.

 

Figure 18 – Roadmap: Implement Software

Figure 18 – Roadmap: Implement Software

Conclusion

This article has presented a high-level overview of ICONIX Process for Embedded Systems, which leverages Enterprise Architect System Engineering Edition to build hardware/software models that are structured around the “four pillars of SysML”.  We’ve illustrated our process roadmap with diagrams from Sam Mancarella’s Audio Player Example.

This topic will soon be expanded into an “eBook”: Embedded Systems Development using SysML and Enterprise Architect.

For more information, visit ICONIX on the web at www.iconixsw.com, or contact us at This email address is being protected from spambots. You need JavaScript enabled to view it.

 

 

 


[1] OMG Systems Modeling Language Tutorial, INCOSE 2008

[2] See Use Case Driven Object Modeling with UML: Theory and Practice by Doug Rosenberg and Matt Stephens for a lot more information about use cases.

[3] http://en.wikipedia.org/wiki/Hardware_description_languages

(Article originally published in SDJournal)

This article presents an easy step-by-step formula that will get from code to a comprehensive test plan, that includes a complete set of unit test code, using the free Agile/ICONIX add-in for EA.  

Here are the 6 steps that we’ll follow:

1)Reverse engineer some code

2)Generate tests from Class Operations

3)Add test scenarios in EA’s testing view

4)Transform the test cases to test classes

5)Generate the unit test code from the test classes

6)Generate a test plan report

We’ll illustrate this approach one step at a time in this article, using some reverse engineered ActionScript (Flex) code from the example project we built while writing  Design Driven Testing.  

 

This article gives an overview of how to use Enterprise Architect's new Structured Scenario capability to generate acceptance tests by expanding "use case threads". If you consider a use case with one “sunny day” scenario and four “rainy day” scenarios, you can expand that use case into at least five “threads”, each of which defines a potential acceptance test for some part of your system...

 


ICONIX is pleased to announce the availability of a beta version of the latest Agile/ICONIX Add-in.

The beta installer can be downloaded from http://www.sparxsystems.com/bin/Iconix_AgileDev2.0.exe.

 

There are 3 notable new capabilities of the new add-in:

1) Support for "DDT/Systems" - Design Driven Testing for SysML models, including automatic generation of interface tests from SysML IBDs, and automatic generation of state machine testing, including Trigger/Do/Entry/Exit behaviors.

2) "More agile" automatic test case generation from class operations.  Agilists will like this one, because it's now possible to reverse engineer your as-built code, and autogenerate a complete set of JUnit test stubs.

3) Inclusion of the "ICONIX Technology" which includes process roadmaps and project templates for use case driven projects using UML, embedded systems projects using SysML, Business Process Modeling using Structured Scenarios, and Service-Oriented Architecture projects.

Betatesters of the new add-in are invited to send us feedback at This email address is being protected from spambots. You need JavaScript enabled to view it..

 

 

I’ve never believed in teaching tools, notation, or modeling in the absence of a process. The reason this book has so many process roadmaps is that there are lots of different kinds of software and systems being developed. 

Which roadmap fits the problem you are trying to solve? The following guidance might be helpful:

For embedded system development follow ICONIX Process for Embedded Systems(SysML)

For SOA and web service development follow ICONIX Process for Service Oriented Architectures

For business process modeling follow the ICONIX Business Modeling Roadmap

For algorithm intensive develoment follow ICONIX Process for Algorithms

For normal GUI-based software follow ICONIX Process for Software (use case driven object modeling)

 


 

This book documents several roadmaps and illustrates their use by example. I hope you find them helpful.

Doug Rosenberg

ICONIX's upcoming Open Enrollment Class in Washington DC has had a date change. New dates are May 16-20, 2011.  


 

 

Course agenda follows.

Monday:  Business Process Modeling with Structured Scenarios

Students will use Enterprise Architect's "structured scenario editor" to model business processes for a bookstore warehouse, following the "ICONIX Business Modeling Roadmap" as defined in the article "Business Process Modeling with Structured Scenarios"

Tuesday: Getting from Use Cases to Code with ICONIX Process

Students will use Enterprise Architect to model an interactive hotel mapping system, starting from the ICONIX Project Template model, and following "ICONIX Process for Software" roadmap as described in "Use Case Driven Object Modeling, Theory and Practice".  Exercise will include a Domain Model, Requirement Model, User Interface Storyboards, Use Cases, Robustness Diagrams, Sequence Diagrams, and Class Diagrams.

Wednesday: Design Driven Testing

Students will use Enterprise Architect to generate test cases, test code, and test plans for the interactive hotel mapping system, as described in the book "Design Driven Testing".  Exercise will include Unit Tests, Controller Tests, Scenario Tests, and Requirement Tests and will use the Agile/ICONIX Add-In (for unit, controller, and requirement tests) and the Structured Scenario Editor (for scenario tests).

Thursday: Modeling Service Oriented Architectures.

Students will use Enterprise Architect Business and Software Engineering Edition to model a service-oriented Car Rental System, using the ICONIX SOA Project Template, and following the "ICONIX Process for Service Oriented Architecture" roadmap as described in the book "ICONIX Process Roadmaps".  Exercise will include BPMN and WSDL modeling, BPEL code generation, and Behavioral Code Generation from Business Rules.

Friday: Embedded Systems Modeling with SysML

Students will use Enterprise Architect Systems Engineering Edition to model a 2-way wristwatch TV in SysML, using the ICONIX SysML Project Template, and following "ICONIX Process for Embedded Systems" roadmap as described in the book "ICONIX Process Roadmaps".  Exercise will include: Block Definition Diagrams, Internal Block Diagrams, State Machines, Use Cases, Interaction Diagrams, and Constraint/Parametric Diagrams.

Registration information on the ICONIX website at http://www.iconixsw.com/EA/PublicClasses_WDC.html

Or contact This email address is being protected from spambots. You need JavaScript enabled to view it. for further details.

 

Because different people use Enterprise Architect to do different things, ICONIX has developed a series of "process roadmaps" to guide you through a variety of development problems.  In addition to use case driven object modeling, we've developed roadmaps for modeling Service Oriented Architectures, Modeling Embedded Systems using SysML, Business Process Modeling, and Design Driven Testing.  

Now we're delivering a 5 day series of "training modules" called Hands On ICONIX Process where you can go hands-on and work through whichever processes you need for your projects.  I'll be teaching these workshops personally, and if there's enough demand, I might be accompanied by my co-author Matt Stephens.

 

Agenda

Monday: Business Modeling using Structured Scenarios

Students will use Enterprise Architect's "structured scenario editor" to model business processes for a bookstore warehouse, following the roadmap defined in the article Business Process Modeling with Structured Scenarios

Tuesday: ICONIX Process: Getting from Use Cases to Code

Students will use Enterprise Architect to model an interactive hotel mapping system following ICONIX Process as described in Use Case Driven Object Modeling, Theory and Practice.  

Wednesday: Design Driven Testing

Students will use Enterprise Architect to generate test cases, test code, and test plans for the interactive hotel mapping system, as described in the book Design Driven Testing.  

Thursday: Modeling Service Oriented Architectures (SOA):

Students will use Enterprise Architect Business and Software Engineering Edition to model a service-oriented Car Rental System, following roadmap as described in the eBook Modeling Service Oriented Architectures.

Friday: Embedded Systems Modeling using SysML

Students will use Enterprise Architect Systems Engineering Edition to model a 2-way wristwatch TV in SysML, following the roadmap described in the eBook Embedded Systems Development using SysML

Pricing:

Students may enroll for whichever days they choose at the following price schedule (price includes books):

1 day: $995
2 days: $795/day
3-5 days: $595/day

More details are available on the ICONIX website here.

 

The groundbreaking book Design Driven Testing brings sanity back to the software development process by flipping around the concept of Test Driven Development (TDD)—restoring the concept of using testing to verify a design instead of pretending that unit tests are a replacement for design. Anyone who feels that TDD is “Too Damn Difficult” will appreciate this book. Design Driven Testing shows that, by combining a forward-thinking development process with cutting-edge automation, testing can be a finely targeted, business-driven, rewarding effort. In other words, you’ll learn how to test smarter, not harder.

  • Applies a feedback-driven approach to each stage of the project lifecycle.
  • Illustrates a lightweight and effective approach using a core subset of UML.
  • Explains how to use Enterprise Architect to generate automatically acceptance test cases from structured scenarios
  • Explains how to use Enterprise Architect and the Agile/ICONIX add-in to generate JUnit and FlexUnit test code
  • Follows a real-life example project using Java and Flex/ActionScript.
  • Presents bonus chapters for advanced DDTers covering unit-test antipatterns (and their opposite, “test-conscious” design patterns), and showing how to create your own test transformation templates in Enterprise Architect.

What you’ll learn

  • Create unit and behavioral tests using JUnit, NUnit, FlexUnit.
  • Generate acceptance tests for all usage paths through use case thread expansion.
  • Generate requirement tests for functional requirements.
  • Run complex acceptance tests across the enterprise.
  • Isolate individual control points for self-contained unit/behavioral tests.
  • Apply Behavior Driven Development frameworks like JBehave and NBehave

Design Driven Testing should appeal to developers, project managers, testers, business analysts, architects…in fact anyone who builds software that needs to be tested. While equally applicable on both large and small projects, Design Driven Testing is especially helpful to those developers who need to verify their software against formal requirements. Such developers will benefit greatly from the rational and disciplined approach espoused by the authors.

 

Design Driven Testing

ICONIX SysML JumpStart Training provides focused, intensive lecture/lab workshops that include hands-on experience using Enterprise Architect Systems Engineering Edition, and lab time devoted to YOUR specific project. Our Embedded Systems Roadmap is built on "the 4 pillars of SysML" -- Requirements, Structure, Behavior, and Parametrics. The Roadmap also leverages unique capabilities of Enterprise Architect Systems Engineering Edition including built-in Parametric Simulation and Hardware Description Language Code Generation.

Our instructors are experts in using Enterprise Architect and, while driving EA in the lab, our instructors will teach you valuable techniques to make your team more effective and efficient users of Enterprise Architect.

SysML JumpStart Training reinforces the concepts learned in lecture by applying the methods learned to your real project in the lab--a valuable and practical benefit to your training team. Materials are learned and retained better by the students since it's relevant to the team project, directly applied to the project, and there is no "down time" before applying the information learned.

In our training classes you get real project work done, become more effective with Enterprise Architect and become proficient in SysML modeling using ICONIX Process for Embedded Systems.

 

Page 3 of 4