Subscribe

Why ReqIF is better than RIF

When the ReqIF standard was created, it was called RIF.  Only when the OMG took over the standard, it was renamed: Unfortunately, there was already an established standard called RIF, the W3C Rule Interchange Format.

Today, both ReqIF and RIF exist and are in use.  Many tools support RIF as well, so potential adopters may wonder why to go with the new ReqIF, when there is an established RIF standard around.  Which one to pick?

Why ReqIF? The short answer

For the following reasons, ReqIF should be preferred over RIF:

  • The ReqIF model is significantly simpler, compared to RIF, without compromising on features
  • The ReqIF data structures are easier to validate
  • Internationally standardized, therefore less risky in long-term deployment
  • Wider availability: All tool vendors we are aware of support ReqIF, but not all support RIF
  • For ReqIF, a reference implementation exists (open source), but not for RIF
  • Interoperability of the various ReqIF implementations is tested in the ProStep Implementor Forum (see below)

Even after thinking hard, we could come up with only one reason to use RIF: You have to use it if the partner you are exchanging requirements with requires it.

The various versions

There are three RIF versions and two ReqIF versions available.  However, the two ReqIF versions (1.0.1 and 1.1) are completely identical: All that has changed between them is the accompanying text, which clarified a few ambiguous text passages.  So for all practical purposes, there is only one ReqIF version today.

In contrast with this, there are five versions of RIF: 1.0, 1.0a, 1.1, 1.1a, and 1.2.  All versions differ.  Out of these, RIF 1.1a is the most popular one. Also note, that these are not “official” versions.  Rather, they are recommendations by ProStep and HIS.  But even as a recommendation, they represent a de-facto standard (similar to the Internet’s well-known Request for Comments, RFCs).

Compatibility

RIF and ReqIF are not 100% compatible, but they are fairly similar.  This means two things:

First, you cannot transform RIF to ReqIF and back and expect the same results.  Depending on which features of RIF/ReqIF you use, the results may differ.

Second, however, by imposing some constraints that are fairly insignificant in practice, compatibility can be achieved.

To give an example: You typically want to define the Attributes of requirements (SpecObjects) and links (SpecRelations), e.g. ID, Description and Status.  These are defined by a so-called SpecType.  RIF allows SpecTypes to be shared between different classes (in this case SpecObjects and SpecRelations), ReqIF does not.  For this example, the solution is simple: Do not share SpecTypes, if you want to perform a RIF-to-ReqIF transformation.

This also means that transforming between RIF and ReqIF is an option, but we’re not aware of any commercial implementations, probably because the demand is just to weak.  We therefore recommend to skip RIF, if this is possible, and to pick ReqIF right away. (If you need this route, however, we are happy to help you with our expertise.)

ProSTEP Implementor Forum

There is one more advantage to ReqIF: ProStep iViP, a non-profit organization that oversaw the RIF format for several years, has been running an implementor forum since 2011.  The objective of this forum is to ensure interoperability of the various implementations, something that never existed for RIF.  Forum members include big uses like Daimler, BMW and VW, as well as major tool vendors, like IBM, PTC and of course ourselves, Formal Mind.  The sentiment within the forum is clear: RIF is the past, ReqIF is the way forward.

We hope that this short overview helps you with your decision on picking the right requirements exchange format for your organization.

Image courtesy of anankkml at FreeDigitalPhotos.net