Home > Eclipse, EMF, Requirements Management, UML > Filling the void

Filling the void

September 6, 2010 Leave a comment Go to comments

The search…

As Andreas blogged a while ago, we at itemis are working on a requirements editor as part of a public research project. Developing a full-fledged requirements management tool is not in the scope of the project. What is of interest is to have a solution to enable traceability from requirements to design, all the way to source code. Looking around for an eclipse based open source solution for requirements management, we realized that this space is currently empty (except for ORMF which somehow didn’t fit our needs or give us confidence).

Having decided to move on with a solution of our own, the next step was to shop for a suitable meta-model for requirements. We weren’t quite unlucky as before here. We had two choices here, SysML or RIF.

SysML or RIF (now ReqIF)

SysML is a general purpose modeling language for systems engineering applications. RIF on the other hand is an interchange format for exchanging requirements between partners. Although SysML and RIF can capture requirements, we found RIF more apt for our needs, as its scope is limited to requirements management. Currently, RIF is up for standardization at OMG with a new name ReqIF.

RIF offers a schema based XML format as well as its UML meta-model in Enterprise Architect. To add to our confidence in RIF, IBM had already incorporated an importer/exporter for the RIF in IBM Rational DOORS . Several other companies, like MKS, are also working on an implementation of the RIF specification.

Bringing RIF to Eclipse world

The first step in building some tooling around RIF was to bring it into an eclipse compatible meta-model. Naturally, the first choice was Ecore, the now de-facto eclipse meta-model. However, converting RIF from an Enterprise Architect format to a Ecore XMI was a herculean task. After failing to do the conversion with the steps I detailed here, we went on a journey of export-import-export from tool to tool and finally had a RIF compatible Ecore meta-model.


The RIF Model

The RIF model is a generic requirements meta-model. (From another perspective, too generic to be called a requirements meta-model). The meta-model allows to define requirement types and requirement objects, fitting one of those types. Take for instance, a typeFunctional Requirement” with attributes such as “ID“, “Name” and “Status“. You could use RIF to create a SpecType named “Functional Requirement” with matching AttributeDefinitions for “ID“, “Name” and “Status” . The AttributeDefinitions could also have DatatypeDefinitions. Based on the defined SpecType you could create SpecObjects having AttributeValues for all the AttributeDefinitions.

This is a birds-eye view of the RIF meta-model.

The Editor

We retained the generic nature of RIF in the editor as well. To start with, you could create type specifications using a tree based editor.

Based on the type specifications, the editor at runtime creates an eclipse forms based user interface, lays it out neatly and lets you edit your requirements. As you could see below, the editor creates a tree to display the requirement hierarchy on the left. On the right, the editor lets you edit the requirement attributes by creating matching UI elements to handle the basic datatypes like StringIntegerEnumeration etc.  you created during RIF type specification using the tree editor.

Editor Extensions

You could easily build extensions to the editor using the provided extension points. If you need a specific UI behavior, you could define a new complex datatype and build UI customizations for this complex datatype.  For example, we extended the basic editor to have an embedded DSL editor (using Xtext) to capture detailed requirements.


The RIF editor loads and writes out XML conforming to the RIF schema.

Filling the void

We aren’t quite there yet. We, of course need more community interest and support to take this forward. Once we do, we hope to fill the void completely and have an open source solution for requirements management.

  1. September 6, 2010 at 1:15 pm


    Remarkable what you achieved in such a short time! As I said before, there is quite a bit of overlap between your work and ProR. However, we focused the few resources that we have on the GUI and the integration with Rodin, rather than on a functioning back-end. Our back-end doesn’t “speak” ReqIF yet, but persists using the generic EMF mechanism.

    At the same time, we feel that we found a really good solution for providing the user with a customized Specification View (I plan on writing about it shortly). We would be really interested in throwing our back-end out, to replace it with yours. Likewise, you may be interested in leveraging some of our GUI features. Let’s talk!

    – Michael

  2. September 6, 2010 at 4:40 pm

    Nice work!

  3. October 16, 2013 at 7:38 am

    What is the homepage of this tool?

  4. October 16, 2013 at 7:38 am


  5. October 16, 2013 at 12:18 pm

    Hi Vadi,

    It’s called ProR, part of the Requirements Modeling Framework, and can be found here: http://eclipse.org/rmf/

  6. October 16, 2013 at 9:35 pm

    I have indeed started poking about ProR as well! I’m also wondering what is the tool that Nirmal is writing about.

  7. Nirmal Sasidharan
    October 18, 2013 at 6:26 am

    Hi Vadi,

    I was talking about ProR and RMF in its beginning days.
    @Michael: Hiiiiiii :)

    • October 18, 2013 at 11:28 am

      @Nirmal, RMF and ProR came a long way, so far! Hope you’re doing good!

  1. September 6, 2010 at 11:23 am
  2. May 17, 2011 at 4:10 pm
  3. July 18, 2011 at 9:46 am

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: