Skip to main content
Jump to: navigation, search

Papyrus IC/Research Academia/Research priorities

Papyrus IC logo

This page will collect the proposed research priorities for the consortium.

The priorities are sorted in the order in which they have been added, with the most recent first.


Fraunhofer IEM

Institution/Organization: Fraunhofer IEM located in Paderborn, Germany is an interdisciplinary research institute for applied research (contract projects and third party founded projects) closely collaborating with the Heinz Nixdorf Institute of Paderborn University. The general focus is on design methodologies for embedded, mechatronic and cyber-physical systems.

Contact Persons: Joerg Holtmann, David Schmelter

Research Priorities Directly Related to Papyrus

Model-based Systems Engineering

Interdisciplinary, Model-based Systems Engineering with a dedicated specification method and modeling language called CONSENS, which we transferred to Papyrus by means of a SysML profile called SysML4CONSENS. The activities in this area focus on:

  • Correctness and comparability of models: Are the models specified by multidisciplinary engineers correct and comparable?
  • Adequacy of visualization: Are multidisciplinary engineers able to understand the particular model views?
  • User experience during modeling: Are engineers from disciplines apart from computer science/software engineering able to specify models with a software-affine language like SysML?

For these purposes, OCL as well as the DSML specification and customization capabilities of Papyrus are heavily applied.

Scenario-based Software Requirements Engineering

Model-driven, scenario-based Software Requirements Engineering with focus on the communication behavior of real-time and safety-critical software systems (ScenarioTools MSD). The activities in this area focus on the (semi-)automatic analysis of requirements formalized by means of Modal Sequence Diagrams (a UML-compliant variant of Live Sequence Charts):

  • Simulative validation of scenarios: Is the behavior emerging from the scenarios the behavior that the engineers expect?
  • Formal consistency checking of scenarios: Are there any contradictions in the scenarios that lead to safety or lifeness violations?

For these purposes, the DSML specification and customization capabilities of Papyrus are applied for the modeling language definition and visualization. Furthermore, the debug mechanism of Eclipse is exploited for the scenario simulation, and algorithms from game theory are applied for the consistency checking approach based on the scenario state space extracted from the simulation.

Requirements Engineering Based on Controlled Natural Language Including Transition to Graphical Analysis Models

Requirements Engineering based on a Controlled Natural Language (CNL) describing functions and the functional breakdown of the system under development, which also includes a bidirectional transition to a graphical analysis model in Papyrus representing a function hierarchy. The activities in this area focus on:

  • CNL design: How to design a semi-formal, textual language?
  • Model transformations: How to conceive bidirectional, consistency-preserving transformations between CNL and graphical models?

For these purposes, Xtext and model transformation techniques supporting the UML/EMF modeling framework as well as the diagram generation mechanism of Papyrus are applied.

Further research priorities:

Model-driven Software Design

Model-driven, component-based Software Design focussing on the platform-indepent and -specific modeling of software for distributed real-time systems with a UML derivate called MechatronicUML. The activities in this area focus on:

  • DSML design: How to conceive languages for component-based architectures and state-based behavior covering discrete real-time behavior?
  • Domain-specific model checking: How to hide the complexity of UPPAAL timed automata in the model transformation from more abstract timed state machines?
  • Compositional verification: How to achieve scalability of formal verification by means of model checking?
  • Integration of continuous models (e.g., MATLAB Simulink): How to combine state-based, discrete behavior with differential-equation-based, continuous behavior?
  • Code generation: How to conceive code generation mechanisms for multiple target platforms preserving the model checking results?

For these purposes, we apply a research prototype built in EMF/GMF (thus, independent of Papyrus). Based on this prototype, we utilize model transformations for different purposes, as well as mode-to-text engines.

Model Transformations

Application and conception of different kinds of model-to-model transformation techniques (QVT-o, Triple Graph Grammars, ...) to enable tool coupling across the particular engineering disciplines and model-to-text transformation techniques (Xtend, Acceleo, ...) to enable code generation.


Antonio Garcia-Dominguez

Institution

Department of Computer Science, Aston University (UK)

Research areas

Engineering education
Search-based software engineering
Scalability in model-driven engineering

Current lines of work

Use of advanced database technologies to speed up queries in large models (Hawk)
Exposing large models stored in various locations through reusable APIs
Turning large-scale software systems into models and producing analytics from them
Mutation testing of BPEL/C++ programs
Test case generation using evolutionary algorithms

Specific problems of interest

Integrate Hawk into the Papyrus model editors, providing efficient and flexible query capabilities
Provide alternative visualisations for very large UML models, based on typed graphs
Expose our UML models efficiently to other machines (whether they're running Eclipse or not)


Dimitris Kolovos

Institution: Department of Computer Science, University of York (https://www-users.cs.york.ac.uk/~dkolovos/)

Priority: Scalable model indexing

Since 2013 I have been collaborating with Konstantinos Barmpis and Antonio Garcia-Dominguez on a open-source framework (Hawk) that supports scalable indexing and querying diverse types of file-based models (e.g. XMI, Modelio) that reside in Git and SVN repositories, local, folders and Eclipse workspaces.

Relevant papers:

  • A. Garcia-Dominguez, K. Barmpis, D. S. Kolovos, M. A. A. da Silva, A. Abherve, and A. Bagnato, “Integration of a graph-based model indexer in commercial modelling tools” in Proceedings of the ACM/IEEE 19th International Conference on Model Driven Engineering Languages and Systems, Saint Malo, France, 2016, ISBN: 978-1-4503-4321-3, pp. 340–350.
  • D. S. Kolovos, A. Garcia-Dominguez, R. F. Paige, E. Guerra, J. de Lara, I. Rath, D. Varró, G. Sunyé, and M. Tisi, “MONDO: Scalable Modelling and Model Management on the Cloud,” in Joint Proceedings of the Doctoral Symposium and Projects Showcase Held as Part of STAF 2016 co-located with Software Technologies: Applications and Foundations (STAF 2016), Vienna, Austria, 2016.
  • D. S. Kolovos, R. F. Paige, F. Polack. The Grand Challenge of Scalability in Model Driven Engineering. In Proc. Models in Software Engineering, MoDELS/UML'08 Workshop Reader, LNCS 5421, Springer-Verlag, April 2009.

Priority: Incremental model-to-text transformation and model validation

As models grow in size, batch code re-generation/re-validation for every minor change made to a model is wasteful and scales poorly. In the context of the Eclipse Epsilon project, I am leading a strand of work on supporting automated impact analysis and incremental re-execution of model-to-text transformations and model validation constraints in response to model changes.

Relevant paper:

  • B. Ogunyomi, L. Rose and D. Kolovos. Property Access Traces for Source Incremental Model-to-Text Transformation. Proc. 11th European Conference on Modelling Foundations and Applications.


Daniel Amyot

Institution: School of Electrical Engineering and Computer Science, University of Ottawa (http://site.uottawa.ca/~damyot)

General research area(s) Software/Requirements Engineering, User Requirements Notation (URN), Goal Modelling, Business Process Modelling, Healthcare Informatics, Legal and Regulatory Compliance

Priority: Requirements modeling, analysis, transformation, and management

SysML supports requirement diagrams and tables that can be used to capture requirements, their attributes, and their relationships. However, several important concepts such as goals and contributions are not predefined in SysML, hindering the reasoning about tradeoffs and adaptation, especially in emerging socio-cyber-physical systems such as smart cities. One opportunity is to model such systems both with SysML and the User Requirements Notation (URN, ITU-T Z.151), a standard that focuses on the modeling and analysis of goals (with GRL) and scenarios (with UCM). SysML and URN are complementary and synergistic, and their combination enables new requirements modeling, analysis, and management opportunities for emerging types of systems

Specific problem(s) of interest:

  • How to combine or link the User Requirements Notation (and its goal part: GRL) and SysML for value-added tradeoff, impact, completeness, and consistency analysis,
  • How to assess the usefulness of different types of integrations
  • How best to support the above with tools (e.g., by integrating jUCMNav and Papyrus, with/without DOORS)

Relevant paper:

  • Amyot, D., Anda, A.A., Baslyman, M., Lessard, L., and Bruel, J.-M. (2016) Towards Improved Requirements Engineering with SysML and the User Requirements Notation. 24th IEEE Int. Requirements Engineering Conf. (RE’16), RE@Next track, Beijing, China, September. IEEE CS, 334-339

Priority: Business Process and Enterprise Architecture Modeling/Management

Business Process Modeling aims to answer common W5H questions (who, what, where, when, why, and how much). The User Requirements Notation (URN) is uniquely positioned here as a modeling language because, in addition to the usual “who/what/where/when” questions answered by many scenario-oriented languages (activity diagrams, BPMN, UCM, etc.), URN offers a goal-oriented view (GRL) that supports actors, goals, indicators and various relationships that enable models to answer “why” and “how much” questions.

Specific problem(s) of interest:

  • How can these concepts and languages be used (likely in combination with other languages) to support Enterprise Architecture modeling and analysis?
  • How can they help assess and maintain compliance?
  • Can they effectively be used to support adaptive systems?
  • How can we support the evolution and management of such systems?
  • How can tools be integrated or enhanced to support the above?

Relevant paper:

  • Pourshahid, A., Chen, P., Amyot, D., Forster, A.J., Ghanavati, S., Peyton, L., and Weiss, M. (2009) Business Process Management with the User Requirements Notation. Electronic Commerce Research, 9(4), Springer, December 2009, 269-316.


Nicolas Hili

Institution: School of Computing, Queen's University (http://cs.queensu.ca)

Priority: Flexibility

Related priorities: Incomplete Models, Collaboration

Metamodeling techniques increase validation through model conformance. However, they drastically decrease flexibility as user-defined metamodels have to be created first and each change to the metamodels questions the validity of existing models. Consequently, traditional model-driven approaches fail to address some issues, such as the availability, evolution, and multiplicity of metamodels as well as the prototyping of models. Whether introducing flexibility in MDE processes is efficiently addressed or not will ultimately depend on how they are realized by modeling frameworks and tools. Consequently, considerations have to be made about the implementation of such frameworks and tools. Particularly, design considerations of the internal representations of a model, given a programming language and a data serialization format, and their impact at both object- and meta-levels, should be cautiously made.

This priority is related to the "Incomplete Models" priority and to the recent interest of many Papyrus IC contributors and Eclipse Source members to see what it is possible to achieve with non-EMF technologies (web-based environments, structuration into JSON, ...). More often, EMF-based tools are criticized for their lack of flexibility and interactive features, which is the result of diverse non-optimal design decisions (modeling framework, programming language, data serialization format, graphical editor API, ...). As a result, it is difficult, as mentioned in the "Incomplete Models" priority, to bridge the gap between sketching tools (for descriptive modeling) and complete modeling environments (featuring validation, analysis, and code generation).

Some references for more detail:

  • Presentation at Ericsson Modeling Days 2016;
  • Hili, N. "A Metamodeling Framework for Promoting Flexibility and Creativity Over Strict Model Conformance".
    Proceedings of the 2nd Workshop on Flexible Model Driven Engineering, pp. 2-11, 2016, CEUR Workshops Modeling;
  • Hili, N., Laurillau, Y., Dupuy-Chessa, S., and Calvary, G. "Innovative Key Features for Mastering Model Complexity: Flexilab, a Multimodel Editor Illustrated on Task Modeling".
    Proceedings of the 7th ACM SIGCHI Symposium on Engineering Interactive Computing Systems, pp. 234-237, 2015, ACM


Specific problem(s) of interest:

  • Support of informal, semi-formal, formal modeling activities in a single environment (Related to the "Incomplete Models" priority);
  • Explore the various features embedded in interactive tools and see how they can be adapted in existing modeling environments. Specially, the different features can be explored:
    • Mapping between model elements and their representations; inter-representation mapping
    • Cooperation / collaboration between stakeholders (related to the "Collaboration" priority)
    • Model sharing (not simply through Git repository or by email): model repository ?
    • Model element edition (currently, mostly done using property menus)


Lionel Briand

Institution: SnT Centre, University of Luxembourg (http://www.svv.lu)

Our overall research is focused on enabling model testing of complex and untestable systems. The key idea of model testing is to frame testing on models rather than operational systems. We define the following main research priorities that relate to MDE tools and technologies and have to be realized to enable model testing:

Priority: Executable and testable models of the system and its environment

- Methodologies to build executable and testable models of systems and their environment

- Supporting heterogenous modeling, and defining interfaces between heterogeneous or third party components

- Facilities to define test oracles for model testing

- Supporting model execution

Priority: Modeling uncertainty and risk

- Modeling various forms of uncertainties

- Supporting model execution and defining test oracles in presence of uncertainty

- Supporting risk analysis of the testing results

Priority: Change impact analysis and regression testing

- Developing appropriate traceability links between model elements, test results and test oracles.

- Developing techniques to determine how model changes are propagated across traceability links.


Tanja Mayerhofer

Institution: TU Wien, Business Informatics Group (http://www.big.tuwien.ac.at)

Priority: Incomplete Models

Modelling is used for different purposes, such as analysis, design, code generation, testing, and documentation. Modelling activities can be classified as 1) descriptive, 2) prescriptive or 3) exploratory. In descriptive modelling, models are used as artifacts to represent and communicate amongst people. In prescriptive modelling, models are used as specifications or blueprints that are to be implemented, perhaps by code generation. In exploratory modelling, models are used as the name suggests, to explore the design space and support analysis. In this setting, a model may not be a finalized design, but rather an incomplete description, design or specification. However, most modelling tools, whether they are tools for analysis tools, simulation, execution or code generation, support only fully formed, complete models adhering to some meta-model. This runs contrary to the nature of exploratory modelling. Using a typical tool, a modeller is forced to specify many aspects of a model that are not essential, just to be able to perform some basic analysis, or to simulate a model. In order to improve the modelling workflow, incomplete or partial models, models that may not fulfill all the requirements of a meta-model, needs to be supported by modelling tools.


Federico Ciccozzi

Institution: Mälardalen University (Sweden)

General interests:DSMLs, UML profiles, model transformation, code generation, HOTs, model versioning and (co)evolution, multi-view modelling, horizontal and vertical explicit traceability and consistency, modelling uncertainty and variability, textual modelling

Research priorities: - ALF and UML models execution: support for action language in combination with UML structural models (+ profiles) is pivotal for model reusability, model debugging, consistency-by-construction, to mention a few. Moreover, ways to execute models adhering to execution semantics specifically defined for the modelling languages themselves, rather than intermediate 3GLs (C++, Java) is crucial. More effort should be dedicated to interpretive and compilative approaches, by-passing 3GLs. - Hybrid textual/graphical modelling: support for both textual and graphical modelling in combination is crucial for maximising productivity and tear down the barriers set by overcomplex graphical diagrams for specific modelling aspects, such as behaviours. More effort should be dedicated to seamless textual and graphical modelling for arbitrary UML profiles. Automation mechanisms - Multi-view modelling: support for the seamless definition, customisation and synchronisation of well-defined views actively separating model concerns is pivotal for providing malleable perspectives through which complex and heterogeneous systems can be specified, by ensuring consistency-by-construction.

Ongoing activities: - ALF and models execution: systematic review on existing solutions; 2 national project proposals (1 to be submitted, 1 under review) - Hybrid textual/graphical modelling: EUREKA network project with Zeligsoft (Canada, leader), EclipseSource (Austria), Arcticus Systems (Sweden), Ericsson (Sweden); 1 ITEA3 project proposal with 12 partners from 3 countries - Multi-view modelling: systematic mapping on existing solutions; 1 national project proposal to be submitted

Jordi Cabot

Institution: ICREA - UOC . [SOM Research team] http://som-research.uoc.edu/

Priority: Quality Assessment of models

The quality assessment of software models is still an open challenge. Most of the time, modeling tools just check basic consistency rules. This is enough to make sure the model is a valid instantiation of its metamodel but not enough to make sure the model is correct (e.g. satisfiable, non-redundant, ...)

Specific problem(s) of interest:

- Identify specific quality concerns and challenges Papyrus partners have when modeling

- Identify possible solutions adapted to their problems (and the kind of models they are interested in verifying)

- Develop the techniques required to do so (mostly using a lightweight formal methods philosophy to get good enough models with a reasonable effort).

Objective: Build a usable Quality Assessment tool for Papyrus


Priority: Collaboration

Software / Systems development requires more and more the collaboration of a diverse team of people. Appropriate support for collaboration of heterogeneous people must go beyond conflict resolution / synchronization approaches.

Specific problem(s) of interest:

- Build a view mechanism that allows combining heterogeneous models to show to each stakeholder the info they need. This effort could take (or learn from) EMF Views as starting point.

- Add rationale and argumentation capabilities to the collaboration process so that any design decision can be traced back to the discussion that originated that specific change.


Objective: Build a collaborative environment to share, discuss and build models in a distributed team


Priority: Sustainability of open source projects

Many open source projects stagnate after an initial push and end up fading away due to the project's inability to attract and support a healthy community around. See this presentation for more details: [Presentation at Ericsson Modeling Days 2016] http://www.slideshare.net/jcabot/wanna-see-your-open-source-project-succeed-nurture-your-community

Specific problem(s) of interest:

- Propose and evaluate strategies to facilitate the onboarding (and retention) of new contributors (again, not only at the code level, it could be to improve the documentation or any other action valuable for the Papyrus community at large).

- Discuss and make explicit a governance model for Papyrus (not only describing the rules to become committer but rules regarding all kinds of community interactions)

- Develop automatic analysis techniques to extract useful information about the Papyrus community based on the mining of user interactions on the repository, on Bugzilla or on the forums. Examples would be to identify experts in specific areas, to detect subcommunities that should communicate with each other, areas with a low bus factor,...

- Provide analysis tools implementing the above points to help the SC to evaluate (and take action on) the community behind Papyrus.

Objective: Contribute to ensure the long-term sustainability of Papyrus

Priority: Scalability

Make sure Papyrus works well with very large models

Specific problem(s) of interest:

- Explore NoSQL databases to speed up the storage and retrieval of (parts of) large models - Add prefetching and caching techniques to Papyrus

Juergen Dingel

Institution/Organization

School of Computing, Queen's University, Kingston, Canada

General research area(s)

Static, dynamic, and formal analysis of models of embedded real-time systems, typically in the form of communicating state machines expressed in UML-RT or UML

Detailed information

* Symbolic execution for, e.g., test case generation or finding unreachable states, infeasible transitions and guards, etc
* State space exploration (a.k.a., model checking) for checking requirements given in the form of temporal logic
* Run-time monitoring and verification for checking timing constraints
* Animation of model execution
* Development guidelines, smells,and (anti-)patterns in models of embedded systems

Context/motivation

The support that current MDE tools (commercial and non-commercial) offer for model analysis is lagging behind the capabilities of analysis tools available for source code:
1. Analyses that the models contain sufficient information for (e.g., many forms of control flow, data flow, or message flow analysis) are either not offered at all, or a source code analyzer needs to be used on source code generated from the models, which means that the abstraction embedded in the model is lost and that both the user and the analysis are exposed to the lower-level detail introduced by the code generation.
2. Analyses that require the generated code (e.g., analyses that determine resource usage such as checking of timing or memory constraints) are not integrated into MDE tools at all, meaning that, e.g., they cannot be set up and run from the MDE tool and any analysis results produced cannot easily be displayed on the model level (such as execution traces leading to the violation of a timing constraint) or integrated into the model (such as minimal and maximal timing delays between two events observed on a set of executions).

Specific problem(s) of interest

* Better support for model-level analyses such as various forms of static analysis, symbolic execution (e.g., for test case generation), and state space exploration (a.k.a., model checking), directly on the model and not the generated code
* Better, more seamless integration of analyses that need to be performed on the generated code such as (1) validation of timing constraints, (2) runtime monitoring and verification, and (3) extraction and incorporation of relevant runtime information into the model
* Better support for observing and interacting with model executions via a model-based observer architecture that allows, e.g., different external components and tools to monitor executions with respect to different events and to influence model executions in different, but well-controlled ways
* Better support for model-level debugging through (1) full support of action code, (2) display of debug information in terms of the model and in context of the MDE tool, and (3) direct support for relevant model elements and features such as message passing, ports, states, and transitions
* Better support for analyses of models of distributed systems

Objective(s)

* Modelers should get more 'return on investment' on their models through the support of a wide range of analyses that allow them to debug their models, check requirements, evaluate design decisions
* Analyses and debugging should leverage the semantics and the higher level of abstraction of models and avoid having to rely on code generation as much as possible; exposing generated code to the modeler should be avoided whenever possible
* MDE tools should offer usable, fully integrated model analysis and debugging capabilities that are as powerful and effective as those offered by currently available source code tools
* Model analysis tools should allow the analysis of industrial models in terms of size and features (e.g., distributed communication)

Potential interested parties

* Everybody developing systems using communicating state machines
* Everybody using or interested in using PapyrusRT

Philip Langer

Institution: EclipseSource Services GmbH, Vienna, Austria (http://eclipsesource.com/vienna)

General research area(s) Automated / model-based modeling tool development, collaborative modeling (diff/merge)

Priority: Multi-notation / multi-view model diff merge (model versioning)

Currently, there is a gap between how users interact with and change models using their customized modeling editors, and how model versioning tools handle and represent the applied changes. Whereas users are only familiar with their customized modeling editors that use dedicated representations and hide the complexity of the underlying model, the model versioning tools are only capable of processing the underlying raw models without taking those customizations of modeling editors and different representations of models into account. This gap significantly impedes the understandability of changes and the usage of existing model versioning tools. Unfortunately, neither industrial nor open-source model versioning tools efficiently support such customized modeling tools that employ extended modeling languages, enhanced editors for a specific domain, and the diverse representations dedicated to different user types.

Specific problem(s) of interest:

  • Customizable domain-specific model versioning
  • Diagram-centric model versioning
  • Multi-representation (textual, graphical, ...) model versioning

Relevant paper:

  • Brosch, P., G. Kappel, P. Langer, M. Seidl, K. Wieland, and M. Wimmer. "An introduction to model versioning." In Formal Methods for Model-Driven Engineering, pp. 336-398. Springer Berlin Heidelberg, 2012.
  • Langer, P. and M. Koegel. "Integrating Open-Source Modeling Projects at the Example of Collaborative Modeling with Papyrus and EMF Compare" OSS4MDE @ MoDELS. 2015.
  • Taentzer, G., C. Ermel, P. Langer, M. Wimmer. "A fundamental approach to model versioning based on graph modifications: from theory to implementation". In the Journal of Software and Systems Modeling, 13 (1), 239 – 272, 2014.

Priority: Combining textual and graphical modeling

Users should be free to choose their preferred way of editing models, either textual or graphical in diagrams, or in tree-based editors. However, combining different representations (syntaxes) of the same model is challenging. The intrinsic formatting (implicit order and whitespace for textual representations, layout for graphical, etc.) has to be preserved and users should be able to switch back and forth between different representations.

Specific problem(s) of interest:

  • How to enable the definition of different representations of the same model?
  • How to keep formatting among different representations?
  • How to keep the semantic model in-sync when edited in different representations?

Back to the top