Eclipse Free BIRD Tools introduces RPMN (Regulatory Process and Modelling Notation) as an open standard for Regulatory experts to easily describe and collaborate on machine readable requirements documents without programming experience.

RPMN is compatible with the artefacts published by BIRD for data models and transformations (and can be used with other regulatory data models and logic also)

RPMN allows solution developers to auto-create a skeleton of a tech solution (e.g. data base schemas and programming language functions) from RPMN as machine written solutions.

These machine written solutions are always in synch with the requirements doc, and gaps in functionality can be completed by technical programmers.

RPMN is inspired by and re-uses other standards typically used in defining regulatory requirements docs such as BPMN,ER-Diagrams and SQL, but refines these to use only what is most appropriate for regulatory processes, and establishes navigable links between the parts of the standard such as workflow to datamodel

RPMN is an open standard, RPMN has a language-neutral model to help technical tool developers to create business-user friendly tools on top of RPMN. The Eclipse Free BIRD Tools project provides open source tools based on RPMN in Python and Java.

The initial RPMN specification is available at the Github Wiki

RPMN has 3 parts as shown in the diagram below, these are described in more detail below


RPMN For Regulatory Subject Matter Experts

For business users RPMN (Regulatory Process Model and Notation) is just 2 things: Some simple diagrams and associated simple text formats.

Users can choose to interact with either visual or text formats .

The text files are human readable text files and easily stored in version control systems like Git/GitHub/GitLab/SVN .

It is easy to display and understand the difference between 2 versions of the text file

We have a different diagram and text format for each of these regulatory artefacts

  • Data Model
  • Workflow
  • Report Generation
  • Business Requirements/Regulations
  • Tests
We show examples of these below

Artefact Type Image Type Diagram Text Example
DataModel DataModel datamodel datamodel
Workflow Workflow workflow workflow_text
Workflow Workflow lineage lineage lineage_text
Report Generation No Diagram just text sql_text sql_text
Requirements Requirements book requiements_image requiremnts_text
Test Test Data test_data tests_text
Test Unit Test Scope test_lineage tests_text
Test E2E Test Scope test_lineage tests_text

RPMN for Technical users

RPMN is a definition of diagrams and associated human readable file formats allowing regulatory experts to describe and collaborate on regulatory artefacts as a machine readable requirements document.

Associated with these file formats is a UML model. This model describes classes, their attributes and relationships.

Technical users can use this model to programmatically generate solution skeletons in an executable language of there choice.

The same model can be used by technical developers who wish to create tools for editing and visualising RPMN.

Generating Solution Skeletons

It is possible to create software to read RPMN files and build concrete solutions such as:
  • Database Schemas
  • Function outlines in any programming language such as Python or Java
  • Workflow logic
  • Executable test that can be run in existing automated testing frameworks
To make this easy for technical developers we have a UML model which can describe the artefacts of RPMN such as data model and workflow.

This is inspired by the approach used in the BPMN standard from the OMG standards group which has a UML model (described in a cmof file here , although the RPMN model is much simpler)

RPMN's UML model can store all the structured information represented in the RPMN text files. Similarly BPMN's UML model can store all the structured information stored in BPMN files, although BPMN files are not easily human readable.

As part of Eclipse Free BIRD tools we have code that converts to/from the text format into an in-memory object tree using the classes defined in the UML format.

Having this in-memory representation of the files, allows any kind of manipulation/navigation/query/transformation/visualisation of the artefacts to create the skeleton of executable solutions.

These executable solutions can therefore always stay in synch with the machine readable requirements document, and lineage can built in also if required from requirement to executable code.

Creating RPMN Tools

The UML model can be used to create software to build tool support for the standard such as
  • Text editors for the file formats with auto-completion
  • Auto-creation of diagrams from the text formats
  • Visual and textual navigation of the artefacts
As part of Eclipse Free BIRD tools we have an example of this which uses the Eclipse Modelling Frameworks and its Sirius visualisation component to create diagrams. It also includes tooling in Python.

The link between text and UML model

As a very technical note, there is a grammar associated with the text file formats of RPMN.

The UML model is complete enough to store the items of the abstract tree of any text file written which follows that grammar.

We indicate how a file in the grammar can be translated to an object tree made of objects which are instances of the classes in the UML diagram.

When we have an object tree, this is a great starting point for generating visualisations, or other structures such as database schemas or Python/Java/Django classes. A common way to do this is with templating frameworks.

Eclipse Free BIRD tools provides an implementation which translates between text files following the RPMN grammar, and object trees in Java or Python

The UML Class diagrams and their documentation

Group Name Class Diagram Documentation
RPMN Data Model UML Class Diagram Documentation
RPMN Workflow UML Class Diagram Documentation
RPMN Report Generation UML Class Diagram Documentation
RPMN Business Requirements/Regulations UML Class Diagram Documentation
RPMN Tests UML Class Diagram Documentation
RPMN Module Management UML Class Diagram Documentation