Friday 21 December 2018

Rational Rhapsody Tip #49 - 3 ways to open an animated state machine (Simple)

This super quick "tips and tricks" video for IBM Rational Rhapsody shows the 3 classic ways to open an animated statechart in Rhapsody. The main thing to remember is that you need running instances in order to do this. Simulations start in the un-initialized state in order to enable you to debug the initialization sequences so you usually click Go Idle or Go to initialize the instances. You then have 3 options: Either the Tools menu, via right-click on an animated sequence diagram lifeline or by finding the instance in the browser. The latter is made easier if you first filter the browser to animation view. Finding the instance when using the Tools menu can be labor some when you have a lot, hence I normally go for the animated sequence diagram approach. Viola, you can then fire events into the system and view its emergent behavior.

Friday 7 December 2018

Rational Rhapsody Tip #48 - Pessimistic Locking and Rhapsody Model Manager 6.0.6 (Advanced)

I've been really busy recently with customer-work. However, I have put together an 11 minute video on something that seems to come up a lot in initial conversations about the great new model-management capability provided in IBM Rational Rhapsody 8.3.1 with Rhapsody Model Manager 6.0.6 (the IBM Jazz/architecture management application). One of the first questions a lot of people have when it comes to file-based model management is whether it is possible to lock files so that other users cannot edit them at the same time? The goal being to remove the need to merge changes with Rhapsody's DiffMerge tool.

By default RTC and RMM both have a very modern optimistic strategy towards changes. That is they won't lock files. In fact, there is no check-out par say, rather RMM/RTC track changes to the files automatically and group them into changesets. Changesets are nifty for a number of reasons. In this video, however, I show that it is possible to change the strategy to pessimistic if you want. To do this you can configure the stream to auto-lock files so they are read-only. This forces the user to have to change the read/write status in order to make changes and this change of status can be used to lock the file so that nobody else can edit them. When a deliver is then made, then the lock can be released. In this way a pessimistic approach can be taken. This video includes demo of this with Rational Rhapsody 8.3.1 (iFix2) and Rhapsody Model Manager 6.0.6. 

File-based model management is extremely powerful for a number of reasons. Firstly, it means that people are able to work effectively on client side in isolation (this is essential when doing work that involves compilation/simulation). It's also an efficient way to transfer information from the client to server when working in parallel as merges can be handled on the client side without needing to add or remove data from large database tables.

Sunday 18 November 2018

Rational Rhapsody Tip #47 - Condition Marks On Sequence Diagrams (Intermediate)

This is really a rounding out video that delves into Condition Marks on sequence diagrams. Interestingly, despite 10 years of working with Rhapsody it was only through recent automation work that I discovered that they could be bound to model elements. I'm not sure why I missed it. Anyway, it was one of those staring you in the face, not seeing it moments, so I thought I'd spin this "eureka" finding into a video (ok, I admit, it's not that exciting, but I need new Rhapsody video topics!).

Basically, Condition Marks in IBM Rational Rhapsody sequence diagrams can be used to annotate information about the state of an object at a time in a sequence. Usually they represent states in the object's state machine, although you can also provide information about the state of attributes (or anything else as it matters). By default, they will be free flowing text. As this video shows, however, you can check a box and choose to select an element (the most obvious being a state in the relevant state chart). Whether this is valuable may depend on what you’re doing, of course. As this video shows, if you’re able to animate your model then you can create sequence on the fly that have the state value’s annotated in the condition marks. Enjoy. I hope it’s useful to someone.

Thursday 25 October 2018

New webinar on Rhapsody Model Manager coming up

In this IBM hostd webinar, Fraser Chadburn, a technical consultant with 11 years of experience in IBM Rational Rhapsody and 20 years of experience in UML and SysML modelling will tackle the newer topic of collaborative development with Rhapsody Model Manager 6.0.6 (Rhapsody 8.3.1) including a live demo of collaborative multi-user workflows. Rhapsody Model Manager is the latest server-side technology for team-based collaboration. RMM is based on the mature SCM functionality provided by Rational Team Concert (RTC). The webinar will touch on some of the options such as Rhapsody units, optional properties and how one might organise Rhapsody's package structure. As well as highlighting some of the enhancements in the 6.0.6 release of Rhapsody Model Manager (and its associated Jazz/am application) he'll touch on optimistic vs pessimistic working strategies and use of the Rhapsody DiffMerge.

Rational Rhapsody Tip #46 - Adding editable units outside the project directory (Advanced)

Normally with an IBM Rational Rhapsody project the writable units are all configured as part of the model under the _rpy folder. As such referenced units would historically always be read-only. In Rhapsody 8.1.5 it became possible to add a referenced unit outside the project directory and have that unit be writable. To do this you need to deselect the Copy into model option when adding the unit. This video demonstrates with Rhapsody 8.3.1. The feature also works when you have separate models as different components in Rational Team Concert or Rhapsody Model Manager (I slipped this into the demo at the end). Hope that helps!

Sunday 21 October 2018

Rational Rhapsody Tip #45 - Making safe use of the ReferenceUnitFile property (Advanced)

This video covers use of the General::Model::ReferenceUnitPath property (using IBM Rational Rhapsody v8.3.1). This property tells Rhapsody to set a relative reference to the unit file whenever you do Add to model. This is particularly useful when you have multiple components in an SCM tool such as Rhapsody Model Manager (Jazz/am 6.0.6 is shown here). This is because different users will have different root folders on their local file system where they will store and access the projects. Not using relative references would result in lots of "cannot find unit" problems when opening projects. By setting the ReferenceUnitPath property you can alleviate these problems (assuming all the components share the same roots).

However, there is one major pitfall, in that the property will also affect Profiles that you add after setting it. Referencing the profiles using relative references is also a bad idea because profiles are not relative to the project, but rather contained in the installation. Rhapsody normally deals with profiles in the installation by pre-fixing the path to the unit using the $OMROOT variable. Fortunately, if you accidentally end up with the paths being wrong then you can use the Edit Unit dialog to manually fix them (as shown here). This video shows Rhapsody 8.3.1 projects with corresponding components being created using Rhapsody Model Manager 6.0.6.

Reflections on a great Agile Engineering Summit Oct 15-17

Last week I was in Washington DC, in the States, privileged to be presenting a paper (and demo) on IBM Rational Rhapsody at IBM's Agile Engineering Summit. What was really nice was meeting up with people I've worked with. There was also the bumping into the odd German-sounding chap and fantastic IBM colleagues ;-). Let me say hi, therefore, to Willert software tools who offer great value for money (and frankly some good direct speaking) for those looking to use Model-Driven Development (MDD) with Rhapsody on tight-embedded targets and micro-controllers (for a good price). They've been doing this for automotive customers for a long time. Other than that it was fantastic to meet some of my USA Rhapsody customers and listen to their presentations. Great week.

Friday 12 October 2018

Rational Rhapsody Tip #44 - RMM 6.0.6 accept/deliver workflow and icons (Intermediate)

I've had quite a few people asking about collaborative working in IBM Rational Rhapsody so I quickly knocked up this video that shows IBM Rhapsody Model Manager (Jazz/am). One of the nice things about the solution is seeing the visibility of the SCM status in the Rhapsody browser. The icons essentially mirror those of Rational Team Concert (on which RMM is built). This means that developers can see what's moving in the stream as soon as it occurs, and make an integration decision. The re-activeness of the Rhapsody client is also pretty good. Obviously the longer you wait before integrating other developers changes is a key question (the isolation vs integration conundrum). However, this enables users to react quickly to changes that affect them. Rhapsody Model Manager is a version of RTC designed for models, hence the integration is similar but improved to the RTC integration (i.e. better in 6.0.6). Included are also more commands in the right-click menu in Rhapsody, that makes it's easy to navigate to the RTC Client. RMM is licensed as per Design Manager hence potentially already bundled in your licensing (something to check).

If you want any tips on configuring RMM then let me know.

Sunday 30 September 2018

Presenting at the IBM Agile Engineering Conference

I am presenting at IBM's Agile Engineering Conference if anybody wants to meet up:

Rational Rhapsody Tip #43 - Toggling between specification vs structured views (Basic and Advanced)

I've just finished my latest spot of consulting. This tip came from a recent email exchange I had where I was explaining how to add and remove compartments on classes/blocks in IBM Rational Rhapsody. The first basic bit of knowledge is to understand that when you look at the Block or Class on a diagram it can be shown in either structured or specification view mode. The specification view is also known as a compartment view and allows the user to show any number of compartments with selected data shown. It contrasts with the structured view which essentially shows an internal block diagram (or composite structure diagram). You can toggle between the views using an icon in the zoom toolbar. At the end of the short video I also show a more advanced tip by customizing the list of available compartments using the AdditionalCompartments property. The video also serves to highlight the new combined Display Options dialog in the latest version of Rhapsody. This brings together several previously separate elements (properties, format, port options and display options) under one roof to make them easier to find and use (certainly adding and removing compartments is a lot easier). Enjoy!

Sunday 23 September 2018

Driving Quality from Simulating System Tests webinar recording

In August I did a webinar as part of the IBM Rational Rhapsody enlightenment series that covers the slightly more advanced topic of executable MBSE.

The following is IBM's link to the recording (you need to give them your email address but it plays straight away):

The webinar was mainly demo. It focuses on using executable MBSE to build test case sequence diagrams and plans from use cases using a method I'm calling called ROCKETs (Requirements Originating in the Context of Knowledge from Executing Transitions on Statecharts). It's a method that works really well with Rational DOORS.

This shows a prototype of my v3 SysMLHelper, an open source plug-in and profile that intends to make the job simple. It's a much more advanced topic than the first video but I've tried to make it fun and interesting. I start with a blank model and transition through the process of making an executable model from nothing, finishing with use of an Add On to Rhapsody called "Test Conductor" that enables suites of tests to be built and executed. 

Of course, this is possible without automation only I wouldn't be able to do in in 20 mins! It would take me weeks to build the model and explain how to build it. The automation I show is something I've been working on and using for over 3 years now. There is over 10K of Java and some of my best ideas for making working with Executable Model-based Systems Engineering (MBSE) and IBM Rhapsody Designer fun and relevant ;-)

Note: My next public training course is w/b 23rd Oct 2018 at HORIBA-MIRA (in concert with the Functional Safety Team). 

Tuesday 11 September 2018

Tips and tricks for navigating IBM Rational Rhapsody models - IBM Webinar recording link

If anybody missed the IBM webinar I did on "Tips and tricks for navigating Rhapsody models" there's a link here to the IBM recording.

This was really a compendium of lots of the smaller tips I've given in short videos plus a few newbies. Topics included:
  • Workspace & Toolbars
    • Recent Projects list display length
  • Browser
    • Show & hide
    • Collapse & expand
    • Using the keyboard
    • Flat vs Categories
    • Tear off browsers
    • Filtering the browser
  • Advanced search and replace
    • Convert to queries
    • Clever queries
    • ShowInBrowserFilterList
  • Favorites list
    • Add to favourites using Ctrl + D
  • Enhanced tooltip
    • Enable / disable
    • Diagram preview in browser
    • Roll over links
    • Controlling with properties
    • Show on diagram
    • Tear off using Ctrl + F2
    • Java Customizing enhanced tooltip
    • Double-click
  • Hyperlinks
    • Adding them
    • Navigating them
  • Navigate
    • Locate in browser 
  • Plug-in examples
    • Locate on diagram
  • Naming conventions
    • Navigation toolbar
      • Back button
      • Hold-down for list
    • Quick navigation icons
      • Enable/disable
    • Diagram navigation
      • Zoom using wheel mouse
      • Zoom to selection
      • Pan tool
      • Full screen
      • Bird’s eye
      • Find in diagram (Ctrl+Shift+F)
    • 6.0.6 Jazz/am Web browser

    Rational Rhapsody Tip #42 - Create dependencies between read-only elements

    I'm back off my hols! This came up recently with a couple of customers. Both were asking "how can I create dependencies if the owner is read-only?". Well, this is possible with IBM Rational Rhapsody. However, you need Rhapsody 8.3, or later (January 2018). In 8.3 the General tab of the Features dialog has separate listings for both the Dependent and Depends On element. The owner is implicit from the element’s location, so generally you need to create the dependency first (under an owner that is read-write) and then move it. When you drag to move a Dependency then a dialog pops up to ask if you want to change the source, the target or both? To move the dependency but keep the relationship the same then you need to choose change source only. This short tips and tricks video highlights, by first drawing a dependency between two elements that are read-write and then trying the same thing when the two elements are read-only.

    It also shows how Rhapsody creates an inferred "source dependency" category under the dependent element, even though the element is read-only and the true dependency owner is elsewhere in the model. The element which owns the dependency will have the "owned dependency" category. Such dependencies are still analyzed by the gateway in the same way, despite their change of ownership, enabling you to establish dependencies between two elements that are read-only and have this reported for traceability purposes.

    Thursday 30 August 2018

    Open Rhapsody MBSE training at HORIBA MIRA ACADEMY, 23-26 Oct 2018

    I've just announced a open (i.e. public enrolment) Mastering OMG SysML with IBM Rational Rhapsody training for 23-26 October, if anybody's interested. This is in conjunction with HORIBA MIRA ACADEMY who will deal with bookings and invoicing (if needed). More info is on their landing page. The plan is to use the new MIRA TECHNOLOGY INSTITUTE venue (very blush and new, hopefully). As with the previous public/open courses, we've moved to allow options of 2, 3, or 4 days based on budget and depth of training desired. If anybody has any questions about content then feel free to ask.

    Wednesday 15 August 2018

    Really good article on the source control model

    A picture paints a thousand words:

    Webinar: Driving quality from simulating system tests with Rational Rhapsody on 21 Aug 2018

    I'm doing another IBM webinar next Tuesday, August 21st 2018. This is entitled "Driving quality from simulating system tests with Rational Rhapsody". The topic is around use of behavioural use case modelling to close the loop between requirements creation and test planning.

    Registration URL:

    This webinar is hosted by IBM and part of IBM's Rhapsody enlightment series.

    Rhapsody Tip #41 - Making the recent files list wider (Advanced)

    Note: It sounds like a "yeh, yeh, sure" tip. However, create a back-up of your rhapsody.ini file before editing, as sometimes Rhapsody will try to write even though it looks as though it's closed down, hence you could end up corrupting it (which may mean that you lose your Gateway or TestConductor menus).

    This IBM Rational Rhapsody tips and tricks video shows how to get Rhapsody to use more characters when displaying the Recent Files list in the File menu. The variable is called MaxDisplayLength and needs to be set in the [General] section of the .ini file. This was new in Rhapsody 8.3.1, hence you may have to upgrade for it to work. The value of the variable should be the number of characters that you want to have displayed. If you set MaxDisplayLength = -1, there is no limit on the width of the menu. Be careful though. Rhapsody writes to the .ini file. As with all manual .ini file changes be sure that Rhapsody is not running when you edit it!

    The video also shows an example where I needed this to demo Rational Model Manager more effectively. When showing collaborative model management you often want to switch to different views of the same model owned by different users in different sandboxes. To choose the correct path using the Recent Files list I set the MaxDisplayLength variable.

    Wednesday 8 August 2018

    Webinar: Tips and tricks for navigating IBM Rational Rhapsody UML and SysML models on 14 Aug 2018

    As you're all on the beach somewhere for your holidays, I'm presenting some IBM Rational Rhapsody webinars. The first is a "Tips and tricks for navigating IBM Rational Rhapsody UML and SysML models" on August 14th 2018:

    Registration URL:

    This webinar is hosted by IBM and part of IBM's Rhapsody enlightment series.

    Rhapsody Tip #40 - Using context patterns to show a chain of elements in a table (Advanced)

    I've reached video 40! This is an introduction to building table layouts with context patterns. Even simple tables in IBM Rational Rhapsody can be quite powerful. When we create a TableLayout, we can have each row represent a single element in the model, with each column displaying information about that element. We can also build relation tables, where the row represents a relationship between two elements. Alternatively, we can have a row in the table represent a hierarchy of elements in the model. To build a chain of elements as a table row, we can use a more advanced concept called a context pattern.

    A context pattern is a comma-separated list of tokens. It is a way to describe a path of elements in the model. Each token in the pattern is a Rational Rhapsody metatype name that is either a core type or a term. This short video shows building a table that shows how blocks relate to safety goals which relate to hazards (new term types I've added to Rhapsody in a profile). The key tip is to know that to navigate to the end of a relation type you can put a colon (:). This, for example, allows us to traverse the relatesTo dependency to find the Hazard. The text in the curley brackets is a unique name for the context, weI can select the context in the Columns list for this. A couple of other options are also shown, such as collapsing the first column, changing the order, and using the Fill Defaults button. Enjoy!

    Friday 3 August 2018

    Installation guide for IBM Rational Rhapsody 8.3.1

    I've published my installation guide for IBM Rational Rhapsody 8.3.1 client.

    This is provided as a pptx (because pictures paint a thousand words). As well as steps for installing it includes steps for checking that the Cygwin compiler is working, Rhapsody Gateway is installed and licensed, and that Webify is working.

    Also included are:
    - Downloading and installing a evaluation version of Rhapsody.
    - How to obtain and install the 8.3.1 iFix 1 (for Jazz/am usage, aka Rhapsody Model Manager).
    - Minimal choice for installing Cygwin gcc and make (unlike the Rhapsody help suggested choice).
    - Installing SysMHelper sample profile (and advanced open source example of profile and for SysML / executable MBSE with an automotive slant).
    - Tips on silent download.

    The steps take the approach of installing all Editions and tailoring the rhapsody.ini afterwards (the approach most Rhapsody Application Engineers use).

    Saturday 28 July 2018

    Rhapsody Tip #39 - Nested states, the art of state-machine design (Intermediate)

    Increasingly in my IBM Rational Rhapsody training I've been getting engineers to communicate with each other by drawing UML/SysML diagrams as a group exercise. Like with any natural language there is often more than one way to say the same thing. Knowing the best way is sometimes an art. The use of nested states is one such example. If you're building a state machine and I find I have many states reacting to the same event, then this little voice pops into my head which says "should I create a superstate?". Sometimes it's obvious whether a superstate is good, sometimes less so (that's the art). The key thing is that we do need to consider the readability of diagrams. We are, after all, using them to communicate. In this example I build a Rhapsody project from scratch with a simple state-machine that builds and executes and the user can interact with. I then show how the same behavior can be modeled in a different way by introducing a super state. Of course, knowing techniques like this also comes from experience. I like to think it also comes from training and the value of training is building people's confidence in using UML or the OMG Systems Modeling Language to communicate.

    Monday 16 July 2018

    Rhapsody Tip #38 - Introducing Diagram Views, new in 8.3.1 (Intermediate)

    In my previous Rhapsody tips and tricks video I covered a feature of IBM Rational Rhapsody known as Custom Views. This capability worked in conjunction with things like Queries to create filtered views. The powerful thing about these views is that they can filter both the diagrams and the browser in Rhapsody. The thing is that the filtered diagrams would only be visible if the Custom View was active. In 8.3.1, the Rhapsody development team have expanded Rational Rhapsody’s capabilities by allowing these views to be persisted in the browser. These persisted views are known as diagrams views. As well as making it easier for users to access them, it also makes them easier to include in documents generated from the model. It’s a layer on top of other layers that adds a cool new capability. This short video demonstrates the base concepts of Diagram Views by building on the project created in the previous video.

    Training material updated to 8.3.1 (Version 8 of Mastering MBSE with OMG SysML and IBM Rational Rhapsody)

    My mission is provide up-to-date affordable and fun training for IBM Rational Rhapsody, i.e. latest release. I've just been through my Mastering MBSE with IBM Rational Rhapsody training labs to test and update to release 8.3.1 (Build 9835550). No major issues. Surprisingly good given that I had 650 tool training slides with no workarounds, hence my training can happily move to this version.

    I did find occasional reload pop-up (not seen as an issue but will check).

    I also had an issue with Notes populating correctly via API (presumably because it was changed to allow rich text hyperlinks). However, I then found that there is an iFix called 8.3.1-RAT-RHAPSODY-IFix1 that fixes this! (yep, should've installed this first. Doh!).

    Summary is that 8.3.1 is worth for going over 8.3 but don't forget to check Fix Central for iFixes and install these at the same time. In terms of rational for 8.3 over 8.3.1 the RMM upgrades with 6.0.6 are enough to warrant this but also there's also polish in other areas worth keeping up with, e.g., I'm getting used to double-clicking to use stamp mode now.

    Thursday 12 July 2018

    Feedback from last week's MBSE with OMG SysML an IBM Rational Rhapsody training

    Last week's Mastering MBSE with OMG SysML and IBM Rational Rhapsody 8.3 training was fun. This was the collated average feedback from the 9 attendees (where 5 = max, 1 = min):

    Lot's of active participation again, with attendees from multiple companies (big auto-slant). I also learnt that the collective noun for a group of functional safety engineers is "a hazard" ;-)

    Feedback/testimonials included:

    "The presentation was clear and at a good pace. I feel I have gained a good understanding of the strengths of the tool" (senior electrical/electronics engineer)

    "Trainer (Fraser) is very knowledgeable, very receptive and approachable to questions. Course provides a good overview of SysML" (software engineer)

    "Good mixture of s/w, presentation & group activities" (engineer)

    "I liked the flexibility on topics and insights / real-work experience of application" (snr engineer)

    "I liked the entire class group exercises. Very much enjoyed the class. Fraser is a true expert and an excellent instructor" (director)

    Tuesday 10 July 2018

    Rhapsody Tip #37 - Filter diagrams and the browser with CustomViews (Intermediate)

    You can easily get the impression with IBM Rational Rhapsody's CustomViews that they're too powerful for their own good. The possibilities are endless though, hence they have a lot of pent-up power you can unleash. First introduced in 8.2.1, this video actually uses 8.3.1 to show them (hence you'll see me double-click the drawing toolbar to enable stamp mode!).

    Rhapsody's CustomViews are a layer on top-up of existing layers, hence this video tries to build things up from the ground level. I first create a tag for ASIL A to D ratings and use a stereotype to convey the tag value to multiple elements. I can then easily create Query elements in the browser able to find elements with particular tag values, e.g., a query that finds all the elements with an ASIL tag value of D. Once I have the Queries built then I form some simple CustomViews that use the queries. Like Query elements, CustomViews appear in the browser, hence can be shared between projects in a profile. They can also be used to filter the browser. This is a bit like putting your reading glasses on (if you have them). Unlike filtering the browser with queries, you can multi-select the CustomViews to show in the browser or on diagrams (like putting on bifocal glasses?). Of course, this video just shows one example of usage. There are many other possibilities (modeling variants is one that springs to mind). Hope it helps!

    Tuesday 26 June 2018

    Rhapsody 8.3.1 was made Generally Available (GA) on 15 Jun 18

    Rhapsody 8.3.1 was released on 15th June 2018. Key things for me are:

    1. Improvements related to Rhapsody Model Manager 6.0.6 (the RTC file-based replacement to Design Manager's client-server based architecture). RMM supports OSLC with increased scalability and ability to work over WAN and in software-centric workflows (like RTC). P.s. Although I mention software-centric, there is equally important thing for systems engineers especially in shared environments where you're exchanging models. Don't forget, RMM is licensed with Design Manager Jazz licenses. Existing users with Designer and Developer licenses under maintenance therefore have entitlement to use it.

    2. More little usability tweaks. The intersection bridges and stamp mode improvements are ones I've already covered in tips and tricks videos, but there are others (e.g. diagram views allow you to persist query-based views of diagrams and enables some new 'interesting' possibilities, particularly around filtering diagrams, e.g., for variants or SIL level views).

    3. Visual Studio 2017. Important for software users that Rhapsody is keeping up with the every changing software world.

    4. An option to display name of operation for Call Operation in activity diagram. This is a small but important enhancement for me as it opens up the possibility to use call operations better to re-use actions across activity diagrams. My SysMLHelper toolkit already supports improved call operation usage workflows hence this will help join the dots for those interested in that workflow. Importantly you can now write the operation description in the call operation's compartment on the diagram.

    5. Webify in 64 bit. Hallelujah! Does this mean I no longer have to recommend sticking with the 32 bit for system simulations? The promised land is close.

    6. Lots of AUTOSAR stuff (if that's your bag). Did you know AUTOSAR profile is created using MDA techniques, i.e. model-to-model transformations? I think it's rather clever how they keep up to date with the standard. Even, if you're not using AUTOSAR, Rhapsody is big in automotive usage.

    This is the list of all the Rhapsody releases.

    Sunday 24 June 2018

    V7 of Mastering MBSE with SysML and Rational Rhapsody

    I have just completed the version 7 update of my 4-day Rational Rhapsody SysML training material. As with the v6 material it's still based on Rhapsody v8.3. However, I've added an improvements particularly in the ports and interfaces area including new theory slides and a full new lab (covering standard vs proxy ports).  If any previous training attendees want the new slides then email me.

    My next open training course is 3-4, 5-6 July in conjunction with HORIBA-MIRA academy. It's not only automotive focused but I imagine the topics of how SysML and Rhapsody can be used in 26262 and A-SPICE projects will be on the radar. Course is confirmed but there's still time to register if you're fast. There are options for 2-day Foundation in SysML, essentials 3-day or advanced 4-day training on SysML with Rhapsody. The material is up-to-date and developed with a license agreement with IBM.

    Friday 22 June 2018

    Looking at a Pizza chain system from 4 different perspectives - MBSE Interest Group Mtg - 22 Jun 18

    Following on from a practical session I tried another team exercise at the INCOSE UK MBSE Interest Group yesterday (at Thales in Reading) using white boards. This came from positive feedback to the idea of the last practical session I did (on ports). The topic this time was around the confusion that is often caused if you don't understand or stakeholders misinterpret the system context. 

    The room was split into 4 different teams and each team was given 10 minutes to come up with the use cases for a Pizza restaurant chain that makes Pizza, from a different perspective: The organisation, a restaurant, the kitchen and the chef were the 4 levels. These were the results:

    Each team then presented back and we explored the idea of looking at a system-of-systems like this with use cases at different levels, how actors and goals might be different at different levels of abstraction and how the higher levels allow you to make bigger decisions with more impact.

    Personally I think there's a lot of value of doing recursive use cases system models, and ensuring that all use case models are created in team workshops rather than individually. Also, I think it was good also as it gets people talking and learning each others view points. I enjoyed the meeting and learnt a lot from the feedback. Importantly, rapport is often key in a team and getting each others views really helps this. I might use the idea in my next training!

    Tuesday 19 June 2018

    Rhapsody Tip #36 - Stamp Mode including double-click in 8.3.1 (Simple)

    Stamp Mode has been in the IBM Rational Rhapsody drawing toolbar for a long while. This short 1 min info video shows how it works and what it's for and also highlights an improvement to it in Rhapsody v8.3.1 (2018). If you double rather than single click a tool then essentially stamp mode will become enabled. This reduces the effort required to enable it by making it easier to turn.

    Tuesday 12 June 2018

    Rhapsody Tip #35 - Nested ports in SysML 1.3 (Intermediate)

    Rhapsody supports the SysML concept of nested ports. However, it's not always easy to remember how to enable these. This short video illustrates how to do nested ports with SysML proxy ports and their associated InterfaceBlock. Nested ports are enabled via a right-click menu on the SysML port. Interestingly when you add a nested port to a port, then it is added to the Block or InterfaceBlock that is typing the port. This video shows a proxy port example with an InterfaceBlock. Rhapsody also supports the same capability with FullPorts. As such you could use similar steps to model physical interfaces with Full Ports typed by Blocks.

    The video uses 8.3 although this capability was fist introduced in 8.1.3. This is all part of a SysML language that can weave many different types of tapestries. If you want to know which is the best tapestry to weave then that's a different question ;-)

    Wednesday 6 June 2018

    MBSE with OMG SysML (and Rhapsody) Open Training 3-4 5-6th July near Nuneaton, UK

    I'm pleased to announce plans to run an Open/Public training for OMG SysML at HORIBA-MIRA near Nuneaton 3-6th July 2018.

    If you just want tool-neutral SysML awareness there's an option to just do the first 2 days. Training will be 4 days for those wanting deep-Rhapsody learning (3 days if you just want Rhapsody essentials). Plenty of options, therefore, but if you have specific needs then feel free to discuss. Training would be with latest Rhapsody release, 8.3 (although I could cover some 8.3.1 preview bits on day 4, if needed).

    Tuesday 5 June 2018

    Rhapsody Tip #34 - Diagrams: Bridges for line intersections - new in 8.3.1 (Simple)

    With 8.3.1 in the release pipeline, this video gives taster of one of the customer-requested usability enhancements in the RC1 open beta. Of-course, Visio does this kind of thing but it's nice to see that the team are polishing IBM Rational Rhapsody's diagramming capabilities and this is one of my favorites. The feature works when the line is rectilinear_arrows or rounded_rectilinear_arrows. Two  properties can be used to control it.

    General::Graphics::RectilinearBridgeDrawing turns it on and off,
    General::Graphics:::RectilinearBridgeShape can be set to Rounded, Rectangle, Triangle, or Space.

    There's few notable things in the release so stay tuned for more 8.3.1 videos.

    Next INCOSE UK MBSE Meeting - 21 Jun 18

    FYI: The next INCOSE UK MBSE interest group meeting is Thursday, 21st of June, 2018 in Reading RG2 6GF. These tend to be really well attended with a  mix of different industries/companies/tool users. At the last meeting in March I did a session on the different port types in SysML that seemed to be well received as it was quite interactive.

    Time: 10:00 to 16:00 (Provisional dependent on agenda)

    For those that don't know WG exists:

    Attendance would require you to be on the list though.

    Monday 4 June 2018

    Systems-of-Systems and Use Cases: An Insulin Pump System Example (9 min video with captions)

    I tend think use cases are great before they force you to think about your system boundary. That said, I've been in plenty of meetings where everybody is agreeing on the use case, but participants actually have completely different perceptions of the system context. Like the statement "controlling the speed has nothing to do with my system, it's done by this other system" is an interesting one when talking about Cruise Control. Clearly if your system is a vehicle then the system will be controlling the speed. If your system is a sub-set of the vehicle, then it will depend on which bit you own.

    In this video I walk through an example of an insulin pump system, or more precisely, two systems that relate to an insulin management system to show how each level can have use cases, but that the use cases differ in the level of abstraction. The key is that the concept of abstraction allows us to deal with complexity at the system-of-system level by focusing on essential detail only. It's also abstraction that enables us to keep things valid and current as the detail is fleshed out. My view is that one should create different use cases at each level and give ownership to the teams. Like when a sky-diver jumps out of an airplane, the first thing they look for is not the gate in the field. The same thing applies with models. This video illustrates using an Insulin Pump Management System to illustrate the value of abstraction. It shows shows an example of how to use Rhapsody's Allocation Wizard to allocate system functions to parts of a system.

    Friday 1 June 2018

    Rhapsody 8.3.1 Open Beta

    Rhapsody released tend to be aligned with Jazz platform cycles (6 monthly). This means that the time for 8.3.1 is approaching.

    There is actually an open beta version you can download (obviously needed if you're testing Rhapsody Model Manager backend, like me).

    The Rhapsody 8.3.1 beta link is on, all downloads tab:

    Scroll to the bottom to find the Rhapsody Open Beta link. You might need to fiddle around a bit to get the IBM ID login to come up but it should allow you to download the zip.

    Remember, although multiple Editions of Rhapsody can be installed, you need to be careful that the DLLs are registered correctly if you're using some of the add-ins (or you uninstall one of them hoping to use another).

    Check out the bridges!

    Monday 21 May 2018

    Video (8 mins) on Making MBSE with Rhapsody simple (SysMLHelper 3rd generation enhancements)

    I've put a new video of my Gen #3 profile onto youtube, in case you're interested. This shows some of the new ideas I've incorporating into the 3rd generation of the profile. It just shows a simple requirements analysis method helper.

    In this video I explore some new ideas I'm working on for my 3rd generation of the SysMLHelper profile; an open-source profile for IBM Rational Rhapsody that is designed to "Make MBSE with Rhapsody simple" by adding automation that enables engineers to focus on the fun and creative tasks, rather than how to set-up and configure the tool. This makes it easier to deploy MBSE and SysML modelling techniques to a larger team. Automation and product tailoring increases the chance that you will achieve productive success first time because the helper is based on methods known to work. The wealth of usability enhancements mean that you have a richer but tailored toolset available. As the helper is open-source there is also the option that I could tailor it for your organisation and processes, making use of over 11 years of experience as a Rhapsody technical consultant and trainer.

    Some of these come from work I did recently on a customized profile for a different client. Some are things I've wanted to do for a while but not had time.

    Thursday 17 May 2018

    Rhapsody Tip #33 - Conveying Standard Content using stereotypes

    This silent helper video illustrates a built-in feature of IBM Rational Rhapsody called Standard Content. This feature allows you to define standard content that you want to apply whenever you apply the stereotype to a model element. First off, you need to define the standard content, i.e. the template. You then need to establish a dependency to it from the stereotype you want to apply, and stereotype the dependency using «StandardContent» from the pre-defined types. Now, whenever you apply the stereotype to a model element, the standard content will be merged with the elements content (preserving existing content if there's a conflict).

    StandardContent works with all types of elements. It also works with New Term stereotypes. It provides a quick way of templating things, when no model transformation is required. If you want to perform a model transformation on creation then writing a Java plugin may be needed, something I can provide consulting or training on, if required ;-).

    Wednesday 16 May 2018

    Tailoring the Harmony/SE MBSE method for automotive paper

    For those that have asked, these are the links to the Tailoring the Harmony/SE MBSE method for automotive TailoringTheHarmonySE-MBSEMethod-ForAutomotive-V4.pdf paper that I delivered at the INCOSE UK ASEC 2017 conference in November. Here's the abstract:

    Abstract. The Harmony/Systems Engineering (SE) process is a Model-based Systems Engineering (MBSE) process originated by Hans-Peter Hoffmann Ph.D. (i-Logix, Telelogic, IBM) based on work by Harel (Harel, Politi 1998). First published as “Harmony/SE” in 2006, it exploited the executable modelling features of the i-Logix Rhapsody® UML tool, based on Harel statechart semantics (Harel, Kulger 1996) to build executable specifications of systems based on modelling use cases. Emphasizing the identification and allocation of desired functionality and state-based behavior rather than details of functional behavior, the method achieved strong usage in the traditional systems engineering markets such as aerospace and defense. With the explosion in the complexity of state orientated Advanced Driver Assistance Systems (ADAS) and other similar systems, this paper will overview the method but look at real experiences of tailoring the ideas of Harmony/SE with SysML in the automotive domain and how it is both similar and different to the traditional Systems Engineering market. The paper reflects the author’s own views rather than the views of automotive companies he has worked for (Jaguar Land Rover, Daimler AG). Aspects covered will include reflections on extending the method to support use of the state machine inheritance, use of simulations and/or lightweight modelling to engage stakeholders, and – importantly – the human aspects including adjusting UML/SysML usage to ease absorption by an automotive control engineer community.

    For those that don't know, the Annual Systems Engineering Conference (ASEC) is INCOSE UK's flagship annual event and brings together a wide range of professionals from a variety of backgrounds, with the common interest of building upon their Systems Engineering (SE) knowledge and sharing ideas with their peers. The focus of the conference was "Pushing the boundaries of systems engineering".

    The paper gives a lot more description than the slides. Here are the TailoringHarmonySEForAutomotive-WidescreenNoVideo-V3.pdf slides.

    Friday 11 May 2018

    Executable MBSE - "Death Star (in 10 minutes)" use case

    This is a video that gives a flavor of Executable MBSE using Rational Rhapsody Designer with the Cygwin/gcc compiler. This video is based on the second generation of my SysMLHelper profile. I'm currently working on the 3rd Generation.

    I might do the Mango Crusher next! Any other novel ideas accepted?

    Feedback from Rhapsody in C++ for Software Engineers 8.3

    As usual, I try to post my training feedback. This is the aggregated feedback from my 4-day Rhapsody training last week (the participants who responded that is), where 5 = strongly agree and 1 = strongly disagree.

    Testimonial include "Excellent course!! (S/W Lead)", "Learned a lot even from watching Fraser navigate around Rhapsody - lots of tips and tricks picked up!", "Fraser very friendly and helpful throughout", "Good background into UML".

    As always, I will look to deliver with the latest version. This was a Rhapsody in C++ Essentials training using Rhapsody 8.3 (iFix 2) and was an official derivative of IBM material.

    Saturday 28 April 2018

    Rhapsody Tip #32 - Graphical merge using Rhapsody's 3-way DiffMerge tool (Intermediate)

    Although Rational Rhapsody has a multi-user repository in Design Manager available, it has historically a file-based tool which integrates directly with configuration management tools. Core to SCM is making sure the tool of choice (e.g. RTC, ClearCase, Synergy) is configured to use the Rational Rhapsody DiffMerge tool. DiffMerge is therefore a separate tool launched independent to Rhapsody that understands Rhapsody projects and how to merge them. Included in this is a very advanced feature known as 3-way merge.

    This video shows the basic operation of the DiffMerge when dealing with parallel changes to the same project and diagrams. Key aspects of this are that the Rhapsody DiffMerge will automatically resolve all trivial parallel changes, leaving the user to deal with changes that are non-trivial, i.e. conflicting or where a user choice is needed. This video illustrates an example where two users change the same diagram.

    Friday 27 April 2018

    Different port types in an OMG SysML model (the old pre SysML 1.3 vs new 1.3+)

    This post covers a brief introduction to the different port types in a Rhapsody SysML project (8.2.1 and 8.3).

    Standard UML ports

    The port named ‘pOC’ here is a standard port contracted with standard UML Interfaces. Ports are named interaction points used for isolating Blocks/Classes.

    Recognisable with the lollipop and cup symbology, the lollipop tells us the port is contracted to provide the iSubsystem interface.

    The cup tells us that it requires the iConsoleAck interface.

    The «interface» is a type of class in UML that lists the signatures of operations provided independent of implementation.

    This notation is core to component-based design of software with UML2, hence works well with software-centric system modelling. Although deprecated from SysML it remains important in UML, and is still widely used in SysML and systems models, due to its flexibility and power. For example, a single port can provide or require multiple interfaces

    If you make use of these, then you may also find you are making use of object-orientated features of UML (such as polymorphism). For example, a behaviour port is one where the Block itself will realize the provided interfaces on the port.

    When using standard ports where the port is connected to other parts that provide or require interfaces, separate interfaces need to be used to show the operations in each direction, i.e. a single interface cannot show bi-directional services/operations. Also UML ports are service-orientated; hence they cannot show the flow of data or objects.

    SysML proxy ports

    The second port type shown here is a SysML proxy port, recognizable by the «proxy» stereotype. There is no lollipop and cup symbology. Proxy ports interfaces are described using a new type of Block introduced in SysML 1.3 onwards called an «InterfaceBlock». Rather than using the Contract tab in Rhapsody, the port is typed by the «InterfaceBlock» that describes the contract.

    Use of the «directedFeature» stereotype allows specification of direction as provided or required. Unlike with standard ports, single interface block can therefore show bi-directional interfaces between two Blocks.

    The provd and reqd annotations in the «InterfaceBlock» compartment show us the directedFeature settings.

    As with UML and pre SysML 1.3 ports, the ~ tells us that this port is ‘conjugated’, i.e. it mirrors or provides the reverse of the interface.

    Unlike the UML port we can also show data or object flows, not just operations and invoked behaviors. For example, if we add flow properties then we can see that a direction indicator is also shown.

    With a proxy port we can therefore manage the bi-directional signals sent between two components on a single «InterfaceBlock».

    In some ways, therefore, this is a simplification.

    SysML Flow Ports (pre 1.3)

    The third type of Port shown here is a pre-SysML 1.3 Flow Port.

    Flow Ports were typed by a SysML concept called «FlowSpecification», an interface concept focusing on data or material that flows designed to allow systems engineers to model aspects like the flow of physical properties.

    These concepts have been replaced by the ProxyPort and InterfaceBlock, respectively, hence a direct translation of this to the SysML 1.3+ proxy port notation is possible.

    One area where FlowPorts can still be useful is where you want to show discrete signals typed by primitive data types.

    When modelling such concepts, a separate InterfaceBlock for each port would lead to a plethora of model elements in the browser which is both difficult to maintain and would bloat a model. This notation is commonly used for integration with Simulink Blocks, and can be desirable for automotive models.

    Until the SysML standard and Rhapsody tool fully support primitive types using Proxy ports therefore, the presence of Flow Ports is likely to remain.

    Also, you may find that there is code or event generation possible with flow ports, not supported in model executable with proxy ports.

    SysML Full Ports (1.3)

    The final type of port shown here is a Full Port, which can be thought of as “a part on the boundary”. A full port is most commonly typed by a Block itself. 

    The different with a proxy port is that the Block will realize the behaviours of itself. Using Full Ports typed by Blocks, the concept of conjugation does not really exist. They are more commonly used to represent physical connections. Another way of doing the way thing would be to create a part and use proxy ports with an InterfaceBlock.

    In summary:

    Full Ports were also introduced in SysML 1.3. They represent a part on the boundary. More commonly used when modelling a physical assembly, as they provide a clear graphical representation that can be shown as connected to the outside world. They tend to be used less, and some authors suggest that modelling with non-behaviour proxy ports may offer more consistency as the part is then shown inside the owner.

    Standard Ports are UML ports and make use of UML Interfaces. If you use them then you are essentially modelling with UML in a SysML model (which to be honest may be perfectly fine). They make use of the cup and ball (aka lollipop and cup) symbols to show the provided and required interfaces contracted on a port.

    The more correct SysML port nowadays tends to be a Proxy Port. Proxy ports are typed by a SysML InterfaceBlock. InterfaceBlocks and ProxyPorts can show both flows and operations/messages and show them flowing in either direction.

    The result of the introduction of Proxy Ports and Interface Blocks means that the need for Flow Specifications with Flow Ports becomes redundant. That said, there are still some instances where Flow Ports can be simpler, for example, want to use primitive types, and when you want to do simulation.

    Wednesday 25 April 2018

    Feedback from my Mastering MBSE with Rhapsody training in Sweden last week

    I've done a couple of training deliveries since my last post about them. This was the averaged feedback from a 3 day Mastering MBSE with OMG SysML and IBM Rational Rhapsody 8.3 training last week.

    This one was in Sweden. Testimonials included: "Good course - Recommended", "Good rundown of SysML and Rhapsody!" and "Good mix of general MBSE and Rhapsody". My reflection is that we could've easily done another day. I certainly have enough 8.3 material for when it runs as a 4 day (esp. when you get into understanding the different types of ports).

    Friday 13 April 2018

    Rhapsody Tip #31 - Referencing units in other projects (Intermediate)

    This Rational Rhapsody helper videos follows on from my video #30 on units and managing the project on the file system. In this video we look at referencing units from other Rational Rhapsody projects. Building families of projects that reference each other can often be better than having a single monolithic project. Separation of concern across projects means that projects can be managed separately, in different locations, and with separate versioning yet they can share common elements or interfaces. In this video I show how two projects can reference the same common unit in another project, including touching on the importance of considering absolute or relative references.

    Interestingly, the video also shows something that I didn't know until very recently. If you manage to import two projects that reference and nest the same third party unit, then Rhapsody will deal with the duplicate import situation by creating a linked unit. Generally, this problem will only occur if you move referenced units until other units (but it's interesting to know that there are still things to know!)

    Sunday 8 April 2018

    I released V2.2 of my open source SysMLHelper profile for executable MBSE with Rhapsody

    This includes a fix to the Functional Analysis Profile package helper that prevents issues that were found with running the helper with Rhapsody 8.3.

    See my blog for more information, links to the profile and full change history (I try not to keep the technical detail for the profile separate from this website).

    Profile should work with both 8.2 and 8.3. I'm now planning my version 3 enhancements which focus on more 8.3-based development (with DOORS Next and Test Conductor).

    Monday 2 April 2018

    Rhapsody Tip #30 - Understanding units and the Edit Unit dialog (Intermediate)

    Related to a key topic for for a US-based company I've been working for this is a new short helper video on using Rhapsody. It's the first of two related to sharing units across projects and provides base knowledge on what Rhapsody 'Unit's are and some of the options in the Edit Unit dialog (available on the right-click menu).

    A 'Unit' in Rhapsody is a file on the File System in which model information is stored. Understanding the concept of units is important prior to configuring Rhapsody projects under source-code management tool control, or to share information across projects on the file system. By default units are created for each package. It's also possible to create units at a finer level of granularity, e.g., for elements based on components, classes, objects and diagrams. This can be done individually or by setting project properties. This video explores some of these concepts and provides an in depth overview of the Edit Unit dialog.

    A follow-up video will cover sharing units between projects.

    Saturday 3 March 2018

    Feedback from Rhapsody in C and Mastering MBSE with SysML training's in Jan/Feb

    I'm doing a training roughly once a month now, predominantly private courses (although HORIBA MIRA are still organizing public MBSE/Rhapsody training's). This was my feedback from a 4 day training in Jan(from 8 of 13 that responded) that was an example of bespoke training:

    "The discussions and knowledge of the instructor meant we could tailor context to our needs"

    "The hands-on labs with individual laptops really helped reinforce the theory. The training material handouts were well organised"

    This was from a 3-day MBSE training in February to 9 participants (completely new to the topics):

    "It was a great 3 day programme. As a business development manager, I thought I wouldn't learn anything (new ;)), but, yes, it was a great learning experience. Could grasp many new stuff."

    "Group exercises, challenges and practical implementations alongside theoretical understanding made the training interesting and fun. A wide range of topics were covered in a short span of time".

    The main thing I've been learning (yes, learning is 2 way) is the value of including more group work and unguided challenges, i.e. things where participants have to put into practice the theory and get chance to ask the questions that arise from this.

    I've also learnt that although 3 day training with SysML and Rhapsody gives a good grounding, there's value in adding the additional day (i.e. 4 days is better if you want to cover both in detail).

    Wednesday 31 January 2018

    Mastering MBSE training now updated to 8.3

    I have now updated my Mastering MBSE with OMG SysML and IBM Rational Rhapsody to Version 8.3 of Rhapsody. I've also delivered it! Another delivery is planned next week.

    Don't forget that Rhapsody 8.3 also has an iFix. This may be important when deploying with Rhapsody Model Manager (RMM). Training on this latter capability together with Rhapsody and DOORS Next Generation (NG) using OSLC is planned.

    Sunday 28 January 2018

    Rhapsody Tip #29 - Understanding UML standard ports vs. SysML proxy ports (Intermediate)

    With coming up to 30 videos posted it's a little harder to find quick wins, so this one goes into a little more detail (i.e. took a lot more work).

    One of the key topics in my instructor-led SysML and MBSE training is getting to grips with different types of ports and interfaces in UML/SysML models. While SysML introduces two new ports in 1.3, full and proxy, there may be still models where standard and flow ports may be a better choice, or projects that predate the new port forms. Choosing the right one is crucial to value but depends a lot on context, and constraints, and needs. This silent video based on a new lab in my instructor-led 3 and 4 day training contrasts UML standard ports with SysML proxy ports, a new type of port in SysML 1.3 on-wards. It highlights some, but not all, of the key differences.

    I'm planning a follow up video on (pre-SysML 1.3) flow ports vs proxy ports, a topic which I feel is important for automotive systems engineering, in particular. As always, there are pros and cons ;-).