Conferences

I have attended the following conferences and co-located workshops:

Workshops

I have attended the following workshops:

Community Service

I have been  on the Program Committee for the following conferences/workshops:

Teaching

I have been a Course Lecturer for the following courses at McGill University:

I have been a Teaching Assistant for the following courses at McGill University:

Awards

I have received the following awards during my studies (M.Sc. and Ph.D.):

  • Baden-Württemberg Stipendium (2012)
  • Differential Fee Waiver Award (2013)
  • McGill School of Computer Science Graduate Excellence Award (2013)
  • McGill School of Computer Science Graduate Excellence Award (2015)

Latest Publications

  • Matthias Schöttle and Jörg Kienzle. On the Difficulties of Raising the Level of Abstraction and Facilitating Reuse in Software Modelling: The Case for Signature Extension. In Proceedings of the 11th international workshop on modelling in software engineering, MiSE ’19, page 71–77, Piscataway, NJ, USA, 2019. Ieee press.
    [BibTeX] [Abstract] [DOI] [Download PDF]

    Reuse is central to improving the software development process, increasing software quality and decreasing time-to-market. Hence it is of paramount importance that modelling languages provide features that enable the specification and modularization of reusable artefacts, as well as their subsequent reuse. In this paper we outline several difficulties caused by the finality of method signatures that make it hard to specify and use reusable artefacts encapsulating several variants. The difficulties are illustrated with a running example. To evaluate whether these difficulties can be observed at the programming level, we report on an empirical study conducted on the Java Platform API as well as present workarounds used in various programming languages to deal with the rigid nature of signatures. Finally, we outline signature extension as an approach to overcome these problems at the modelling level.

    @InProceedings{MiSE/Schoettle2019,
author = {Matthias Sch{\"{o}}ttle and J{\"{o}}rg Kienzle},
title = {{On the Difficulties of Raising the Level of Abstraction and Facilitating Reuse in Software Modelling: The Case for Signature Extension}},
booktitle = {Proceedings of the 11th International Workshop on Modelling in Software Engineering},
year = {2019},
series = {MiSE '19},
pages = {71--77},
address = {Piscataway, NJ, USA},
publisher = {IEEE Press},
abstract = {Reuse is central to improving the software development process, increasing software quality and decreasing time-to-market. Hence it is of paramount importance that modelling languages provide features that enable the specification and modularization of reusable artefacts, as well as their subsequent reuse. In this paper we outline several difficulties caused by the finality of method signatures that make it hard to specify and use reusable artefacts encapsulating several variants. The difficulties are illustrated with a running example. To evaluate whether these difficulties can be observed at the programming level, we report on an empirical study conducted on the Java Platform API as well as present workarounds used in various programming languages to deal with the rigid nature of signatures. Finally, we outline signature extension as an approach to overcome these problems at the modelling level.},
doi = {10.1109/MiSE.2019.00018}
}
  • Matthias Schöttle. Model-Based Reuse of Framework APIs: Bridging the Gap Between Models and Code. PhD thesis, School of Computer Science, McGill University, 2019.
    [BibTeX] [Abstract] [Download PDF] [Download Slides]

    Reuse is considered key to software engineering and is very common at the implementation level. Many reusable libraries and frameworks exist and are widely reused. However, in the context of Model-Driven Engineering (MDE) reuse is not very common. Most modelling approaches do not support reuse, requiring a user to start their modelling activity either from scratch or copy and paste pieces from other models. This thesis provides a bridge for reusable units between implementation and modelling. We apply the principles of Concern-Oriented Reuse (CORE), a next-generation reuse technology, to lift existing frameworks up from the programming level to the modelling level. The level of abstraction of the API of existing frameworks is raised to the modelling level to facilitate their reuse within design models that are integrated within an MDE process. In addition, the benefits of the higher level of abstraction are exploited to formalize otherwise informally provided information, such as which features the framework provides, the impact of each feature on high-level goals and non-functional qualities, how to adapt the framework to the reuse context, and how the API of each feature is to be used. This thesis defines an automated algorithm that analyses the code of a framework and example code that uses the framework to produce an interface that 1) lists the user-perceivable features of the framework organized in a feature model, and 2) modularizes the API of the framework API according to each feature. The algorithm is implemented and validated on two small frameworks and the Android Notifications API along with an empirical user study. To smoothen the transition from a high-level abstraction to a low level of abstraction, i.e., from models to code, this thesis addresses the difficulty caused by the finality of signatures. We identify and discuss four difficult situations for defining high-level interfaces at the modelling level, and present evidence that shows that these situations also exist at the implementation level. The signature extension approach is introduced to CORE allowing interfaces to encompass diverse implementation variants and to be evolved at a fine level of granularity across groups of features. We re-design two reusable concerns to show that the approach addresses the four difficult situations.

    @PhdThesis{PhDThesis_Schoettle2019,
author = {Sch\"{o}ttle, Matthias},
title = {{Model-Based Reuse of Framework APIs: Bridging the Gap Between Models and Code}},
school = {School of Computer Science, McGill University},
year = {2019},
abstract = {Reuse is considered key to software engineering and is very common at the implementation level. Many reusable libraries and frameworks exist and are widely reused. However, in the context of Model-Driven Engineering (MDE) reuse is not very common. Most modelling approaches do not support reuse, requiring a user to start their modelling activity either from scratch or copy and paste pieces from other models.
This thesis provides a bridge for reusable units between implementation and modelling. We apply the principles of Concern-Oriented Reuse (CORE), a next-generation reuse technology, to lift existing frameworks up from the programming level to the modelling level. The level of abstraction of the API of existing frameworks is raised to the modelling level to facilitate their reuse within design models that are integrated within an MDE process. In addition, the benefits of the higher level of abstraction are exploited to formalize otherwise informally provided information, such as which features the framework provides, the impact of each feature on high-level goals and non-functional qualities, how to adapt the framework to the reuse context, and how the API of each feature is to be used. This thesis defines an automated algorithm that analyses the code of a framework and example code that uses the framework to produce an interface that 1) lists the user-perceivable features of the framework organized in a feature model, and 2) modularizes the API of the framework API according to each feature. The algorithm is implemented and validated on two small frameworks and the Android Notifications API along with an empirical user study.
To smoothen the transition from a high-level abstraction to a low level of abstraction, i.e., from models to code, this thesis addresses the difficulty caused by the finality of signatures. We identify and discuss four difficult situations for defining high-level interfaces at the modelling level, and present evidence that shows that these situations also exist at the implementation level. The signature extension approach is introduced to CORE allowing interfaces to encompass diverse implementation variants and to be evolved at a fine level of granularity across groups of features. We re-design two reusable concerns to show that the approach addresses the four difficult situations.}
}
  • Benoit Combemale, Jörg Kienzle, Gunter Mussbacher, Olivier Barais, Erwan Bousse, Walter Cazzola, Philippe Collet, Thomas Degueule, Robert Heinrich, Jean-Marc Jézéquel, Manuel Leduc, Tanja Mayerhofer, Sébastien Mosser, Matthias Schöttle, Misha Strittmatter, and Andreas Wortmann. Concern-Oriented Language Development (COLD): Fostering Reuse in Language Engineering. Computer Languages, Systems & Structures, 2018.
    [BibTeX] [Abstract] [DOI] [Download PDF]

    Domain-Specific Languages (DSLs) bridge the gap between the problem space, in which stakeholders work, and the solution space, i.e., the concrete artifacts defining the target system. They are usually small and intuitive languages whose concepts and expressiveness fit a particular domain. DSLs recently found their application in an increasingly broad range of domains, e.g., cyber-physical systems, computational sciences and high-performance computing. Despite recent advances, the development of DSLs is error-prone and requires substantial engineering efforts. Techniques to reuse from one DSL to another and to support customization to meet new requirements are thus particularly welcomed. Over the last decade, the Software Language Engineering (SLE) community has proposed various reuse techniques. However, all these techniques remain disparate and complicate the development of real-world DSLs involving different reuse scenarios. In this paper, we introduce the Concern-Oriented Language Development (COLD) approach, a new language development model that promotes modularity and reusability of language concerns. A language concern is a reusable piece of language that consists of usual language artifacts (e.g., abstract syntax, concrete syntax, semantics) and exhibits three specific interfaces that support (1) variability management, (2) customization to a specific context, and (3) proper usage of the reused artifact. The approach is supported by a conceptual model which introduces the required concepts to implement COLD. We also present concrete examples of some language concerns and the current state of their realization with metamodel-based and grammar-based language workbenches. We expect this work to provide insights into how to foster reuse in language specification and implementation, and how to support it in language workbenches.

    @Article{COMLAN/Combemale2018,
author = {Benoit Combemale and Jörg Kienzle and Gunter Mussbacher and Olivier Barais and Erwan Bousse and Walter Cazzola and Philippe Collet and Thomas Degueule and Robert Heinrich and Jean-Marc Jézéquel and Manuel Leduc and Tanja Mayerhofer and Sébastien Mosser and Matthias Schöttle and Misha Strittmatter and Andreas Wortmann},
title = {{Concern-Oriented Language Development (COLD): Fostering Reuse in Language Engineering}},
journal = {{Computer Languages, Systems \& Structures}},
year = {2018},
abstract = {Domain-Specific Languages (DSLs) bridge the gap between the problem space, in which stakeholders work, and the solution space, i.e., the concrete artifacts defining the target system. They are usually small and intuitive languages whose concepts and expressiveness fit a particular domain. DSLs recently found their application in an increasingly broad range of domains, e.g., cyber-physical systems, computational sciences and high-performance computing. Despite recent advances, the development of DSLs is error-prone and requires substantial engineering efforts. Techniques to reuse from one DSL to another and to support customization to meet new requirements are thus particularly welcomed. Over the last decade, the Software Language Engineering (SLE) community has proposed various reuse techniques.
However, all these techniques remain disparate and complicate the development of real-world DSLs involving different reuse scenarios.
In this paper, we introduce the Concern-Oriented Language Development (COLD) approach, a new language development model that promotes modularity and reusability of language concerns. A language concern is a reusable piece of language that consists of usual language artifacts (e.g., abstract syntax, concrete syntax, semantics) and exhibits three specific interfaces that support (1) variability management, (2) customization to a specific context, and (3) proper usage of the reused artifact. The approach is supported by a conceptual model which introduces the required concepts to implement COLD. We also present concrete examples of some language concerns and the current state of their realization with metamodel-based and grammar-based language workbenches. We expect this work to provide insights into how to foster reuse in language specification and implementation, and how to support it in language workbenches.},
doi = {10.1016/j.cl.2018.05.004},
issn = {1477-8424},
keywords = {domain-specific languages},
url = {https://www.sciencedirect.com/science/article/pii/S1477842418300496}
}

[View All Publications]