IBM Engineering Rhapsody Tip #111 - Rhapsody 10 and fixing SysMLHelper example

One for more advanced Rhapsody users this one. This video is a thought a little look behind the scenes, showing I fix I needed to make to the open-source SysMLHelper I have on GitHub to get my Executable MBSE Profile to work with Rhapsody 10.0.3. It's for the Rhapsody geeks perhaps, but then I do think the metamodeling profile that I use is pretty handy. A bit of a drop-off in Cameo SysML/UAF training for me, but I have had some flair-ups in interest in the Executable MBSE Profile helper over the last year. There has been a bit more interest in Rhapsody and a pick-up in interest in executable systems modeling hence been exploring Rhapsody 10.0.3 more recently.

Here's the transcript:

Hello, welcome to my video 111 on the currently owned by IBM, SysML/UML2 tool, called Rhapsody. 

I've been testing Rhapsody 10 with one of my open source profiles called the Executable MBSE Profile. There is still life in the old dog, perhaps, and that's not just the tool. This is 10.0.3 which was released in April 2026. As you can see Rhapsody 10 has a new Visual Studio dock able windows style user interface.

As you can see most of it works fine, but I did find an issue with my new term activity diagram called Textual Activity, When you draw a control flow, it wants Transition in the aggregates list for the diagram stereotype.  This stereotype is the profile. Most things in Rhapsody are controllable through properties, there are thousands of them, but these are the overridden properties for my profile's Textual Activity stereotype, including the aggregates property that controls the ownership in the browser, which is giving us this problem in Rhapsody 10.

The profile itself is read-only here, as it's been copied into the Profiles folder, so that it can be added by reference to multiple models.

One of the great things about Rhapsody is its upward compatibility and also the stability of its Java API for writing plugins, hence in this video I'm going to walk through the steps I have taken to update the profile to fix the issue. This will also highlight its open source nature/ As you can see here, it is in GitHub, and part of an assembly of profiles called the SysMLHelper.

--------

The version of the Executable MBSE Profile I'm going to fix for Rhapsody 10 is in the 4.3.h.Release of the SysML Helper.

Now a nuance here is that the Rhapsody version I'm using to maintain the profile's file format is 8.3.1, a conscious decision I took, as this was a highly stable version after Rhapsody moved to an xml-based file format for storing units. 

This means that the profile format can be read by versions of Rhapsody, 8.3.1 and above, including version 10. This is one advantages of maintaining my own profile outside of a Rhapsody release cycle. We can use it with older versions, if we want.

I'm actually cloning the GitHub profile directly into my Profiles folder of my 8.3.1 installation. The Share folder in 8.3.1 is stored in a read-write location, in this case by ProgramData folder as it was installed for all users.

--------

I'll start by launching Rhapsody 8.3.1 then. Although this is Windows 11, I was still able to make it work, although there were a few compatibility warnings during installation.

It doesn't really matter too much which edition I launch here, so I'll launch the Designer Edition of Rhapsody. 

I get the usual animation won't work warning as I also have Rhapsody 10 open, but that's not an issue. 

The Executable MBSE Profile is managed by a combination of a profile, stored in a Rhapsody project, and a Java plugin, developed using the free Eclipse IDE Java development environment.

I'll start by opening the project that has the profile in it therefore, and this is in the 8.3.1 Profiles folder I just did the Clone of the GitHub repository into.

Now the interesting thing about the ExecutableMBSE profile is that it has a lot of new term stereotypes and a lot of properties that need to be kept consistent, hence I moved to using a metamodel with a self-built java helper to do this, the project is therefore bigger than you think.

--------

With it now open, you can see that this is the same unit that was added by reference to my test project.

Here's is the new term stereotype Textual Activity that controls the toolbars for my activity diagram.

And the aggregates property that I want to update to contain the Transition metaclass.

--------

So, I'm not going to edit it directly. What I found when developing SysML language extensions using new term stereotypes, is that the larger the profile, the harder it is to maintain all the property value settings.

Initially I moved using Excel but then it got even harder, so I moved to using a metamodel created in Rhapsody, and I wrote a Java helper that reads the UML metamodel and updates all the property values for the associated stereotypes.

Composition is used to model ownership in the browser, and Add New menus, and aggregation is to uses to model the =drawing toolbar lists. I also use dependencies with stereotypes to set other properties, such as the target and source lists for new term relation types.

--------

Currently, as I don't customize any drawing toolbars with Transitions on them, they're not in the metamodel. 

Default Transitions are, however, so what I'll do is clone this to create a Transition metaclass.

If I then drag it on to the diagram and establish a directed composition to it, then this will cause it to be added to the Aggregates list of the owner.

I'll do a similar thing for the Call Operation Activity new term diagram type.

--------

The metamodeling profile and its associated Java plugin for updating the properties are included in the SysML Helper bundle we downloaded from GitHub.

Rather than run the property renderer from a right-click menu, I chose to do it from a table renderer.

So, when I double-click this table, the Java runs to query the profile metamodel and update all the properties in the stereotypes that are pointed to from the metamodel.

--------

If I inspect the property setting then I can see that the comma separated list now includes Transition. I'll have a look in Notepad as it's hard to see here.

--------

I usually look at my working tree differences in Git. Although you wouldn't normally edit the xml files directly, it's a good way of understanding the changes.

I could then do some testing. What I'm going to do is to copy the profile into the Profiles folder of my 10.0.3 Rhapsody installation.

I've got Rhapsody 10 closed and hence it won't have a lock on the units, so I'll delete the old folder and paste in the new version

I would need admin rights to do this with version 10, as I'm putting it in Profiles rather than UserProfiles.

--------

I'll then launch Rhapsody and open the project that I used to show the issue, initially.

Here I can test that the issue is fixed.

I'll also do some updates to the version numbering in the helper, so that I can release a new version with new timestamp.

As you can see the source code is present in the SysMLHelper package and I can import a project into an Eclipse workspace.

To get the project to compile I am just going to fix the build properties so they point at a Rhapsody API Jar file.

I'll also fix the native Library Folder Configuration location.

There are some other problems here, however, they are expected.

I have some CSV example import code that uses the Apache POI library. It's not used, however.

The Executable MBSE and Metamodeling profile do not use or require any 3rd party jar files, partly for security  and distribution reasons. 

--------

This bit is slightly clunky, I recognise there may be better ways of doing it, but I'll show what I do anyway.

I am going to create a 4.3.i.Release.

I use a correspondling named Text file in the profile, as both a versionmarker file and change log, hence I've changed its name.

As you can see the SysMLHelper profile is now over 10 years old, hence there's a lot of development here, but also a lot of iterative changes.

This change is going to be change 0874, hence I'll add it to the log here and give it a short description.

I'll then copy the description and add use it in the commit to Git.

There's also a few configuration files to update.

--------

In the profile itself, I also use tags on this Profile Info stereotype to record both the version and timestamp information.

This is used by the Java code to compare with tag information stored in models that use the profile, so that users who open up a project created with a newer version of the profile, are warned to upgrade.

Ok, so, I've now updated the profile.

I'll just do a final test to make sure the version info is appearing correctly when I open up a project that was created with an earlier version version of the profile.

--------

Here we can see that the plugin has given some information in the output window to tell me that I might want to run the set-up project properties command to apply some updates to the project.

This command is in the MBSE Method: Others submenu.

When you run it, you can see that the tags on the project are updated to align with the tag values in the profile. 

If users open this project and have an earlier version of the profile, then they would get a warning in the output window telling them to also upgrade the profile.

I'll just do a final sanity check that the fix I applied is still working.

I'll then commit and push the change to GitHub. I'll use the change line number and comment in the commit.

If I go back to GitHub, we can see the change comments have come through. Periodically, I'd then create a new release.

This may not be the most professional use of all the GitHub features, but it does the job for me as a single developer. 

Periodically, I'd then create a new release, and post the info also to my www.executablembse.com blog site.

My latest Rhapsody MBSE training feedback summary

I have owned and developed my own Mastering MBSE with SysML and Rhapsody training over the last 10 years with international delivery via a variety of business partners. I moved to capturing feedback via google forms which gives me ability to create summary. Past performance is a good indication of future performance. This is the latest feedback summary. 

What did you like most about the training?

• The labs really helped enforce the theory and brought the material full circle.
• It's a new tool for me that can capture big picture ideas and decompose to manageable chunks.
• Labs are great. Good examples.
• Instructor & the labs
• Flexibility to demonstrate tasks on demand, make it easy in this environment.
• lots of tips and short cuts for action users 
• I had no prior knowledge regarding Rhapsody however leaving the training I feel like I'm able to perform task via Rhapsody. The trainer was also very knowledgeable and kept the participants engaged. 
• Practical Lab
• The trainer was very cool!
• Learned a new piece of software that could be quite useful as my team embarks on new R&D Designs.
• Constant examples - learn by doing a lot more efficiently
• I really enjoyed the fact that it was a small class and there was a lot of interaction between class attendees and the instructor
• Hands-on lab activities
• Drilling the concepts through "labs"
• Technically involving course. Fraser is very knowledgeable on the topics and is happy/ready to answer and help with any questions.
• Really good & detailed resources, instructor very knowledgeable, easy to follow exercises
• Practical labs and engagement were good.
• Lab work
• Hands on experimenting on Skytap virtual machine very useful. Having a cleanly setup environment with all the notes and lessons ready is great.
• Doing the labs
• Loved the labs, it was fun going through and manipulating the system and learning how it all works. I am a hands on learner so this was great for me. 
• The material provided was very informative. It answered most questions I had, and I didn't need to ask the instructor for much of anything. 
• Fraser was very knowledgeable; online collaboration tools
• As someone who has never used this software (or similar) before, just the introduction and basic principals were extremely helpful.
• I enjoyed that this course was hands on training. The instructor was helpful and knowledgeable on the topics.
• The labs were fun and Fraser made this course something to look forward to.
• The instructor
• Building models as a team and seeing how they are built into the tool.
• Labs, Kahoot
• The exercises.
• The Instructor was very knowledgeable and also did a great job of keeping everyone's attention and keeping everyone actively engaged.  He often tailored his training and responses to the feedback he received from the group.  Great Instructor!
• The slides were very informational. 
• The games and doing the exercises together
• I liked the sequence of the lab training. I think it helped build our skills to become more independent when creating our own systems. 
• The fact that the instructor walked us through the material, showed how the tool was used, and then we had the chance to do it on our end. This helps confirm if we understood or not as well as improve our familiarity with the tool.
• Presenter was very good at communicating and keeping students engaged.
• It was presented in an easy to follow format and the trainer answered any questions I had along the way.
• Interactive training and hands-on labs hands-on activities were helpful in understanding the course
• Practicals organising the material
• Labs
• Labs with support if needed
• Relating what we learned to current projects we are working on
• I liked working through subjects in the tools.  I also liked the kahoot tests.
• well organized with live explanation and time to play in Labs
• The interaction and presentation.
• Hands on the VM.
• VM setup for the lab practices
• Lots of different training activities (theory, labs, quizzes, workshop)
• Open dialog helped to drive understanding and application of training to current work.
• Completing the labs because we got to practice what we reviewed
• The labs were very well detailed. 
• Hands -on training
• Detailed steps in pdf
• Well detailed slides, easy to understand
• The hands on labs
• Systematic way of doing a model by understanding what should be the System
• Interactive exercises
• Enough structure but not too rigid for taking questions or related topics
• The flow of topics was organized and clear. Fraser is very knowledgeable and welling to answer/discuss all the questions. 
• I really enjoyed the labs - I thought that they were really helpful in applying what we have learned. 
• The remote desktop environment, where we can practice actually using Rhapsody
• "- Allowed me to really think about the systems that I work on and how they break down into individual elements.
• - Gave me a strong beginner foundation of MBSE and is encouraging me to learn more and gain more experience in and outside of my current role.
• - Labs and lesson plans were easy to follow along.
• - Training was interactive and fun but still challenging. I liked the Kahoot quizzes :)" 
• Kahoot game.
• The trainer was very proficient and lab exercises were useful
• The labs are outstanding
• I really enjoyed the pace, detailed descriptions, attention to detail, and patience with working through all of our various issues and understanding hurdles to make sure we all were moving through the course and not falling behind.
• The applicability of content and case study topics.
• Range of Topics
• getting to know Rhapsody, I've used other tools but I'm new to Rhapsody and will be using it for work so it was great to practice with it
• I liked most the fact that this training requires so much interaction... really forces the attendees to practice what they learn, not just absorb it
• The labs were really easy to follow and helped with my understanding of the elements of Rhapsody that I will use most often.
• Liked the hands-on learning experience of using the tool and working on the labs.
• The labs, the practical exercises
• good opportunity to learn about very powerful tool for MBSE process.
• Interaction of the instructor 
• Engagement, Kahoot
• Labs
• There was a lot of time to follow along and ask questions as needed. Room for flexibility.
• Lots of labs and participation to try out the software functionality.
• The interactive labs
• The multiple ways that the instructor explained the same topic. The material was provided in a concise, assertive, and practicable.
• Clear, Concise and effective presentation. Training material was hands-on and in-depth. Instructor (Fraser) is very knowledgeable and patient with answering questions and simplifying the concepts so that even novice trainees could understand. 
• How clear all the material was; it make it very easy to follow. 
• Trainers willingness to provide guidance on topics not directly in the training materials.
• The examples were relevant
• The instructor's knowledge and expertise
• Provided documentation is awesome. Searches can be performed within the documents to find topics of interest. Pace was good in that there was time to work in the tools and time to learn theory. 
• I love the presentations and videos before practicing on our own
• Understanding the power of the Rhapsody tool and the lab practices.
• Building own practical examples (vs following lab)
• Real time training 
• The labs
• I liked getting to work through the examples and use a case study to reference throughout the day.
• The training showed additional features for testing within a model that I had not used before.
• knowledgable responsive instructor
• The VM used to be able to do the Labs
• I always enjoy the hands-on feel of Fraser's trainings.  The format of theory and then a "go do" really makes sense to me.
• The hands-on labs
• THE INSTRUCTOR INPUT AND GUIDANCE
• The instructor knows the software capabilities very well, and he relayed those capabilities to the group.
• Practical Labs
• Clear training material with clear delivery. I understood everything delivered. Good entry level training.
• Good format of explanations followed by labs.
• Plenty of hands on on relevant subjects
• In-depth discussion on UML and SysML background and diagrams
• The instructor answer questions related to the product but not necessarily to the training
• It was pretty thorough.
• Comfortable and friendly
• I love that it was flexible and trainer shifter for our specific requirements in many instances.  That's why the lower score on training objectives, we really didn't know what we were getting.
• the hands on labs
• I did not know much about MBSE or its role in the context of an engineering project. I didn't just learn the tools, but also why they are being used. That was very helpful.
• test format (game)
• The knowledge and expertise of the trainer. Very helpful and learned a lot about Rhapsody and integration with DOORs NG
• New experience
• The interaction with creating Systems Engineering Diagrams
• Tool agnostic
• Tests and exercises were quite entertaining 
• The relaxed, informal and collaborative style.
• Instructor seemed experienced and was personable.
• Hands-on workshops
• Practicals and Kahoot challenges - really tested our knowledge
• Broad focus on Rhapsody 
• The combination of theory, labs and quizzes was well suited to remember and understand the content.
• The practical labs
• Good balance between slides, labs and quizzes to break up the course.
• Kahoot quizes were a good way the break up the course in a fun and relevant way

v4.3.f.Release of the Executable MBSE Profile (8-OCT-2024)

 Added some further updates to open source Executable MBSE Profile:

Making MBSE quicker with profile support for IBM Rational Rhapsody: v4.3.f.Release (08-OCT-2024) (executablembse.com) 

IBM Engineering Rhapsody Tip #110 - The Function Block Method

This video shows how it's possible to build a very powerful description of a systems structure and behavior using only two SysML diagram types, if you embrace the notation of function blocks and using BDDs and IBDs to do both. To get this to really work, I've had to extend Rhapsody with my open-source profile called ExecutableMBSEProfile. 

The video creates a project from scratch including bdd/ibds for both behaviour and structure and then shows some of the notation that's possible dove-tailing them together. The ability to show functions inside structural elements together with signals is something similar to Capella/Arcadia. Personally I find it interesting that you don't need something complex to describe something complex. Somehow by limiting the notation you can achieve more, especially as it means that you only really need to understand two SysML diagram types to read the diagrams.

This is the transcript in case that helps:

00:00:00

In this video I'm going to show you the executable MBSE profile again, and then I'm going to do something a bit different with this, which is to explain one of the workflows you can do with this profile without using activity diagram, sequence diagrams or state charts and instead doing an entire project with just two diagrams.

The intent of that methodology is to simplify SysML so, if you understand how to do block definition diagrams and internal block diagrams for structure, then you would understand how to do it for behavior and then you can take those two compositional trees and dovetail them together. This is an approach around function block modeling. I'll do the insulin pump system again.

00:00:48

And I'm going to use the executable MBSE profile. This is the four three E version. If you look on my executable mbse website here (www.executablembse.com), then you can see that there is a link to be able to get this profile from GitHub.

00:01:13

Now, conventionally you might start a project with use cases and use cases you might decompose with, say, an activity model. An alternative to that is to start with blocks and do a decomposition using a block model, so the first thing I'm going to say is let's define a system architecture structure.

00:01:32

Using a block definition diagram and this is for an insulin pump system.

00:01:45

And the insulin pump system has an insulin pump, a continuous glucose sensor, and a blood glucose meter.

00:02:09

This is something called a block definition diagram in SysML, and it's derived from the class diagram in UML and allows me to do directed decomposition to be able to create part property relationships between elements.

00:02:31

The insulin pump system now has three part properties typed by these subsystems.

00:02:40

Well, if I did the same within the behaviour domain then I could do it with something very similar and this profile adds the concept of a feature which might be to deliver basal insulin.

00:03:02

This, rather than being a structural block, is a functional block. I'm able to say well to deliver basal insulin, I need to measure glucose level, calculate basal adjustment and deliver insulin.

00:03:29

Obviously, there might be more detail than the real world, but this is just an example.

00:03:40

I use decomposition to show that there's a functional decomposition and the only real difference here between the feature block and function block is I'm saying the feature block is at system boundary level and I do have some relationships that I can do between the system block and the feature block to say that a feature is a system, for example, using generalization, that I don't allow with these function blocks.

00:04:06

But I do allow function blocks to be decomposed to any arbitrary level as do I allow within the structural model subsystems to be decomposed into any any level but not systems. So we're making a language choice within the profile to put meaning around these different types of block, but fundamentally it's a block definition diagram and the notation is the same across both.

00:04:30

So you would say conventional systems projects such as Magic Grid with Cameo or Harmony/SE with Rhapsody would start with use cases and I could could do that but I'll show you an alternative which is that I've added the idea of a context diagram.

00:04:51

Where the context diagram is going to show me the relationships that the system has with external actors.

00:04:59

So it's very similar to a use case diagram. This is an internal block diagram. It's got parts which are typed by actors.

00:05:07

Obviously I haven't really got drivers using an insulin pump system, I've probably got a patient so if I rename that actor as a patient, I could say that there's an interaction between the patient and the system. The patient might request a bonus correction and the system delivers insulin.

00:05:44

This simplified internal block diagram does have very simplified palette and we're using flows between part properties, and the flow is carrying signals or what Rhapsody calls events, because that's one of one of the easiest things to hook other things into. Lots of different diagrams within SysML are able to capture exchange items using Events/Signals. I could show within this insulin pump system using

00:06:16

A feature usage which is typed by that (Feature).

00:06:22

And establish the flows to those features. If you think of this as similar to what a use case would do, the difference is instead of having an ellipse here and having a use case, I've got a block.

00:06:36

To do this (project), I've only actually used two different types of SysML diagram so far. I've used block definition diagrams to do decomposition. I've used a high level internal block diagram. When I say high level, I mean an internal block diagram where the part properties are global. I've got the concept of a block called a feature which decomposable into functions.

00:06:57

And I can then establish relationships between these blocks, and although I could do it with allocation dependencies, what this opens up quite easily is the ability to do allocation through composition. I could say, that my.

00:07:16

Calculation of basal adjustment is done by the insulin pump.

00:07:25

My deliver of insulin is actually also done by the insulin pump.

00:07:34

My measuring glucose levels is done by the continuous glucose sensor.

00:07:42

If I wanted to, I could go into using internal block diagrams.

00:07:48

I've got an internal block diagram here. I can populate the parts.

00:07:53

And I've got a helper here to to be able to do that. Some of these are function usages. Some of them are subsystem usages. If I just say, populate them all.

00:08:05

You'll see how it it dovetails the two together.

00:08:10

Just can pack this a bit than because my screen size is not so good.

00:08:14

The insulin pump then might might have connections with the continuous glucose sensor.

00:08:26

The helper is going to automatically create some interface blocks and conjugate one of the ports. If I do that, I could say that the measurement of the glucose level.

00:08:37

So might might bits or less.

00:08:41

This way, that's the way of doing it.

00:08:45

I could say measuring glucose level produces flows on this connector into these parts, so you see how I'm using part properties with a structured compartment here to be able to see both entities.

00:09:11

So that will be our flow input into that function you can see it's part of the insulin pump.

00:09:22

This gives me some sort of unique but recognizable views, which I can't quite do as clearly/closely using activities as I can with parts and blocks.

00:09:38

And this might be a pre step. I could take that feature.

00:09:44

And then take the part properties and chain them purely in a functional model.

00:09:54

So I measure glucose level.

00:09:58

And that flows.

00:10:02

I haven't typed these by events, but I could that flows to calculating the basal adjustment and then calculating the basal adjustment flows into the delivery of insulin.

00:10:14

And the helper here is creating some flow ports there, and if I wanted to I could put some conditional logic or parallel logic and I'm using business process (BPMN-inspired) notation here because that works quite well in nodes, but this is actually an internal block diagram being used to perform the function that an activity diagram would have.

00:10:39

So it's relatively powerful notation but I've got the whole port/part capability in that this measure glucose level function block here, assuming that essentially the capability and it owns things like a requirement diagram.

00:10:57

And show requirements that the function block owns. Then if I allocate this function block to a subsystem, then I'm essentially allocating the requirements.

00:11:08

And these function blocks then become these reusable elements. So I could create a completely different architecture with different subsystems and allocate the same functions if I wanted to. Or I could start to use some of the things of object orientation such as generalization and composition to assemble reusable functionality as a block, and then use that functionality in another system. It's SysML but all these diagrams are done entirely with the notation of block definition diagrams and internal block diagrams. I haven't used any use cases. I haven't used any activity diagrams, haven't used any sequence diagrams.

00:11:49

But I can achieve quite a lot with a very small syntax.

00:11:53

And once you understand that small syntax, you can express quite interesting relationships and start to assemble systems from reusable components. So it's a more fluid, dynamic way of modeling a system.

00:12:08

Which does rely on some extensions here to be able to specialize the types of blocks, but is something that may be interesting if you're into this idea of functionally decomposing system capabilities rather than trying to say, that we need to express our system in terms of a SysML sequence diagram or state chart.

00:12:26

So I thought I'd show you that it's a slightly different approach to SysML. There's lots of different ways you can use SysML, but I think the idea of only using two diagrams is actually quite clever (i.e. powerful) if you need any more information then let me know.

IBM Engineering Rhapsody Tip #109 - Activity diagram swimlanes and allocation

Gosh, almost on a roll. This Rhapsody Tips and Tricks video which came from some new lab work I've done for my Rhapsody training labs. 

It covers both basic principles of swimlane allocation in IBM Engineering Rhapsody using SysML but it also has a fair share of advanced aspects. For example, I show how to create a context pattern table to show allocation and how Rhapsody creates inferred allocation relations. I then illustrate how it's possible to see allocation in compartments on a block definition diagram, and how Rhapsody also has a slightly hidden capability to show allocation using SysML Callouts, a type of new term comment added by the SysML profile.

Here's the transcript:

00:00:03

OK, my name is Fraser Chadburn. In this demo, I'm going to show you some things about swim lanes in activity diagrams. I'll just navigate to this activity diagram and show you what I mean. I've got double click here working with a Java helper.

00:00:22

This is an activity diagram that just shows control flow with Rhapsody and you can see how this activity diagram is quite useful for capturing the operational scenario perhaps of the system and also how we can link these actions to requirements. 

00:00:41

I'm just going to remove a customization as at the moment the drawing toolbar here has got some additional things like a derivation and that's been done through an applied profile which is a profile that which isn't globally applied but is applied if there's a dependency with applied profile on it.

00:00:59

I'm just going to delete that and then I'll reopen the activity diagram.

00:01:11

And here I've got the default drawing toolbar for an activity diagram. Let me just expand this a bit so we can see it. I've also got action pins and activity parameters.

00:01:22

I've got these swim lanes (in the toolbar). The concept of swim lanes is the ability to associate structure to those swim lanes and then, if I put the action inside of a swim lane, then there's an implicit thing in SysML that this behavioral element is allocated to this structural element. Let me just zoom out and.

00:01:42

I'll draw a swim lane frame of roughly the same size as these actions.

00:01:47

And I'll subdivide it into three different swimlanes (or partitions).

00:01:51

This is what we'd call a black box sequence; we're looking at the operational scenarios from the perspective of the user and we're treating the system as a black box.

00:02:06

Let me just resize these to be able to resize the frame. Here I need to hold down the alt key and that allows me to have some modification of the behavior of the resize.

00:02:22

I'll make them slightly bigger. The first thing with these swim lanes is that we could associate or get a swim lane to represent a structural element. Here's my first action. The operator logs in at the control panel and activates the teleportation system because this is a teleportation system.

00:02:44

I'll turn off the hovering toolbar. I'm going to say well that that's an action performed by the operator.

00:02:53

Within my use case package here I've got an operator actor so to represent that actor I could look at the features and then pick the element.

00:03:05

Or I can drag the element onto the name of the swim lane. If I drag it here I just get an object node. If I drag it directly onto the text, it will do that represents for me. This is the swim lane that represents the operator so I move this action into that swim lane.

00:03:24

I can use the arrow keys here to just shift it across.

00:03:30

What I'm saying is that this action is performed by that actor. Let me delete and redraw the initial flow. I could move it, but generally it's just easier to redraw.

00:03:43

So that's the first step. The operator has logged in at the control panel, so the second step here the Teleportee (actor) tells the Operator where they want to transport to. I'll shift that over with my arrow key on my keyboard andmove that into the second swim lane.

00:04:02

And that is an action performed by the Teleportee. Something that Rhapsody does automatically here, if I have a swimlane, if I look in here, is it it will create an inferred relationship. You can see here that an allocation relationship has been created in the model because of the presence of that action within that swimlane.

00:04:30

What I'll also show you then, is the ability to see this allocation of behavior to structure within a table. I'm going to create something powerful concept here called a context pattern table.

00:04:46

So I create a table layout of my swim lane allocations.

00:04:59

And I'll go to the features for that.

00:05:03

Go to the columns, and go to the advanced options. Not everybody needs to know how to create a context pattern, but they're useful to know what they do and how powerful they can be so that if you think well, actually it would be really useful to see this stuff in a table. You know that it's possible, perhaps as someone in your organization who's able to to understand the series of tokens you need to write to create a contacts pattern. So here's an example I'm going to say go to all the packages and any nested packages. Then if you find a use case.

00:05:34

Then list that, but underneath the use case is an activity diagram.

00:05:39

And I'll give that a token name of act, which is the system mail abbreviation. Effectively, I actually then want to have the actions.

00:05:52

These are states in Rhapsody.

00:05:55

And then I want to see the allocated to elements, so that's go to the allocation relationship and find the end element.

00:06:06

So this is a context pattern. If I collapse the first column I can use the fill defaults to populate columns from that context pattern. The table layout is like a template, so I'll create a view so this is a table view.

00:06:23

Of my swim lane allocations.

00:06:30

If I don't click Refresh, we can see that this action is performed by this actor.

00:06:40

OK, let's look at the next things. Operator sets the destination point, the Teleportee stands on it. I'll just get rid of the Interruptible Region here and what I'll do is move across these actions into the swim lanes.

00:07:00

Once they've moved across, if I go to table view and do a refresh.

00:07:04

Here you can see it's representing that (allocation).

00:07:07

So let's look at the next thing. Actually, this is something done by the system. I've got a third swim lane but I haven't actually allocated any structural element to it, and often when we use swim lanes, we actually have blocks or parts of the system that we're allocated behaviours to. If we go into the white box model. So I'll just create a package.

00:07:34

With a block in it. So I'll create a design synthesis package.

00:07:42

In that I'll create a block definition diagram. This is a BDD of the teleportation system.

00:07:56

And there's a block on it called Teleportation System.

00:08:04

And what I want to show with this is also compartment. So firstly let me take that block and I'll allocate it, or get the swim lane here, to represent it.

00:08:22

And then I'll move this action into that swim lane.

00:08:36s

And I'll check that it then appears OK (in the table). So here we go, we've got an allocation of the system analyzes target location to the teleportation system.

00:08:47

If I go to the display options of this block then what I could do is show that allocation in a compartment.

00:08:57

And an allocated from compartment is available in the pull down list here.

00:09:02

And now I can see the allocation of that behaviour to that structural element on my block definition diagram in a compartment using the specification view.

00:09:15

In terms of the activity if I go to the display options of this action, then there isn't the ability to do compartments, but there is this option to use the SysML callout tool. It's a type of stereotype comment and if I set the display options to the anchored info on here and I make sure that box style isn't shown.

00:09:38

And I anchor it.

00:09:41

Comment to that action.

00:09:44

It's going to pick up the allocated to relationship and show that in system. SysML call out notation.

00:09:52

I'll just show you this final thing here. If I had a a core behaviour here which is dematerialise and rematerialise and I'll just move that in to a swimlane.

00:10:13

Then the question is, is it the call behaviour, or the referenced activity, that I want to allocate to the teleportation system?

00:10:26

Now. If I look at the activity model that's underneath the activity diagram here.

00:10:35

You'll see that there are two different things I've got.

00:10:39

An activity which is dematerialized and rematerialized and then I've got the action that then invokes that activity.

00:10:48

So if I want this activity to be allocated soon, then rather than using inferred, I actually have to use an explicit relationship to allocate. The right click (menu) here would require me to create a dependency and then select that this activity is performed by the teleportation System block.

00:11:11

I'm explicitly creating a dependency here and making that an allocation new term.

00:11:20

And that means that it will then also appear in the allocated from compartment.

00:11:30

If I had the activity on here, we can see that relationship. The display options of the activity on a block definition diagram do allow me to put compartments.

00:11:50

So that’s it. A quick introduction to the idea of using swim lanes to do allocation of behaviors to structures from activity diagrams.

00:12:00

And also some of the support within Rhapsody for inferred allocation that comes from the presence of an action within and from lane.

00:12:10

Or explicit allocation which comes from creating allocation dependencies from the behavioral element to the structural element, in this case, and how we can see these in either compartments on a block definition diagram, or using call out notation on an activity diagram.

00:12:28

Hope that helps. My name is Fraser Chadburn and I do a lot of work with customization, specialization of Rhapsody. If you have any questions then give us a call. Thank you.

IBM Engineering Rhapsody Tip #108 - Creating models quickly, incl. package diagrams automatically

In some ways this is more of the same. However, this video has some of my very latest work for auto-creating package diagrams for model navigation which has gone through a few iterations but is getting quite promising, considering that I used to think that package diagrams weren't that useful in SysML.

The video shows how I create models quickly using a mosaic SysML package approach with an open-source profile I've created called the Executable MBSE Profile. The beginning point for a lot of projects is often a use case and requirements-driven approach but this 11 min video does show that the profile goes beyond that with functional and system architecture packages. This video ends with the auto-creation of package diagram - index for model navigation of the project that was created.

New release of SysMLHelper

The latest SysMLHelper package (4.3.b.Release) is now available on Github. This is an open-source profile and helper collection. The ExecutableMBSE profile part of this as well as providing a Harmony/SE like approach includes function block and function chain modeling enhancements using advanced profile features of Rhapsody. It works with 8.3.1 upwards. 

See my other website which is: http://www.executablembse.com

IBM Engineering Rhapsody Tip #107 - Create a use case package structure

This video represents training Module A on creating use case package structures using the Executable MBSE Profile, a GPL-licensed extension to Rhapsody development by MBSE Training and Consulting Ltd to enhance SysML with method-aware helpers. 

The Executable MBSE Profile takes a mosaic approach by adding new term packages which have specific purposes.. The methodology is designed to support team-based development in Rhapsody with an awareness of both DOORS Next external requirements and configuration of Rhapsody projects using Rhapsody Model Manager and the IBM Jazz platform.

Interesting paper comparing BPMN with Activity Diagrams

I've done a lot of work on a new New Term IBD-like diagram in Rhapsody for modeling Function Blocks as parts in a process flow. I've increasingly had to look to BPMN notation to provide a paradigm for how to manage aspects such as decision nodes, forks and joins. 

The result is very intelligible, similar to Activity Diagrams but with a slant of BPMN and a unique ability to blend structural and functional modeling.  

Interestingly I've just found this paper that compares BPMN notation with UML/SysML Activity Diagrams:

http://www.workflowpatterns.com/vendors/documentation/BPMN_wfh.pdf

 

Continued development of executablembse profile

I've been continuing development of executable mbse profile (part of the SysML Helper collection), an open-source project I started in 2016 to automate some Harmony-like methods steps because I needed the HarmonySE toolkit to do some additional things / cope with a new workflow.

I don't post about this here though as it would've overwhelmed my video posting. Instead, the profile changes are posted here: http://www.executablembse.com/ 

Things to note:

1. The SysMLHelper bundle has more than one profile. It has the original SysMLHelper profile but I moved my development to the ExecutableMBSE profile in 30 May 2019. I also did a Tau G2 migration profile, for example, and a Metamodeling profile. 

2. All the profiles including the Metamodeling Profile are in the same bundle because they share the Java code. I found that whenever I was creating a profile for a new task or a new problem that needed a GUI, I needed to repeat a lot of code. The bundling like gives a better foundation for creating and updating profiles quickly without re-inventing the wheel. 

3. Profile will pretty much work with any Rhapsody version 8.3.1 onwards as the API hasn't changed that much. The unit files for the profile are developed in 8.3.1.  

2. The Executable MBSE profile (main active profile under dev) has two different workflows for modeling functions; either using operations or using function blocks (new term metatype based on class). Latest stuff is all coming from customers who've found ways of working with DOORS NG and OSLC (things that come from real workflows).

3. Profile uses a metamodel profile that is part of SysML toolkit to render properties for new terms. I back-fitted this into the SysML Helper profile collection in 2021 and seems to work well. 

Setting up Rhapsody DiffMerge with EWM Eclipse client

I keep losing this link to DiffMerge setup instructions, hence I'm pasting here:

https://www.ibm.com/docs/en/engineering-lifecycle-management-suite/lifecycle-management/7.0.3?topic=SSYMRC_7.0.3/com.ibm.rational.rmm.overview.doc/topics/rhp_c_installing_rmm.html

IBM Engineering Systems Design Rhapsody 9.0.2 was released on 23 Mar 2023

Just a heads up that there was a new Rhapsody release on 23 March 2023: 
IBM Engineering Systems Design Rhapsody 9.0.2

This supersedes the latest iFix for 9.0.1 which was iFix 004 which fixes some issues introduced in iFix 003: IBM Support: Fix Central - Select fixes

Reflections on tool-neutral training

So, last couple of weeks I did some 2 day tool-neutral face-to-face training. It was fun actually. Like my tool-specific training, it is very interactive except that I use white boards and group work, and miss out the tool-based labs. In the group work, we develop a novel system from scratch using whiteboards. The fun bit is the interaction between people sharing ideas. You never know quite how it will turn out. Both courses had similar participants (a mixture of functional safety consultants, software, and systems engineers) but went in different directions with their solutions as I played around a bit with project constraints (budget, time etc). As we explored the different diagrams, I took their ideas and put them into a model to show them out it would look and some of the different views, particularly around traceability tables and using simulation to explore emergent behavior.

v4.2.g.PreRelease of Executable MBSE Profile

Over last 6 months with more late adopters moving to try and pick-up MBSE and run with it, I've found myself moving more towards suggesting people exploit tool automation such as my SysMLHelper. The amount of code and ideas now accumulated in this open-source project is substantial and it fits almost all needs now (executable or function-block based).

If I've come up with ideas I've incorporated them into it. The latest SysMLHelper is 4.2.g.PreRelease and is available on Github. I also post info to my http://www.executablembse.com/ website, although I've found with all; my websites that I've not had time to add much beyond essentials as I've got hungry customers I've committed hours to.

Regarding my helpers, all I ask is that you comply and respect the license as it protects me against commercialisation of my ideas. I've avoided 3rd party libraries in all my Java. Also, there's a limit to my time, hence if you really want proper help then get me to consult for a bit and I can put my experience to use for you, either to recover projects that need help or to make sure you start off with some quick wins. Doing MBSE with Rhapsody isn't effortless, but it can be fun if you learn how to speed up the tool mechanics and get drawing diagrams quickly based on well proven paths.

Reflection on recent trainings

Done 3 hands-on Rhapsody tool trainings in the 1-3 months, all Rhapsody 4-days but some spread over non-consecutive days (which is one of the benefits of remote/virtual-image-based deliveries). One of the 4 days was C++ based including deep-dive into statecharts and configuration management topics (dates over 2 weeks). The other was mostly Systems/SysML-based (automotive), also dates over 2 weeks. They seemed to go well. More recently I've found myself doing more consulting and recovery jobs, e.g. people getting into trouble with Rhapsody Model Manager and understanding its true potential but also coaching people on advanced topics like making context patterns work with their models. 

IBM Engineering Rhapsody Tip #106 - Power features for filtering diagrams using views/viewpoints

This is my first video for a while and comes from some recent work trying to make it easier for users to exploit the power features of IBM Engineering Rhapsody for filtering diagrams to show elements within a view. Rhapsody includes lots of features to do this such as Queries and CustomViews but it's not always easy to set them up, hence I added some support to Rhapsody to make both the setting up of the necessary elements and then the usability of those elements much easier. After showing the resulting example, the video steps through the steps of creating it using my helper.

First delivery of my new Model-based Testing with Test Conductor training course

Last week I did my first delivery of a new Model-based Testing with IBM Rhapsody Test Conductor (1 day) course I developed to a group of 15 participants, my first new material for a while. Training was based on Rhapsody 9.0.1 iFix 003.

This was the feedback:

Final Class Summary

General: 4.6 out of 5
Material: 4.8 out of 5
Instructor: 4.9 out of 5

Overall Satisfaction: 9.3 out of 10 

The material is all based on hands-on labs and does assume some knowledge of Rhapsody. It can be considered as a 1-day add-on to existing 3-day Mastering Rhapsody trainings. Either done in the same training cycle or as a top-up that gives more exposure to executable modeling later on. 

Rhapsody 9.0.1 iFix 003 SR1 was released 29-Sep-2022

For those that don't know, the latest Interim Fix (iFix) 003 for Rhapsody 9.0.1 is actually a Service Release (SR). This means that it's a complete installer that you can install like a release and don't need to install anything afterwards to get additional fixes (at least at the moment). This makes it a good candidate for performing new installs with as there is just one installer to deal with.

To obtain iFixes for IBM products, you do not need to be a customer but may need to register for IBM id. They are available on IBM's Fix Central website: https://www.ibm.com/support/fixcentral/

Search for: IBM Engineering Systems Design Rhapsody

If you have a previous 9.0.1 installing you need to uninstall and then re-install. Obviously, this needs to be done with an understanding of what customization's you've done to the rhapsody.ini, Share folder such as profiles and properties.

Really iFix 003 is a roll up of all the fixes done since 9.0.1 was originally released into a single installation package. It makes it a good candidate for new installs where you're rolling out Jazz 7.0.2.

Java Versions and Features link

Often, a Rhapsody team may choose to get a toolsmith on board to extract the best power with the least effort from what is probably the most configurable UML tool of them all. Although Rhapsody is natively and C++ application, plug-ins for Rhapsody make use a Java API. It's not always the case, however, that the toolsmith is a software engineer by trade and hence just a little foundation knowledge can go a long way. I found this article that helps explain a bit of foundation knolwedge wrt Java and JDKs. It's quite well written I thought and hence thought I'd share the link: Java Versions and Features (marcobehler.com)

v4.1.a.PreRelease version of SysMLHelper toolkit on Github

I published first version with business value profile (target for visio import) plus some important tables views for showing traceability in the requirements, use case and feature function packages in the Executable MBSE profile. 

See my Making Executable MBSE fun with IBM Rational Rhapsody website if you want to know what the latest enhancements were and where to download this set of open source profiles and process automation helper toolkit.