Systematic literature review of the objectives, techniques, kinds, and architectures of models at runtime

In the context of software development, models provide an abstract representation of a software system or a part of it. In the software development process, they are primarily used for documentation and communication purposes in analysis, design, and implementation activities. Model-Driven Engineering (MDE) further increases the importance of models, as in MDE models are not only used for documentation and communication, but as central artefacts of the software development process. Various recent research approaches take the idea of using models as central artefacts one step further by using models at runtime to cope with dynamic aspects of ever-changing software and its environment. In this article, we analyze the usage of models at runtime in the existing research literature using the Systematic Literature Review (SLR) research method. The main goals of our SLR are building a common classification and surveying the existing approaches in terms of objectives, techniques, architectures, and kinds of models used in these approaches. The contribution of this article is to provide an overview and classification of current research approaches using models at runtime and to identify research areas not covered by models at runtime so far.

[1]  Svein O. Hallsteinsen,et al.  Using product line techniques to build adaptive systems , 2006, 10th International Software Product Line Conference (SPLC'06).

[2]  Premkumar T. Devanbu,et al.  Instant multi-tier web applications without tears , 2009, ISEC '09.

[3]  Heather Goldsby,et al.  Goal-Based Modeling of Dynamically Adaptive System Requirements , 2008, 15th Annual IEEE International Conference and Workshop on the Engineering of Computer Based Systems (ecbs 2008).

[4]  Franco Zambonelli,et al.  A survey of autonomic communications , 2006, TAAS.

[5]  Manuel Wimmer,et al.  Towards xMOF: executable DSMLs based on fUML , 2012, DSM '12.

[6]  Xuanzhe Liu,et al.  Model-Based Management of Service Composition , 2013, 2013 IEEE Seventh International Symposium on Service-Oriented System Engineering.

[7]  Carlo Ghezzi,et al.  Rethinking the Use of Models in Software Architecture , 2008, QoSA.

[8]  Klaus D. Müller-Glaser,et al.  A Graphical Model-Level Debugger for Heterogenous Reconfigurable Architectures , 2007, 2007 International Conference on Field Programmable Logic and Applications.

[9]  Kurt Geihs,et al.  Architectural Constraints in the Model-Driven Development of Self-Adaptive Applications , 2008, IEEE Distributed Systems Online.

[10]  Yérom-David Bromberg,et al.  OverStar: An Open Approach to End-to-End Middleware Services in Systems of Systems , 2012, Middleware.

[11]  Hui Song,et al.  Generating synchronization engines between running systems and their model-based views , 2009, MODELS'09.

[12]  Mahdi Derakhshanmanesh,et al.  Achieving dynamic adaptation via management and interpretation of runtime models , 2012, J. Syst. Softw..

[13]  Jan Bosch,et al.  Runtime variability for dynamic reconfiguration in wireless sensor network product lines , 2012, SPLC '12.

[14]  Ta'id Holmes From Business Application Execution to Design Through Model-Based Reporting , 2012, 2012 IEEE 16th International Enterprise Distributed Object Computing Conference.

[15]  Kumar Bhaskaran,et al.  Model-driven business performance management , 2005, IEEE International Conference on e-Business Engineering (ICEBE'05).

[16]  Jörg Pleumann,et al.  A Model-Driven Runtime Environment for Web Applications , 2003, UML.

[17]  Sahin Albayrak,et al.  Executable Models for Human-Computer Interaction , 2008, DSV-IS.

[18]  Brice Morin,et al.  An eclipse modelling framework alternative to meet the models@runtime requirements , 2012, MODELS'12.

[19]  Mahdi Derakhshanmanesh,et al.  GRAF: graph-based runtime adaptation framework , 2011, SEAMS '11.

[20]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture Volume 1: A System of Patterns , 1996 .

[21]  Carlo Ghezzi,et al.  Model evolution by run-time parameter adaptation , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[22]  Sophie Dupuy-Chessa,et al.  UsiComp: an extensible model-driven composer , 2012, EICS '12.

[23]  Jean-Sébastien Sottet,et al.  An MDE-SOA Approach to Support Plastic User Interfaces in Ambient Spaces , 2007, HCI.

[24]  Mahdi Derakhshanmanesh,et al.  Software Evolution towards Model-Centric Runtime Adaptivity , 2011, 2011 15th European Conference on Software Maintenance and Reengineering.

[25]  John A. Zinky,et al.  Runtime Performance Modeling and Measurement of Adaptive Distributed Object Applications , 2002, OTM.

[26]  Brice Morin,et al.  A dynamic component model for cyber physical systems , 2012, CBSE '12.

[27]  Philippe Lalanda,et al.  Autonomic management of multimodal interaction: DynaMo in action , 2012, EICS '12.

[28]  Philippe Collet,et al.  Actor-based runtime model of adaptable feedback control loops , 2012, MRT '12.

[29]  Douglas C. Schmidt,et al.  Guest Editor's Introduction: Model-Driven Engineering , 2006, Computer.

[30]  David Garlan,et al.  Using Gauges for Architecture-Based Monitoring and Adaptation , 2001 .

[31]  Bradley R. Schmerl,et al.  Software Architecture-Based Adaptation for Pervasive Systems , 2002, ARCS.

[32]  Gul Agha,et al.  Polus: a self-evolving model-based approach for automating the observe-analyze-act loop , 2005 .

[33]  James C. Lester,et al.  Diagnosing Self-efficacy in Intelligent Tutoring Systems: An Empirical Study , 2006, Intelligent Tutoring Systems.

[34]  Chantal Taconet,et al.  CA3M: A Runtime Model and a Middleware for Dynamic Context Management , 2009, OTM Conferences.

[35]  Jochen Ludewig,et al.  Models in software engineering – an introduction , 2003, Software and Systems Modeling.

[36]  Jean-Marc Jézéquel,et al.  Making Components Contract Aware , 1999, Computer.

[37]  Nelly Bencomo,et al.  RELAX: Incorporating Uncertainty into the Specification of Self-Adaptive Systems , 2009, 2009 17th IEEE International Requirements Engineering Conference.

[38]  Brice Morin,et al.  Report on the 7th international workshop on models@run.time , 2013, SOEN.

[39]  Oscar Nierstrasz,et al.  Model-Centric, Context-Aware Software Adaptation , 2009, Software Engineering for Self-Adaptive Systems.

[40]  Klaus D. Müller-Glaser,et al.  Dynamic Mapping of Runtime Information Models for Debugging Embedded Software , 2006, Seventeenth IEEE International Workshop on Rapid System Prototyping (RSP'06).

[41]  S. Neema,et al.  Model Predictive Analysis for AutonomicWorkflow Management in Large-scale Scientific Computing Environments , 2007, Fourth IEEE International Workshop on Engineering of Autonomic and Autonomous Systems (EASe'07).

[42]  Holger Giese,et al.  Incremental model synchronization with triple graph grammars , 2006, MoDELS'06.

[43]  Jørgen Staunstrup Design Specification and Verification , 1997 .

[44]  Gordon S. Blair,et al.  Engineering complex adaptations in highly heterogeneous distributed systems , 2008, Autonomics.

[45]  Gilles Vanwormhoudt,et al.  Dynamic and generic manipulation of models: from introspection to scripting , 2006, MoDELS'06.

[46]  Svein O. Hallsteinsen,et al.  Model-driven development of self-adaptive applications for mobile devices: (research summary) , 2006, SEAMS '06.

[47]  David Garlan,et al.  Rainbow: architecture-based self-adaptation with reusable infrastructure , 2004 .

[48]  Kang G. Shin,et al.  Multi-view modeling and analysis of embedded real-time software with meta-modeling and model transformation , 2004, Eighth IEEE International Symposium on High Assurance Systems Engineering, 2004. Proceedings..

[49]  Gerti Kappel,et al.  Leveraging Model-Based Tool Integration by Conceptual Modeling Techniques , 2008, The Evolution of Conceptual Modeling.

[50]  Carlo Ghezzi,et al.  Predicting Performance Properties for Open Systems with KAMI , 2009, QoSA.

[51]  Gerti Kappel,et al.  Debugging Model-to-Model Transformations , 2012, 2012 19th Asia-Pacific Software Engineering Conference.

[52]  Thomas Vogel,et al.  Incremental model synchronization for efficient run-time monitoring , 2009, MODELS'09.

[53]  Philippe Merle,et al.  Applying OMG D&C specification and ECA rules for autonomous distributed component-based systems , 2006, MoDELS'06.

[54]  Franck Barbier,et al.  Proved Metamodels as Backbone for Software Adaptation , 2010, 2010 IEEE 12th International Symposium on High Assurance Systems Engineering.

[55]  Jozef Hooman,et al.  Model-Based Run-Time Error Detection , 2007, MoDELS Workshops.

[56]  Benoit Baudry,et al.  Toward a model-driven access-control enforcement mechanism for pervasive systems , 2012, MDsec '12.

[57]  Markus Herrmannsdoerfer,et al.  Model-Level Debugging of Embedded Real-Time Systems , 2010, 2010 10th IEEE International Conference on Computer and Information Technology.

[58]  Hui Song,et al.  SM@RT: towards architecture-based runtime management of Internetware systems , 2009, Internetware.

[59]  Holger Giese,et al.  From model transformation to incremental bidirectional model synchronization , 2009, Software & Systems Modeling.

[60]  Gordon S. Blair,et al.  4th international workshop on models@run.time , 2009, MODELS'09.

[61]  Franck Barbier,et al.  Model execution adaptation? , 2012, MRT '12.

[62]  Lei Feng,et al.  Towards Model-Based Engineering of Self-configuring Embedded Systems , 2007, Model-Based Engineering of Embedded Real-Time Systems.

[63]  Marcello La Rosa,et al.  From Collaboration Models to BPEL Processes Through Service Models , 2005, Business Process Management Workshops.

[64]  Valérie Issarny,et al.  Dynamic decision networks for decision-making in self-adaptive systems: A case study , 2013, 2013 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS).

[65]  Yijun Yu,et al.  Run-Time Security Traceability for Evolving Systems , 2010, Comput. J..

[66]  Riccardo Bettati,et al.  Efficient calibration of thermal models based on application behavior , 2009, 2009 IEEE International Conference on Computer Design.

[67]  Insup Lee,et al.  Model-based testing and monitoring for hybrid embedded systems , 2004, Proceedings of the 2004 IEEE International Conference on Information Reuse and Integration, 2004. IRI 2004..

[68]  Hui Song,et al.  Instant and incremental QVT transformation for runtime models , 2011, MODELS'11.

[69]  Vicente Pelechano,et al.  Applying Software Product Lines to Build Autonomic Pervasive Systems , 2008, 2008 12th International Software Product Line Conference.

[70]  Vicente Pelechano,et al.  Using Variability Models for Developing Self-conguring Pervasive Systems , 2008 .

[71]  Gunter Saake,et al.  Software Evolution through Dynamic Adaptation of Its OO Desgin , 2003, Objects, Agents, and Features.

[72]  Klaus Marius Hansen,et al.  A Declarative Approach to Architectural Reflection , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[73]  Alessandro Orso,et al.  AMNESIA: analysis and monitoring for NEutralizing SQL-injection attacks , 2005, ASE.

[74]  Wouter Joosen,et al.  The case for aspect-oriented reflective middleware , 2007, ARM '07.

[75]  John Murphy,et al.  Performance management in component-oriented systems using a Model Driven Architecture/spl trade/ approach , 2002, Proceedings. Sixth International Enterprise Distributed Object Computing.

[76]  Sahin Albayrak,et al.  Multimodal user interfaces for smart environments: the multi-access service platform , 2008, AVI '08.

[77]  Thomas Vogel,et al.  The Role of Models and Megamodels at Runtime , 2010, MoDELS.

[78]  Roland H. Kaschek,et al.  On the evolution of conceptual modeling , 2008, The Evolution of Conceptual Modeling.

[79]  Christian Kreiner,et al.  Interpreting Model-Based Components for Information Systems , 2009, 2009 16th Annual IEEE International Conference and Workshop on the Engineering of Computer Based Systems.

[80]  Nelly Bencomo,et al.  Requirements-Aware Systems: A Research Agenda for RE for Self-adaptive Systems , 2010, 2010 18th IEEE International Requirements Engineering Conference.

[81]  Mario Trapp,et al.  Runtime Safety Models in Open Systems of Systems , 2009, 2009 Eighth IEEE International Conference on Dependable, Autonomic and Secure Computing.

[82]  Brice Morin,et al.  An Aspect-Oriented and Model-Driven Approach for Managing Dynamic Variability , 2008, MoDELS.

[83]  Shahar Maoz,et al.  Using Model-Based Traces as Runtime Models , 2009, Computer.

[84]  David B. Knoester,et al.  Digital Evolution of Behavioral Models for Autonomic Systems , 2008, 2008 International Conference on Autonomic Computing.

[85]  G.S. Blair,et al.  Integrating meta-information management and reflection in middleware , 2000, Proceedings DOA'00. International Symposium on Distributed Objects and Applications.

[86]  Gordon S. Blair,et al.  Models@ run.time , 2009, Computer.

[87]  Peter J. Clarke,et al.  Towards Adaptable Middleware to Support Service Delivery Validation in i-DSML Execution Engines , 2012, 2012 IEEE 14th International Symposium on High-Assurance Systems Engineering.

[88]  Brice Morin,et al.  Security-driven model-based dynamic adaptation , 2010, ASE '10.

[89]  Sahin Albayrak,et al.  Meta-Modeling Runtime Models , 2010, Models@run.time.

[90]  Jean-Sébastien Sottet,et al.  Ingénierie dirigée par les modèles pour la plasticité des interfaces homme machine , 2007, IHM '07.

[91]  Andrea Mocci,et al.  Detecting component changes at run time with behavior models , 2012, Computing.

[92]  Takeo Kanade,et al.  Models in Software Engineering , 2011, Lecture Notes in Computer Science.

[93]  Christian Schlegel,et al.  Model-driven engineering and run-time model-usage in service robotics , 2011, GPCE '11.

[94]  Jasminka Matevska,et al.  Model-based runtime reconfiguration of component-based systems , 2009 .

[95]  Marin Litoiu,et al.  Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems , 2013, ICSE 2013.

[96]  Lidia Fuentes,et al.  Autonomic Computing Driven by Feature Models and Architecture in FamiWare , 2011, ECSA.

[97]  Peter J. Clarke,et al.  Model-driven development of DSML execution engines , 2012, MRT '12.

[98]  Christian Kreiner,et al.  Applying Multi-model Based Components for Virtual Organizations , 2011, 2011 19th International Euromicro Conference on Parallel, Distributed and Network-Based Processing.

[99]  A. Krasnogolowy,et al.  Flexible debugging of behavior models , 2012, 2012 IEEE International Conference on Industrial Technology.

[100]  Nelly Bencomo,et al.  Requirements reflection: requirements as runtime entities , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[101]  Gordon S. Blair,et al.  A reflective framework for discovery and interaction in heterogeneous mobile environments , 2005, MOCO.

[102]  Olivier Barais,et al.  A process for continuous validation of self-adapting component based systems , 2012, MRT '12.

[103]  Vicente Pelechano,et al.  Dynamic evolution of context-aware systems with models at runtime , 2012, MODELS'12.

[104]  Samuel Kounev,et al.  Modeling dynamic virtualized resource landscapes , 2012, QoSA '12.

[105]  Peter Sawyer,et al.  Managing Testing Complexity in Dynamically Adaptive Systems: A Model-Driven Approach , 2010, 2010 Third International Conference on Software Testing, Verification, and Validation Workshops.

[106]  Valérie Issarny,et al.  Satisfying requirements for pervasive service compositions , 2012, MRT '12.

[107]  Tushar Sharma,et al.  Quality Model Driven Dynamic Analysis , 2011, 2011 IEEE 35th Annual Computer Software and Applications Conference.

[108]  Tony Gjerlufsen,et al.  Mirrors of meaning: supporting inspectable runtime models , 2009, Computer.

[109]  Heather Goldsby,et al.  AMOEBA-RT: Run-Time Verification of Adaptive Software , 2008, MoDELS.

[110]  Sebastian Feuerstack,et al.  Model-based design and generation of a gesture-based user interface navigation control , 2011, IHC+CLIHC.

[111]  Vicente Pelechano,et al.  Supporting Runtime System Evolution to Adapt to User Behaviour , 2010, CAiSE.

[112]  Frank Barbier,et al.  A Framework for Statechart Based Component Reconfiguration , 2008, Fifth IEEE Workshop on Engineering of Autonomic and Autonomous Systems (ease 2008).

[113]  Pearl Brereton,et al.  Empirical evidence about the UML: a systematic literature review , 2011, Softw. Pract. Exp..

[114]  Svein O. Hallsteinsen,et al.  Using a Patterns-Based Modelling Language and a Model-Based Adaptation Architecture to Facilitate Adaptive User Interfaces , 2006, DSV-IS.

[115]  Jan-Torsten Milde,et al.  Configurable Executable Task Models Supporting the Transition from Design Time to Runtime , 2011, HCI.

[116]  Gordon S. Blair,et al.  The Design and Implementation of OpenORB v2 , 2001 .

[117]  Roy Kalawsky,et al.  System modelling for run-time verification and validation of autonomous systems , 2010, 2010 5th International Conference on System of Systems Engineering.

[118]  Mark Strembeck,et al.  Modeling process-related RBAC models with extended UML activity models , 2011, Inf. Softw. Technol..

[119]  Anand Raghunathan,et al.  MDR: performance model driven runtime for heterogeneous parallel platforms , 2011, ICS '11.

[120]  Sahin Albayrak,et al.  Adjustable context adaptations for user interfaces at runtime , 2010, AVI.

[121]  Frank Eliassen,et al.  Using architecture models for runtime adaptability , 2006, IEEE Software.

[122]  Hui Song,et al.  Inferring meta-models for runtime system data from the clients of management APIs , 2010, MODELS'10.

[123]  M. Hagberg Editorial , 2004 .

[124]  Birgit Bomsdorf,et al.  Finalizing Dialog Models at Runtime , 2007, ICWE.

[125]  Holger Giese,et al.  Incremental model synchronization for multiple updates , 2008, GRaMoT '08.

[126]  Mark Strembeck,et al.  An integrated approach for identity and access management in a SOA context , 2011, SACMAT '11.

[127]  Frank Eliassen,et al.  MADAM: towards a flexible planning-based middleware , 2006, SEAMS '06.

[128]  Peter G. Harrison,et al.  A class of tractable models for run-time performance evaluation , 2012, ICPE '12.

[129]  Fabrice Kordon Guest Editor's Introduction: Rapid System Prototyping , 2007, IEEE Distributed Syst. Online.

[130]  Laurence Duchien,et al.  Context awareness for dynamic service-oriented product lines , 2009, SPLC.

[131]  Hui Song,et al.  SM@RT: representing run-time system data as MOF-compliant models , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[132]  Carlo Ghezzi,et al.  The Fading Boundary between Development Time and Run Time , 2011, 2011 IEEE Ninth European Conference on Web Services.

[133]  Martin Kardos,et al.  Model-based Runtime Verification Framework for Self-optimizing Systems , 2006, RV@CAV.

[134]  Bernhard Rumpe,et al.  Model-driven Development of Complex Software : A Research Roadmap , 2007 .

[135]  Paola Inverardi,et al.  Run-time performance management of the Siena publish/subscribe middleware , 2005, WOSP '05.

[136]  Alan W. Colman,et al.  A Feature-Oriented Approach for Web Service Customization , 2010, 2010 IEEE International Conference on Web Services.

[137]  Sahin Albayrak,et al.  Model-based layout generation , 2008, AVI '08.

[138]  Marin Litoiu,et al.  Hierarchical model-based autonomic control of software systems , 2005, ACM SIGSOFT Softw. Eng. Notes.

[139]  Manfred Reichert,et al.  MaDe4IC: an abstract method for managing model dependencies in inter-organizational cooperations , 2010, Service Oriented Computing and Applications.

[140]  T. C. Nicholas Graham,et al.  An Incremental Algorithm for High-Performance Runtime Model Consistency , 2009, MoDELS.

[141]  Pattie Maes,et al.  Concepts and experiments in computational reflection , 1987, OOPSLA '87.

[142]  Thomas Vogel,et al.  A language for feedback loops in self-adaptive systems: Executable runtime megamodels , 2012, 2012 7th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS).

[143]  Antonello Calabrò,et al.  Towards a Model-Driven Infrastructure for Runtime Monitoring , 2011, SERENE.

[144]  W. Nutt,et al.  Constructive problem solving : a model construction approach towards configuration , 1995 .

[145]  Vicente Pelechano,et al.  Context-Aware Autonomous Web Services in Software Product Lines , 2011, 2011 15th International Software Product Line Conference.

[146]  Ekkart Kindler,et al.  Integrating behaviour in software models: an event coordination notation -- concepts and prototype , 2011, BM-FA '11.

[147]  INGOLF H. KRÜGER,et al.  Interaction-based Runtime Verification for Systems of Systems Integration , 2010, J. Log. Comput..

[148]  Olivier Barais,et al.  Dissemination of Reconfiguration Policies on Mesh Networks , 2012, DAIS.

[149]  Paola Inverardi,et al.  Model checking requirements at run-time in adaptive systems , 2011, ASAS '11.

[150]  Paola Inverardi,et al.  Feature oriented evolutions for context-aware adaptive systems , 2010, IWPSE-EVOL '10.

[151]  Schahram Dustdar,et al.  Domain-Specific Service Selection for Composite Services , 2012, IEEE Transactions on Software Engineering.

[152]  Bradley R. Schmerl,et al.  Model-based adaptation for self-healing systems , 2002, WOSS '02.

[153]  Gordon S. Blair,et al.  ReMMoC: A Reflective Middleware to Support Mobile Client Interoperability , 2003, OTM.

[154]  Jean Vanderdonckt,et al.  A Model-Based Approach for Developing Vectorial User Interfaces , 2009, 2009 Latin American Web Congress.

[155]  Sophie Dupuy-Chessa,et al.  Users need your models!: exploiting design models for explanations , 2012, BCS HCI.

[156]  Thomas Vogel,et al.  Graph Transformations for MDE, Adaptation, and Models at Runtime , 2012, SFM.

[157]  Bradley R. Schmerl,et al.  Using Architectural Models at Runtime: Research Challenges , 2004, EWSA.

[158]  Hong Yan,et al.  Discovering Architectures from Running Systems , 2006, IEEE Transactions on Software Engineering.

[159]  Xingshe Zhou,et al.  Web Services Trustworthiness Evaluation Based on Fuzzy Cognitive Maps , 2010, 2010 International Symposium on Intelligence Information Processing and Trusted Computing.

[160]  Gordon S. Blair,et al.  Summary of the workshop models@run.time at MoDELS 2006 , 2006, MoDELS'06.

[161]  Bernhard Rumpe,et al.  Proceedings of the 2008 international workshop on Models in software engineering , 2008, ICSE 2008.

[162]  Martin Gogolla,et al.  OCL-Based Runtime Monitoring of Applications with Protocol State Machines , 2012, ECMFA.

[163]  Jacques Klein,et al.  Towards flexible evolution of Dynamically Adaptive Systems , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[164]  Jean-Marc Jézéquel,et al.  Weaving executability into object-oriented meta-languages , 2005, MoDELS'05.

[165]  Anne-Françoise Le Meur,et al.  A Model-Based Framework to Design and Debug Safe Component-Based Autonomic Systems , 2009, QoSA.

[166]  Wasif Gilani,et al.  Event-Driven Process-Centric Performance Prediction via Simulation , 2011, Business Process Management Workshops.

[167]  Uwe Aßmann,et al.  Architecture and Mechanisms of Energy Auto-Tuning , 2013 .

[168]  Vincenzo Grassi,et al.  Qos-driven runtime adaptation of service oriented architectures , 2009, ESEC/SIGSOFT FSE.

[169]  Takeo Kanade,et al.  Software Engineering for Self-Adaptive Systems II , 2013, Lecture Notes in Computer Science.

[170]  Wei-Tek Tsai,et al.  Model-Based Monitoring and Policy Enforcement of Services , 2009, 2009 Congress on Services - I.

[171]  Darren J. Kerbyson,et al.  Dynamic performance prediction of an adaptive mesh application , 2006, Proceedings 20th IEEE International Parallel & Distributed Processing Symposium.

[172]  Gerti Kappel,et al.  A runtime model for fUML , 2012, MRT '12.

[173]  Mahdi Derakhshanmanesh,et al.  Towards model-centric engineering of a dynamic access control product line , 2012, SPLC '12.

[174]  Brice Morin,et al.  A models@runtime framework for designing and managing Service-Based Applications , 2012, 2012 First International Workshop on European Software Services and Systems Research - Results and Challenges (S-Cube).

[175]  Paola Inverardi,et al.  A Software Lifecycle Process to Support Consistent Evolutions , 2010, Software Engineering for Self-Adaptive Systems.

[176]  Changsheng Liu,et al.  Runtime Software Architecture Model Based on Design Hierarchy , 2007, 2007 International Conference on Machine Learning and Cybernetics.

[177]  Martin Kardos,et al.  Increasing Dependability by Means of Model-Based Acceptance Test inside RTOS , 2005, PPAM.

[178]  Tarak Chaari,et al.  Semantic Modeling and Reasoning at Runtime for Autonomous Systems Engineering , 2012, 2012 9th International Conference on Ubiquitous Intelligence and Computing and 9th International Conference on Autonomic and Trusted Computing.

[179]  Wouter Joosen,et al.  Support for distributed adaptations in aspect-oriented middleware , 2008, AOSD.

[180]  Schahram Dustdar,et al.  Monitoring and Analyzing Service-Based Internet Systems through a Model-Aware Service Environment , 2010, CAiSE.

[181]  Gunter Saake,et al.  Flexible feature binding in software product lines , 2011, Automated Software Engineering.

[182]  John Grundy,et al.  MDSE@R: Model-Driven Security Engineering at Runtime , 2012, CSS.

[183]  Pearl Brereton,et al.  Performing systematic literature reviews in software engineering , 2006, ICSE.

[184]  Daniel Schneider,et al.  Conditional Safety Certification of Open Adaptive Systems , 2013, TAAS.

[185]  Bikram Sengupta,et al.  An extensible framework for tracing model evolution in SOA solution design , 2009, OOPSLA Companion.

[186]  Frank Eliassen,et al.  A Component-Based Planning Framework for Adaptive Systems , 2006, OTM Conferences.

[187]  Lui Sha,et al.  Resource allocation contracts for Open Analytic Runtime models , 2011, 2011 Proceedings of the Ninth ACM International Conference on Embedded Software (EMSOFT).

[188]  Franck Barbier MDE-based Design and Implementation of Autonomic Software Components , 2006, 2006 5th IEEE International Conference on Cognitive Informatics.

[189]  P. Sawyer,et al.  Visualizing the Analysis of Dynamically Adaptive Systems Using i* and DSLs , 2007, Second International Workshop on Requirements Engineering Visualization (REV 2007).

[190]  Marek Kasztelnik,et al.  Towards semantic modeling of network physical devices , 2009, MODELS'09.

[191]  Daniela E. Damian,et al.  Selecting Empirical Methods for Software Engineering Research , 2008, Guide to Advanced Empirical Software Engineering.

[192]  Vicente Pelechano,et al.  Using Feature Models for Developing Self-Configuring Smart Homes , 2009, 2009 Fifth International Conference on Autonomic and Autonomous Systems.

[193]  Antonio Vallecillo,et al.  An MDE Approach for Runtime Monitoring and Adapting Component-Based Systems: Application to WIMP User Interface Architectures , 2012, 2012 38th Euromicro Conference on Software Engineering and Advanced Applications.

[194]  Gordon S. Blair,et al.  The case for reflective middleware , 2002, CACM.

[195]  Vicente Pelechano,et al.  Context-Adaptive Coordination of Pervasive Services by Interpreting Models during Runtime , 2013, Comput. J..

[196]  Mark Chignell,et al.  The Smart Internet - Current Research and Future Applications , 2010, The Smart Internet.

[197]  Brice Morin,et al.  Modeling and Validating Dynamic Adaptation , 2009, MoDELS.

[198]  Martin Gogolla,et al.  OCL-based Runtime Monitoring of JVM hosted Applications , 2011, Electron. Commun. Eur. Assoc. Softw. Sci. Technol..

[199]  Franz Wotawa,et al.  Real-Time Diagnosis and Repair of Faults of Robot Control Software , 2005, RoboCup.

[200]  Rogério de Lemos,et al.  Software Engineering for Self-Adaptive Systems [outcome of a Dagstuhl Seminar] , 2009, Software Engineering for Self-Adaptive Systems.

[201]  Nelly Bencomo,et al.  Models@run.time (Dagstuhl Seminar 11481) , 2011, Dagstuhl Reports.

[202]  Paola Inverardi,et al.  Towards an assume-guarantee theory for adaptable systems , 2009, 2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems.

[203]  Jean-Sébastien Sottet,et al.  Model-Driven Adaptation for Plastic User Interfaces , 2007, INTERACT.

[204]  Liang Xiao An adaptive security model using agent-oriented MDA , 2009, Inf. Softw. Technol..

[205]  Brice Morin,et al.  Models@ Run.time to Support Dynamic Adaptation , 2009, Computer.

[206]  Brice Morin,et al.  Taming Dynamically Adaptive Systems using models and aspects , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[207]  James D. Foley,et al.  A second generation user interface design environment: the model and the runtime architecture , 1993, INTERCHI.

[208]  Jocelyn Simmonds,et al.  Monitoring and recovery for web service applications , 2012, Computing.

[209]  Sébastien Gérard,et al.  Model-Driven Development of Self-Describing Components for Self-Adaptive Distributed Embedded Systems , 2011, 2011 37th EUROMICRO Conference on Software Engineering and Advanced Applications.

[210]  Dianxiang Xu,et al.  A Threat Model Driven Approach for Security Testing , 2007, Third International Workshop on Software Engineering for Secure Systems (SESS'07: ICSE Workshops 2007).

[211]  Romina Kühn,et al.  Model-based interactive ubiquitous systems , 2011, EICS.

[212]  Brice Morin,et al.  A semi-automatic behavioral mediation approach based on models@runtime , 2012, MRT '12.

[213]  Shahar Maoz,et al.  Model-Based Traces , 2009, MoDELS.

[214]  Vicente Pelechano,et al.  Automating Routine Tasks in AmI Systems by Using Models at Runtime , 2010, AmI.

[215]  Siobhán Clarke,et al.  Rapid GUI development on legacy systems: a runtime model-based solution , 2012, MRT '12.

[216]  Gerti Kappel,et al.  Reviving QVT Relations: Model-Based Debugging Using Colored Petri Nets , 2009, MoDELS.

[217]  Fábio M. Costa,et al.  Towards a More Effective Coupling of Reflection and Runtime Metamodels for Middleware ∗ , 2006 .

[218]  Padma Iyenghar,et al.  Model based debugging and testing of embedded systems without affecting the runtime behaviour , 2012, Proceedings of 2012 IEEE 17th International Conference on Emerging Technologies & Factory Automation (ETFA 2012).

[219]  Wilhelm Hasselbring,et al.  Model-driven Development of Self-managing Software Systems , 2006 .

[220]  Paola Inverardi,et al.  A Framework for Reconfiguration-Based Fault-Tolerance in Distributed Systems , 2003, WADS.

[221]  Yérom-David Bromberg,et al.  Starlink: Runtime Interoperability between Heterogeneous Middleware Protocols , 2011, 2011 31st International Conference on Distributed Computing Systems.

[222]  Paola Inverardi,et al.  Requirements models at run-time to support consistent system evolutions , 2011, 2011 2nd International Workshop on Requirements@Run.Time.

[223]  Sebastian Feuerstack,et al.  Engineering device-spanning, multimodal web applications using a model-based design approach , 2012, WebMedia.

[224]  Olivier Barais,et al.  K@RT: An Aspect-Oriented and Model-Oriented Framework for Dynamic Software Product Lines ⋆ , 2008 .

[225]  Uwe Aßmann,et al.  Towards Energy Auto Tuning , 2010 .

[226]  Helen Sharp,et al.  Ethnographically-informed empirical studies of software practice , 2007, Inf. Softw. Technol..

[227]  Rolf Ernst,et al.  Consistency Challenges in Self-Organizing Distributed Hard Real-Time Systems , 2010, 2010 13th IEEE International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing Workshops.

[228]  Pearl Brereton,et al.  Systematic literature reviews in software engineering - A systematic literature review , 2009, Inf. Softw. Technol..

[229]  Steffen Zschaler,et al.  Tool Support for Refinement of Non-functional Specifications , 2007, Software & Systems Modeling.

[230]  Damien Lyonnard,et al.  Exploiting TLM and Object Introspection for System-Level Simulation , 2006, Proceedings of the Design Automation & Test in Europe Conference.

[231]  Gerti Kappel,et al.  A Petri Net Based Debugging Environment for QVT Relations , 2009, 2009 IEEE/ACM International Conference on Automated Software Engineering.

[232]  Jean-Marc Jézéquel,et al.  Transactions on Aspect-Oriented Software Development VII , 2009 .

[233]  Sahin Albayrak,et al.  A 3-layer architecture for smart environment models , 2010, 2010 8th IEEE International Conference on Pervasive Computing and Communications Workshops (PERCOM Workshops).

[234]  Manzoor Ahmad First step towards a domain specific language for self-adaptive systems , 2010, 2010 10th Annual International Conference on New Technologies of Distributed Systems (NOTERE).

[235]  Bradley R. Schmerl,et al.  Architecture-Based Run-Time Fault Diagnosis , 2011, ECSA.

[236]  Carlo Ghezzi,et al.  Runtime Monitoring of Functional Component Changes with Behavior Models , 2011, MoDELS Workshops.

[237]  Baowen Xu,et al.  Improve the Effectiveness of Test Case Generation on EFSM via Automatic Path Feasibility Analysis , 2011, 2011 IEEE 13th International Symposium on High-Assurance Systems Engineering.

[238]  Peyman Oreizy,et al.  An architecture-based approach to self-adaptive software , 1999, IEEE Intell. Syst..

[239]  John Mylopoulos,et al.  Awareness requirements for adaptive systems , 2011, SEAMS '11.

[240]  J. Strassner,et al.  A Modeling Framework for Self-Healing Software Systems , 2007 .

[241]  Schahram Dustdar,et al.  Automating the Management and Versioning of Service Models at Runtime to Support Service Monitoring , 2012, 2012 IEEE 16th International Enterprise Distributed Object Computing Conference.

[242]  Michael Cebulla,et al.  Model-Based Personalization within an Adaptable Human-Machine Interface Environment that is Capable of Learning from User Interactions , 2010, 2010 Third International Conference on Advances in Computer-Human Interactions.

[243]  Cristina Vicente-Chicote,et al.  Runtime Adaptation of Architectural Models: An Approach for Adapting User Interfaces , 2012, MEDI.

[244]  Valérie Issarny,et al.  The role of models@run.time in supporting on-the-fly interoperability , 2013, Computing.

[245]  Betty H. C. Cheng,et al.  Model-based development of dynamically adaptive software , 2006, ICSE.

[246]  Gang Huang,et al.  Detecting anti-patterns in Java EE runtime system model , 2012, Internetware.

[247]  Yuhong Zhao,et al.  On-Line Model Checking as Operating System Service , 2009, SEUS.

[248]  Peyman Oreizy,et al.  Architecture-based runtime software evolution , 1998, Proceedings of the 20th International Conference on Software Engineering.

[249]  Bao Le Duc,et al.  A QoI-aware Framework for Adaptive Monitoring , 2010 .

[250]  Paolo Arcaini,et al.  CoMA: Conformance Monitoring of Java Programs by Abstract State Machines , 2011, RV.

[251]  Olaf Zimmermann,et al.  Architectural Decisions as Reusable Design Assets , 2011, IEEE Software.

[252]  Daniel Amyot,et al.  Goal models as run-time entities in context-aware systems , 2012, MRT '12.

[253]  J. Muskens,et al.  Integrity management in component based systems , 2004 .

[254]  John Mylopoulos,et al.  Why Goal-Oriented Requirements Engineering , 1998, Requirements Engineering: Foundation for Software Quality.

[255]  Sahin Albayrak,et al.  Utilizing Dynamic Executable Models for User Interface Development , 2008, DSV-IS.

[256]  Christian Kreiner,et al.  A Model-Based Architecture Supporting Virtual Organizations in Pervasive Systems , 2010, 2010 15th IEEE International Conference on Engineering of Complex Computer Systems.

[257]  Christian Schlegel,et al.  Managing execution variants in task coordination by exploiting design-time models at run-time , 2011, 2011 IEEE/RSJ International Conference on Intelligent Robots and Systems.

[258]  David Harel,et al.  On tracing reactive systems , 2011, Software & Systems Modeling.

[259]  Carlo Ghezzi,et al.  Run-time efficient probabilistic model checking , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[260]  Philippe Collet,et al.  Compositional Patterns of Non-Functional Properties for Contract Negotiation , 2007, J. Softw..

[261]  Heather Goldsby,et al.  Automatically Generating Behavioral Models of Adaptive Systems to Address Uncertainty , 2008, MoDELS.

[262]  Minqiang Xu,et al.  An Unsupervised Anomaly Detection Approach for Spacecraft Based on Normal Behavior Clustering , 2012, 2012 Fifth International Conference on Intelligent Computation Technology and Automation.

[263]  Matjaz B. Juric,et al.  Modeling functional requirements for configurable content- and context-aware dynamic service selection in business process models , 2012, J. Vis. Lang. Comput..

[264]  Vicente Pelechano,et al.  Autonomic Computing through Reuse of Variability Models at Runtime: The Case of Smart Homes , 2009, Computer.

[265]  Paola Inverardi,et al.  Model-based system reconfiguration for dynamic performance management , 2007, J. Syst. Softw..

[266]  Edwin D. Reilly,et al.  Interactive system , 2003 .

[267]  Thomas Vogel,et al.  Adaptation and abstract runtime models , 2010, SEAMS '10.

[268]  Richard N. Taylor,et al.  Using Architectural Models to Manage and Visualize Runtime Adaptation , 2009, Computer.

[269]  Axel-Cyrille Ngonga Ngomo,et al.  Developing Consistent and Modular Software Models with Ontologies , 2009, SoMeT.

[270]  Holger Kenn,et al.  The WUI-Toolkit: A Model-Driven UI Development Framework for Wearable User Interfaces , 2007, 27th International Conference on Distributed Computing Systems Workshops (ICDCSW'07).

[271]  Yu Guo,et al.  Graphical Model Debugger Framework for embedded systems , 2010, 2010 Design, Automation & Test in Europe Conference & Exhibition (DATE 2010).

[272]  Hui Song,et al.  Supporting runtime software architecture: A bidirectional-transformation-based approach , 2011, J. Syst. Softw..

[273]  Martin Gogolla,et al.  Towards supporting multiple execution environments for UML/OCL models at runtime , 2012, MRT '12.

[274]  Philippe Collet,et al.  A Reflective Model for Architecting Feedback Control Systems , 2011, SEKE.

[275]  Alfonso Garc Self-Explanatory User Interfaces by Model-Driven Engineering , 2010 .

[276]  Nelly Bencomo,et al.  Supporting Decision-Making for Self-Adaptive Systems: From Goal Models to Dynamic Decision Networks , 2013, REFSQ.

[277]  B. J. Ferro Castro,et al.  Pattern-Oriented Software Architecture: A System of Patterns , 2009 .

[278]  Vicente Pelechano,et al.  A NFR-Based Framework for User-Centered Adaptation , 2012, ER.

[279]  Jeffrey O. Kephart,et al.  The Vision of Autonomic Computing , 2003, Computer.

[280]  Nelly Bencomo,et al.  Towards requirements aware systems: Run-time resolution of design-time assumptions , 2011, 2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011).

[281]  Radu Calinescu,et al.  Dynamic QoS Management and Optimization in Service-Based Systems , 2011, IEEE Transactions on Software Engineering.

[282]  Yuhong Zhao,et al.  Model-based Runtime Verification Framework , 2009, FESCA@ETAPS.

[283]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture , 1996 .

[284]  Nelly Bencomo,et al.  On the use of software models during software execution , 2009, 2009 ICSE Workshop on Modeling in Software Engineering.

[285]  Hasan Sözer,et al.  Runtime Verification of Domain-Specific Models of Physical Characteristics in Control Software , 2011, 2011 Fifth International Conference on Secure Software Integration and Reliability Improvement.

[286]  Lidia Fuentes,et al.  Dynamic Weaving of Aspect-Oriented Executable UML Models , 2009, LNCS Trans. Aspect Oriented Softw. Dev..

[287]  Shin Nakajima An Architecture of Dynamically Adaptive PHP-based Web Applications , 2011, 2011 18th Asia-Pacific Software Engineering Conference.

[288]  Thomas Vogel,et al.  Model-driven architectural monitoring and adaptation for autonomic systems , 2009, ICAC '09.

[289]  Daniel A. Menascé,et al.  A framework for QoS-aware software components , 2004, WOSP '04.

[290]  Gordon S. Blair,et al.  A generic component model for building systems software , 2008, TOCS.