Advertisement

Models@run.time: a guided tour of the state of the art and research challenges

  • Nelly Bencomo
  • Sebastian Götz
  • Hui Song
Regular Paper
  • 67 Downloads

Abstract

More than a decade ago, the research topic models@run.time was coined. Since then, the research area has received increasing attention. Given the prolific results during these years, the current outcomes need to be sorted and classified. Furthermore, many gaps need to be categorized in order to further develop the research topic by experts of the research area but also newcomers. Accordingly, the paper discusses the principles and requirements of models@run.time and the state of the art of the research line. To make the discussion more concrete, a taxonomy is defined and used to compare the main approaches and research outcomes in the area during the last decade and including ancestor research initiatives. We identified and classified 275 papers on models@run.time, which allowed us to identify the underlying research gaps and to elaborate on the corresponding research challenges. Finally, we also facilitate sustainability of the survey over time by offering tool support to add, correct and visualize data.

Keywords

Models@run.time Self-reflection Causal connection Systematic literature review 

Notes

Acknowledgements

This work has been partially funded by the German Research Foundation (DFG) under Project Agreement SFB912/2 and GRK1907 and the Systems Analytics Research Institute (SARI) in Aston University.

References

  1. 1.
    Abeywickrama, D.B., Serbedzija, N., Loreti, M.: Monitoring and visualizing adaptation of autonomic systems at runtime. In: Proceedings of the 30th Annual ACM Symposium on Applied Computing, SAC ’15, pp. 1857–1860. ACM, New York, NY, USA (2015).  https://doi.org/10.1145/2695664.2695983
  2. 2.
    Albassam, E., Porter, J., Gomaa, H., Menasci, D.A.: Dare: a distributed adaptation and failure recovery framework for software systems. In: 2017 IEEE International Conference on Autonomic Computing (ICAC), pp. 203–208 (2017).  https://doi.org/10.1109/ICAC.2017.12
  3. 3.
    Alfarez, G., Pelechano, V., Mazo, R., Salinesi, C., Diaz, D.: Dynamic adaptation of service compositions with variability models. J. Syst. Softw. 91, 24–47 (2014).  https://doi.org/10.1016/j.jss.2013.06.034 CrossRefGoogle Scholar
  4. 4.
    Almorsy, M., Grundy, J., Ibrahim, A.S.: Adaptable, model-driven security engineering for SaaS cloud-based applications. Autom. Softw. Eng. 21(2), 187–224 (2014)CrossRefGoogle Scholar
  5. 5.
    Al-Refai, M., Cazzola, W., France, R.: Using models to dynamically refactor runtime code. In: Proceedings of the 29th Annual ACM Symposium on Applied Computing, SAC ’14, pp. 1108–1113. ACM, New York, NY, USA (2014).  https://doi.org/10.1145/2554850.2554954
  6. 6.
    Amoui, M., Derakhshanmanesh, M., Ebert, J., Tahvildari, L.: Achieving dynamic adaptation via management and interpretation of runtime models. J. Syst. Softw. 85(12), 2720–2737 (2012).  https://doi.org/10.1016/j.jss.2012.05.033 CrossRefGoogle Scholar
  7. 7.
    Anaya, I.D.P., Simko, V., Bourcier, J., Plouzeau, N., Jézéquel, J.M.: A prediction-driven adaptation approach for self-adaptive sensor networks. In: Proceedings of the 9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2014, pp. 145–154. ACM, New York, NY, USA (2014).  https://doi.org/10.1145/2593929.2593941
  8. 8.
    Anderson, S., Bredeche, N., Eiben, A., Kampis, G., van Steen, M.: Adaptive Collective Systems: Herding Black Sheep. Bookprints, Minneapolis (2013)Google Scholar
  9. 9.
    Andersson, J., Ericsson, M., Löwe, W.: Automatic rule derivation for adaptive architectures. In: 7th Working IEEE/IFIP Conference on Software Architecture, pp. 323–326. IEEE (2008)Google Scholar
  10. 10.
    Andersson, J., Lemos, R., Malek, S., Weyns, D. (2009) Modeling dimensions of self-adaptive software systems. In: Cheng B.H., Lemos R., Giese H., Inverardi P., Magee J. (eds.) Software Engineering for Self-Adaptive Systems, Chap. Modeling Dimensions of Self-Adaptive Software Systems, pp. 27–47. Springer, Berlin.  https://doi.org/10.1007/978-3-642-02161-9_2
  11. 11.
    Anthony, R., Pelc, M., Ward, P., Hawthorne, J., Pulnah, K.: A run-time configurable software architecture for self-managing systems. In: International Conference on Autonomic Computing, 2008. ICAC ’08, pp. 207–208 (2008).  https://doi.org/10.1109/ICAC.2008.23
  12. 12.
    Arcaini, P., Riccobene, E., Scandurra, P.: Modeling and analyzing MAPE-K feedback loops for self-adaptation. In: Proceedings of the 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’15, pp. 13–23. IEEE Press, Piscataway, NJ, USA (2015). http://dl.acm.org/citation.cfm?id=2821357.2821362
  13. 13.
    Arcega, L., Font, J., Haugen, Ø., Cetina, C.: An infrastructure for generating run-time model traces for maintenance tasks. In: Proceedings of the 11th International Workshop on Models@run.time co-located with 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016), Saint Malo, France, 4 October 2016, pp. 35–42 (2016). http://ceur-ws.org/Vol-1742/MRT16_paper_7.pdf
  14. 14.
    Arias, T.B.C., America, P., Avgeriou, P.: Defining execution viewpoints for a large and complex software-intensive system. In: Joint Working IEEE/IFIP Conference on Software Architecture, 2009 and European Conference on Software Architecture. WICSA/ECSA 2009, pp. 1–10. IEEE (2009). (They never use the term “models@runtime”, nor cite our paper, but it is essentially the same idea) Google Scholar
  15. 15.
    Barbier, F., Cariou, E., Le Goaer, O., Pierre, S.: Software adaptation: classification and a case study with state chart xml. IEEE Softw. 32(5), 68–76 (2015)CrossRefGoogle Scholar
  16. 16.
    Baresi, L., Ghezzi, C.: The disappearing boundary between development-time and run-time. In: Proceedings of the FSE/SDP Workshop on Future of Software Engineering Research, FoSER ’10, pp. 17–22. ACM, New York, NY, USA (2010).  https://doi.org/10.1145/1882362.1882367
  17. 17.
    Baresi, L., Pasquale, L., Spoletini, P.: Fuzzy goals for requirements-driven adaptation. In: RE 2010, 18th IEEE International Requirements Engineering Conference, Sydney, New South Wales, Australia, 27 September–1 October 2010, pp. 125–134 (2010). http://dx.doi.org/10.1109/RE.2010.25
  18. 18.
    Baresi, L., Pasquale, L.: Live goals for adaptive service compositions. In: Proceedings of the 2010 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’10, pp. 114–123. ACM, New York, NY, USA (2010).  https://doi.org/10.1145/1808984.1808997
  19. 19.
    Baresi, L.: Self-adaptive systems, services, and product lines. In: Proceedings of the 18th International Software Product Line Conference—Volume 1, SPLC ’14, pp. 2–4. ACM, New York, NY, USA (2014).  https://doi.org/10.1145/2648511.2648512
  20. 20.
    Baxter, I.: Keynote: supporting forward and reverse engineering with multiple types of models. In: Proceedings of the 20th International Conference on Model-driven Engineering, Systems and Languages. IEEE (2017)Google Scholar
  21. 21.
    Bellman, K.L., Landauer, C., Nelson, P., Bencomo, N., Götz, S., Lewis, P., Esterle, L.: Self-Modeling and Self-Awareness, pp. 279–304. Springer, Cham (2017).  https://doi.org/10.1007/978-3-319-47474-8_9 Google Scholar
  22. 22.
    Bencomo, N., Belaggoun, A., Issarny, V.: Dynamic decision networks for decision-making in self-adaptive systems: a case study. In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’13, pp. 113–122. IEEE Press, Piscataway, NJ, USA (2013). http://dl.acm.org/citation.cfm?id=2487336.2487355
  23. 23.
    Bencomo, N., Belaggoun, A., Issarny, V.: Dynamic decision networks for decision-making in self-adaptive systems: a case study. In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2013, San Francisco, CA, USA, 20–21 May 2013, pp. 113–122 (2013).  https://doi.org/10.1109/SEAMS.2013.6595498
  24. 24.
    Bencomo, N., Grace, P., Flores-Cortés, C.A., Hughes, D., Blair, G.S.: Genie: supporting the model driven development of reflective, component-based adaptive systems. In: 30th International Conference on Software Engineering (ICSE 2008), Leipzig, Germany, 10–18 May 2008, pp. 811–814 (2008).  https://doi.org/10.1145/1368088.1368207
  25. 25.
    Bencomo, N., Whittle, J., Sawyer, P., Finkelstein, A., Letier, E.: Requirements reflection: requirements as runtime entities. In: 2010 ACM/IEEE 32nd International Conference on Software Engineering, vol. 2, pp. 199–202 (2010).  https://doi.org/10.1145/1810295.1810329
  26. 26.
    Bencomo, N.: The role of models@run.time in autonomic systems: keynote. In: 2017 IEEE International Conference on Autonomic Computing, ICAC 2017, Columbus, OH, USA, 17–21 July 2017, pp. 293–294 (2017).  https://doi.org/10.1109/ICAC.2017.55
  27. 27.
    Bencomo, N., Belaggoun, A.: Supporting Decision-Making for Self-Adaptive Systems: From Goal Models to Dynamic Decision Networks, pp. 221–236. Springer, Berlin (2013).  https://doi.org/10.1007/978-3-642-37422-7_16 Google Scholar
  28. 28.
    Bencomo, N., Bennaceur, A., Grace, P., Blair, G., Issarny, V.: The role of models@run.time in supporting on-the-fly interoperability. Computing 95(3), 167–190 (2012)CrossRefGoogle Scholar
  29. 29.
    Bencomo, N., Hallsteinsen, S., De Almeida, E.S.: A view of the dynamic software product line landscape. Computer 45(10), 36–41 (2012).  https://doi.org/10.1109/MC.2012.292 CrossRefGoogle Scholar
  30. 30.
    Bencomo, N., France, R., Cheng, B.H.C., Aßmann, U.: Models@run.time. Foundations, Applications, and Roadmaps, vol. 8378. Springer, Cham (2014)CrossRefGoogle Scholar
  31. 31.
    Bencomo, N., Torres, R., Salas, R., Astudillo, H.: An architecture based on computing with words to support runtime reconfiguration decisions of service-based systems. Int. J. Comput. Intell. Syst. 11(1), 272–281 (2018). (Copyright 2018, the Authors. Published by Atlantis Press. This is an open access article under the CC BY-NC license (http://creativecommons.org/licenses/by-nc/4.0/). Funding: UNAB Grant DI-1303-16/RG, grant FONDEF IDeA ID16I10322, FONDECYT Grant 1140408)
  32. 32.
    Bennaceur, A., France, R.B., Tamburrelli, G., Vogel, T., Mosterman, P.J., Cazzola, W., Costa, F.M., Pierantonio, A., Tichy, M., Aksit, M., Emmanuelson, P., Huang, G., Georgantas, N., Redlich, D.: Mechanisms for leveraging models at runtime in self-adaptive software. In: Models@run.time—Foundations, Applications, and Roadmaps (Dagstuhl Seminar 11481, 27 November–2 December 2011), pp. 19–46 (2014).  https://doi.org/10.1007/978-3-319-08915-7_2
  33. 33.
    Bennaceur, A., Issarny, V.: Automated synthesis of mediators to support component interoperability. IEEE Trans. Softw. Eng. 41, 221–240 (2015)CrossRefGoogle Scholar
  34. 34.
    Bézivin, J., Jouault, F., Valduriez, P.: On the need for megamodels. In: Proceedings of the OOPSLA/GPCE: Best Practices for Model-Driven Software Development Workshop, 19th Annual ACM Conference on Object-Oriented Programming, Systems, Languages, and Applications, Vancouver, Canada (2004). https://hal.archives-ouvertes.fr/hal-01222947
  35. 35.
    Blair, G., Bencomo, N., France, R.: Models@run.time. Computer 42(10), 22–27 (2009).  https://doi.org/10.1109/MC.2009.326 CrossRefGoogle Scholar
  36. 36.
    Bosch, J.: Delivering customer value in the age of autonomous, continuously evolving systems. In: 2016 IEEE 24th International Requirements Engineering Conference (RE), pp. 1–1 (2016).  https://doi.org/10.1109/RE.2016.16
  37. 37.
    Calinescu, R., France, R., Ghezzi, C.: Models@run.time. Computer 95(3), 165–166 (2013)CrossRefGoogle Scholar
  38. 38.
    Calinescu, R., France, R.B., Ghezzi, C.: Editorial. Computing 95(3), 165–166 (2013).  https://doi.org/10.1007/s00607-012-0238-4 CrossRefzbMATHGoogle Scholar
  39. 39.
    Cámara, J., Correia, P., De Lemos, R., Garlan, D., Gomes, P., Schmerl, B., Ventura, R.: Evolving an adaptive industrial software system to use architecture-based self-adaptation. In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’13, pp. 13–22. IEEE Press, Piscataway, NJ, USA (2013)Google Scholar
  40. 40.
    Cámara, J., Bellman, K.L., Kephart, J.O., Autili, M., Bencomo, N., Diaconescu, A., Giese, H., Götz, S., Inverardi, P., Kounev, S., Tivoli, M.: Self-Aware Computing Systems: Related Concepts and Research Areas, pp. 17–49. Springer, Cham (2017).  https://doi.org/10.1007/978-3-319-47474-8_2 CrossRefGoogle Scholar
  41. 41.
    Capilla, R., Bosch, J.: The promise and challenge of runtime variability. Computer 44(12), 93–95 (2011).  https://doi.org/10.1109/MC.2011.382 CrossRefGoogle Scholar
  42. 42.
    Castañeda, L., Villegas, N.M., Müller, H.A.: Self-adaptive applications: on the development of personalized web-tasking systems. In: Proceedings of the 9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS 2014, pp. 49–54. ACM, New York, NY, USA (2014).  https://doi.org/10.1145/2593929.2593942
  43. 43.
    Cazzola, W., Rossini, N.A., Bennett, P., Mandalaparty, S.P., France, R.B.: Fine-grained semi-automated runtime evolution. In: Models@run.time—Foundations, Applications, and Roadmaps (Dagstuhl Seminar 11481, 27 November–2 December 2011), pp. 237–258 (2014).  https://doi.org/10.1007/978-3-319-08915-7_9
  44. 44.
    Cazzola, W., Rossini, N.A., Al-Refai, M., France, R.B.: Fine-Grained Software Evolution Using UML Activity and Class Models, pp. 271–286. Springer, Berlin (2013).  https://doi.org/10.1007/978-3-642-41533-3_17 Google Scholar
  45. 45.
    Cetina, C., Giner, P., Fons, J., Pelechano, V.: A model-driven approach for developing self-adaptive pervasive systems. In: Proceedings of the 3rd International Models@ Runtime Workshop, pp. 97–106 (2008)Google Scholar
  46. 46.
    Cetina, C., Giner, P., Fons, J., Pelechano, V.: Autonomic computing through reuse of variability models at runtime: the case of smart homes. Computer 42(10), 37–43 (2009)CrossRefGoogle Scholar
  47. 47.
    Chen, B., Peng, X., Yu, Y., Nuseibeh, B., Zhao, W.: Self-adaptation through incremental generative model transformations at runtime. In: 36th International Conference on Software Engineering, ICSE ’14, Hyderabad, India—31 May–07 June 2014, pp. 676–687 (2014).  https://doi.org/10.1145/2568225.2568310
  48. 48.
    Chen, T., Bahsoon, R.: Self-adaptive and online qos modeling for cloud-based software services. IEEE Trans. Softw. Eng. 43(5), 453–475 (2017).  https://doi.org/10.1109/TSE.2016.2608826 CrossRefGoogle Scholar
  49. 49.
    Chen, X., Li, A., Zeng, X., Guo, W., Huang, G.: Runtime model based approach to iot application development. Front. Comput. Sci. 9(4), 540–553 (2015)CrossRefGoogle Scholar
  50. 50.
    Cheng, B.H.C., Eder, K.I., Gogolla, M., Grunske, L., Litoiu, M., Müller, H.A., Pelliccione, P., Perini, A., Qureshi, N.A., Rumpe, B., Schneider, D., Trollmann, F., Villegas, N.M.: Using models at runtime to address assurance for self-adaptive systems. In: Models@run.time—Foundations, Applications, and Roadmaps (Dagstuhl Seminar 11481, 27 November–2 December 2011), pp. 101–136 (2011).  https://doi.org/10.1007/978-3-319-08915-7_4
  51. 51.
    Cheng, B.H.C., Eder, K.I., Gogolla, M., Grunske, L., Litoiu, M., Müller, H.A., Pelliccione, P., Perini, A., Qureshi, N.A., Rumpe, B., Schneider, D., Trollmann, F., Villegas, N.M.: Using models at runtime to address assurance for self-adaptive systems. In: Models@run.time—Foundations, Applications, and Roadmaps (Dagstuhl Seminar 11481, 27 November–2 December 2011), pp. 101–136 (2014).  https://doi.org/10.1007/978-3-319-08915-7_4
  52. 52.
    Combemale, B., Broto, L., Crégut, X., Daydé, M., Hagimont, D.: Autonomic management policy specification: from uml to dsml. In: Model Driven Engineering Languages and Systems, pp. 584–599. Springer (2008)Google Scholar
  53. 53.
    Criado, J., Vicente-Chicote, C., Padilla, N., Iribarne, L.: A model-driven approach to graphical user interface runtime adaptation. In: Proceedings of the 5th Workshop on Models@run.time, pp. 49–59 (2010)Google Scholar
  54. 54.
    Dávid, I., Ráth, I., Varró, D.: Foundations for streaming model transformations by complex event processing. Softw. Syst. Model. (2016).  https://doi.org/10.1007/s10270-016-0533-1
  55. 55.
    de Grandis, P., Valetto, G.: Elicitation and utilization of application-level utility functions. In: Proceedings of the 6th International Conference on Autonomic Computing, pp. 107–116. ACM (2009).  https://doi.org/10.1145/1555228.1555259
  56. 56.
    de Lemos, R., Giese, H., Müller, H.A., Shaw, M., Andersson, J., Litoiu, M., Schmerl, B., Tamura, G., Villegas, N.M., Vogel, T., Weyns, D., Baresi, L., Becker, B., Bencomo, N., Brun, Y., Cukic, B., Desmarais, R., Dustdar, S., Engels, G., Geihs, K., Göschka, K.M., Gorla, A., Grassi, V., Inverardi, P., Karsai, G., Kramer, J., Lopes, A., Magee, J., Malek, S., Mankovskii, S., Mirandola, R., Mylopoulos, J., Nierstrasz, O., Pezzè, M., Prehofer, C., Schäfer, W., Schlichting, R., Smith, D.B., Sousa, J.P., Tahvildari, L., Wong, K., Wuttke, J.: Software Engineering for Self-Adaptive Systems: A Second Research Roadmap, pp. 1–32. Springer, Berlin (2013).  https://doi.org/10.1007/978-3-642-35813-5_1
  57. 57.
    De Oliveira Filho, J., Papp, Z., Djapic, R., Oosteveen, J.: Model-based design of self-adapting networked signal processing systems. In: IEEE 7th International Conference on Self-Adaptive and Self-Organizing Systems (SASO), 2013, pp. 41–50 (2013).  https://doi.org/10.1109/SASO.2013.16
  58. 58.
    Debbabi, B., Diaconescu, A., Lalanda, P.: Controlling self-organising software applications with archetypes. In: IEEE 6th International Conference on Self-Adaptive and Self-Organizing Systems (SASO), 2012, pp. 69–78 (2012).  https://doi.org/10.1109/SASO.2012.21
  59. 59.
    DeLoach, S.A., Ou, X., Zhuang, R., Zhang, S.: Model-driven, moving-target defense for enterprise network security. In: Models@run.time—Foundations, Applications, and Roadmaps (Dagstuhl Seminar 11481, 27 November–2 December 2011), pp. 137–161 (2014).  https://doi.org/10.1007/978-3-319-08915-7_5
  60. 60.
    Denker, M., Ressia, J., Greevy, O., Nierstrasz, O.: Modeling features at runtime. In: Model-Driven Engineering Languages and Systems, pp. 138–152. Springer (2010)Google Scholar
  61. 61.
    Derakhshanmanesh, M., Amoui, M., O’Grady, G., Ebert, J., Tahvildari, L.: Graf: graph-based runtime adaptation framework. In: Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’11, pp. 128–137. ACM, New York, NY, USA (2011).  https://doi.org/10.1145/1988008.1988026
  62. 62.
    Derakhshanmanesh, M., Grieger, M., Ebert, J.: On the need for extended transactional models@run.time. In: Götz, S., Bencomo, N., Blair, G., Song, H. (eds.) Proceedings of the 10th International Workshop on Models@run.time, pp. 21–30. CEUR-WS.org (2015)Google Scholar
  63. 63.
    Devries, B., Cheng, B.: Using models at run time to detect incomplete and inconsistent requirements. In: Proceedings of the 12th International Workshop on Models@run.time Co-located with 20th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016), 19 September 2017, Austin, TX, USA (2017)Google Scholar
  64. 64.
    Diaconescu, A., Bellman, K.L., Esterle, L., Giese, H., Götz, S., Lewis, P., Zisman, A.: Architectures for Collective Self-Aware Computing Systems, pp. 191–235. Springer, Cham (2017).  https://doi.org/10.1007/978-3-319-47474-8_7 CrossRefGoogle Scholar
  65. 65.
    Didona, D., Romano, P., Peluso, S., Quaglia, F.: Transactional auto scaler: elastic scaling of in-memory transactional data grids. In: Proceedings of the 9th International Conference on Autonomic Computing, pp. 125–134. ACM (2012).  https://doi.org/10.1145/2371536.2371559
  66. 66.
    Ding, Y., Namatame, N., Riedel, T., Miyaki, T., Budde, M.: Smartteco: context-based ambient sensing and monitoring for optimizing energy consumption. In: Proceedings of the 8th ACM International Conference on Autonomic Computing, pp. 169–170. ACM (2011).  https://doi.org/10.1145/1998582.1998612
  67. 67.
    Ebraert, P., Tourwe, T.: A reflective approach to dynamic software evolution. In: Cazzola, W., Chiba, S., Saake, G. (eds.) Research Report C-196, pp. 37–43. Department of Mathematical and Computing Sciences, Tokyo Institute of Technology, Tokyo (2004)Google Scholar
  68. 68.
    El Kateb, D., Zannone, N., Moawad, A., Caire, P., Nain, G., Mouelhi, T., Le Traon, Y.: Conviviality-driven access control policy. Requir. Eng. 20(4), 363–382 (2015).  https://doi.org/10.1007/s00766-014-0204-0 CrossRefGoogle Scholar
  69. 69.
    Elkhodr, M., Shahrestani, S.A., Cheung, H.: The Internet of Things: new interoperability, management and security challenges. CoRR arXiv:1604.04824 (2016)
  70. 70.
    Esfahani, N., Malek, S.: Uncertainty in Self-Adaptive Software Systems, pp. 214–238. Springer, Berlin (2013).  https://doi.org/10.1007/978-3-642-35813-5_9 CrossRefGoogle Scholar
  71. 71.
    Esfahani, N., Yuan, E., Canavera, K.R., Malek, S.: Inferring software component interaction dependencies for adaptation support. ACM Trans. Auton. Adapt. Syst. 10, 26:1–26:32 (2016)CrossRefGoogle Scholar
  72. 72.
    Evesti, A., Ovaska, E.: Ontology-based security adaptation at run-time. In: 4th IEEE International Conference on Self-Adaptive and Self-Organizing Systems (SASO), 2010, pp. 204–212 (2010).  https://doi.org/10.1109/SASO.2010.11
  73. 73.
    Ferry, N., Hourdin, V., Lavirotte, S., Rey, G., Tigli, J.Y., Riveill, M.: Models at runtime: service for device composition and adaptation. In: Proceedings of the 4th Workshop on Models@run.time, pp. 51–60 (2009)Google Scholar
  74. 74.
    Fiadeiro, J.L., Lopes, A.: A model for dynamic reconfiguration in service-oriented architectures. In: Proceedings of 4th European Conference on Software Architecture, ECSA 2010, Copenhagen, Denmark, 23–26 August 2010, pp. 70–85 (2010).  https://doi.org/10.1007/978-3-642-15114-9_8
  75. 75.
    Filho, R.R., Porter, B.: Defining emergent software using continuous self-assembly, perception, and learning. ACM Trans. Auton. Adapt. Syst. 12(3), 16:1–16:25 (2017).  https://doi.org/10.1145/3092691 CrossRefGoogle Scholar
  76. 76.
    Filieri, A., Ghezzi, C., Grassi, V., Mirandola, R.: Reliability analysis of component-based systems with multiple failure modes. In: Proceedings of 13th International Symposium on Component-Based Software Engineering, CBSE 2010, Prague, Czech Republic, 23–25 June 2010, pp. 1–20 (2010).  https://doi.org/10.1007/978-3-642-13238-4_1
  77. 77.
    Filieri, A., Tamburrelli, G., Ghezzi, C.: Supporting self-adaptation via quantitative verification and sensitivity analysis at run time. IEEE Trans. Softw. Eng. 42(1), 75–99 (2016).  https://doi.org/10.1109/TSE.2015.2421318 CrossRefGoogle Scholar
  78. 78.
    Fleurey, F., Dehlen, V., Bencomo, N., Morin, B., Jezequel, J.M.: Modeling and validating dynamic adaptation. In: Proceedings of the 3rd International Models@ Runtime Workshop, pp. 36–46 (2008)Google Scholar
  79. 79.
    Fouquet, F., Morin, B., Fleurey, F., Barais, O., Plouzeau, N., Jézéquel, J.: A dynamic component model for cyber physical systems. In: Proceedings of the 15th ACM SIGSOFT Symposium on Component Based Software Engineering, CBSE 2012, Part of Comparch ’12 Federated Events on Component-Based Software Engineering and Software Architecture, Bertinoro, Italy, 25–28 June 2012, pp. 135–144 (2012).  https://doi.org/10.1145/2304736.2304759
  80. 80.
    Fouquet, F., Nain, G., Morin, B., Daubert, E., Barais, O., Plouzeau, N., Jézéquel, J.M.: An eclipse modelling framework alternative to meet the models@ runtime requirements. In: Proceedings of the 15th International Conference on Model Driven Engineering Languages and Systems, pp. 87–101. Springer (2012)Google Scholar
  81. 81.
    France, R., Rumpe, B.: Model-driven development of complex software: a research roadmap. In: Briand, L., Wolf, A. (eds.) Future of Software Engineering. IEEE-CS Press, Piscataway (2007)Google Scholar
  82. 82.
    Gamez, N., Fuentes, L., Troya, J.: Creating self-adapting mobile systems with dynamic software product lines. IEEE Softw. 32(2), 105–112 (2015)CrossRefGoogle Scholar
  83. 83.
    Garcia, A., Bencomo, N.: Non-human modelers: Can they work? In: Proceedings of Workshops, STAF 2017, Software Technologies: Applications and Foundations (2017)Google Scholar
  84. 84.
    Garlan, D., Schmerl, B.: Using Architectural Models at Runtime: Research Challenges. Springer, Berlin (2004)Google Scholar
  85. 85.
    Georgas, J.C., van der Hoek, A., Taylor, R.N.: Using architectural models to manage and visualize runtime adaptation. Computer 42(10), 0052–60 (2009)CrossRefGoogle Scholar
  86. 86.
    Gerbert-Gaillard, E., Lalanda, P.: Self-aware model-driven pervasive systems. In: 2016 IEEE International Conference on Autonomic Computing (ICAC), pp. 221–222 (2016).  https://doi.org/10.1109/ICAC.2016.26
  87. 87.
    Ghahremani, S., Giese, H., Vogel, T.: Efficient utility-driven self-healing employing adaptation rules for large dynamic architectures. In: 2017 IEEE International Conference on Autonomic Computing (ICAC), pp. 59–68 (2017).  https://doi.org/10.1109/ICAC.2017.35
  88. 88.
    Ghezzi, C., Mocci, A., Sangiorgio, M.: Runtime monitoring of component changes with spy@runtime. In: Proceedings of the 34th International Conference on Software Engineering, ICSE ’12, pp. 1403–1406. IEEE Press, Piscataway, NJ, USA (2012). http://dl.acm.org/citation.cfm?id=2337223.2337430
  89. 89.
    Gjerlufsen, T., Ingstrup, M., Olsen, J.W.: Mirrors of meaning: supporting inspectable runtime models. Computer 42(10), 61–68 (2009). (This paper is focused on the reflection of programs’ runtime status)CrossRefGoogle Scholar
  90. 90.
    Gonzalez-Herrera, I., Bourcier, J., Daubert, E., Rudametkin, W., Barais, O., Fouquet, F., Jézéquel, J.M.: Scapegoat: an adaptive monitoring framework for component-based systems. In: IEEE/IFIP Conference on Software Architecture (WICSA), 2014, pp. 67–76. IEEE (2014)Google Scholar
  91. 91.
    Götz, S., Gerostathopoulos, I., Krikava, F., Shahzada, A., Spalazzese, R.: Adaptive exchange of distributed partial models@run.time for highly dynamic systems. In: Proceedings of the 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS). IEEE (2015)Google Scholar
  92. 92.
    Götz, S., Kühn, T.: Models@run.time for object-relational mapping supporting schema evolution. In: Götz, S., Bencomo, N., Blair, G., Song, H. (eds.) Proceedings of the 10th International Workshop on Models@run.time, pp. 41–50. CEUR-WS.org (2015)Google Scholar
  93. 93.
    Götz, S., Schöne, R., Wilke, C., Mendez, J., Assmann, U.: Towards predictive self-optimization by situation recognition. In: Proceedings of 2nd Workshop “Energy Aware Software—Engineering and Development” (EASED) (2013)Google Scholar
  94. 94.
    Götz, S.: Supporting systematic literature reviews in computer science: the systematic literature review toolkit. In: MoDELS Companion, pp. 22–26. ACM (2018)Google Scholar
  95. 95.
    Götz, S., Bencomo, N., France, R.B.: Devising the future of the models@run.time workshop. ACM SIGSOFT Softw. Eng. Notes 40(1), 26–29 (2015).  https://doi.org/10.1145/2693208.2693249 CrossRefGoogle Scholar
  96. 96.
    Grohmann, J., Herbst, N., Spinner, S., Kounev, S.: Self-tuning resource demand estimation. In: 2017 IEEE International Conference on Autonomic Computing (ICAC), pp. 21–26 (2017).  https://doi.org/10.1109/ICAC.2017.19
  97. 97.
    Guo, T., Shenoy, P.: Model-driven geo-elasticity in database clouds. In: 2015 IEEE International Conference on Autonomic Computing (ICAC), pp. 61–70 (2015).  https://doi.org/10.1109/ICAC.2015.46
  98. 98.
    Hallsteinsen, S., Hinchey, M., Park, S., Schmid, K.: Dynamic software product lines. Computer 41(4), 93–95 (2008).  https://doi.org/10.1109/MC.2008.123 CrossRefGoogle Scholar
  99. 99.
    Hartmann, T., Moawad, A., Fouquet, F., Le Traon, Y.: The next evolution of MDE: a seamless integration of machine learning into domain modeling. Softw. Syst. Model. (2017).  https://doi.org/10.1007/s10270-017-0600-2
  100. 100.
    Hartmann, T., Moawad, A., Fouquet, F., Nain, G., Klein, J., Traon, Y.L.: Stream my models: Reactive peer-to-peer distributed models@run.time. In: ACM/IEEE 18th International Conference on Model Driven Engineering Languages and Systems (MODELS), 2015, pp. 80–89 (2015).  https://doi.org/10.1109/MODELS.2015.7338238
  101. 101.
    Heinzemann, C., Becker, S., Volk, A.: Transactional execution of hierarchical reconfigurations in cyber-physical systems. Softw. Syst. Model. (2017).  https://doi.org/10.1007/s10270-017-0583-z
  102. 102.
    Hinchey, M., Park, S., Schmid, K.: Building dynamic software product lines. Computer 45, 22–26 (2012).  https://doi.org/10.1109/MC.2012.332 CrossRefGoogle Scholar
  103. 103.
    Hong, Jy, Suh, Eh, Kim, S.J.: Context-aware systems. Expert Syst. Appl. 36(4), 8509–8522 (2009).  https://doi.org/10.1016/j.eswa.2008.10.071 CrossRefGoogle Scholar
  104. 104.
    Hooman, J., Hendriks, T.: Model-based run-time error detection. In: Giese, H. (ed.) Models in Software Engineering, Lecture Notes in Computer Science, vol. 5002, pp. 225–236. Springer, Berlin (2008).  https://doi.org/10.1007/978-3-540-69073-3_24 Google Scholar
  105. 105.
    Hussein, M., Han, J., Yu, J., Colman, A.: Enabling runtime evolution of context-aware adaptive services. In: 2013 IEEE International Conference on Services Computing, pp. 248–255 (2013).  https://doi.org/10.1109/SCC.2013.77
  106. 106.
    Iordanov, B., Alexandrova, A., Abbas, S., Hilpold, T., Upadrasta, P.: The semantic web as a software modeling tool: an application to citizen relationship management. In: Model-Driven Engineering Languages and Systems, pp. 589–603. Springer (2013)Google Scholar
  107. 107.
    Jacques-Silva, G., Challenger, J., Degenaro, L., Giles, J., Wagle, R.: Towards autonomic fault recovery in system-s. In: 4th International Conference on Autonomic Computing, 2007. ICAC ’07, pp. 31–31 (2007).  https://doi.org/10.1109/ICAC.2007.40
  108. 108.
    Janik, A., Zielinski, K.: Transparent resource management and self-adaptability using multitasking virtual machine RM API. In: Proceedings of the 2006 International Workshop on Self-Adaptation and Self-Managing Systems, SEAMS ’06, pp. 51–57. ACM, New York, NY, USA (2006).  https://doi.org/10.1145/1137677.1137688
  109. 109.
    Javed, F., Arshad, N.: Adopt: an adaptive optimization framework for large-scale power distribution systems. In: 3rd IEEE International Conference on Self-Adaptive and Self-Organizing Systems, 2009. SASO ’09, pp. 254–264 (2009).  https://doi.org/10.1109/SASO.2009.26
  110. 110.
    Johanndeiter, T., Goldstein, A., Frank, U.: Towards business process models at runtime. In: Proceedings of the 8th Workshop on Models@run.time, pp. 13–25. CEUR-WS.org (2013)Google Scholar
  111. 111.
    Junior, A.S., Costa, F., Clarke, P.: A model-driven approach to develop and manage cyber-physical systems. In: Proceedings of the 8th Workshop on Models@run.time, pp. 62–73. CEUR-WS.org (2013)Google Scholar
  112. 112.
    Karol, S., Bürger, C., Aßmann, U.: Towards well-formed fragment composition with reference attribute grammars. In: Grassi, V., Mirandola, R., Medvidovic, N., Larsson, M. (eds.) Proceedings of the 15th ACM SIGSOFT Symposium on Component Based Software Engineering, CBSE 2012, Part of Comparch 12 Federated Events on Component-Based Software Engineering and Software Architecture, pp. 109–114. ACM (2012)Google Scholar
  113. 113.
    Kitchenham, B.: Procedures for Performing Systematic Reviews (2004)Google Scholar
  114. 114.
    Kounev, S., Brosig, F., Huber, N.: Self-aware QoS management in virtualized infrastructures. In: Proceedings of the 8th ACM International Conference on Autonomic Computing, pp. 175–176. ACM (2011).  https://doi.org/10.1145/1998582.1998615
  115. 115.
    Kounev, S., Kephart, J.O., Milenkoski, A., Zhu, X. (eds.): Self-Aware Computing Systems. Springer, Cham (2017)Google Scholar
  116. 116.
    Kounev, S., Lewis, P.R., Bellman, K.L., Bencomo, N., Cámara, J., Diaconescu, A., Esterle, L., Geihs, K., Giese, H., Götz, S., Inverardi, P., Kephart, J.O., Zisman, A.: The notion of self-aware computing. In: Self-Aware Computing Systems, pp. 3–16 (2017).  https://doi.org/10.1007/978-3-319-47474-8_1
  117. 117.
    Křikava, F., Collet, P., France, R.B.: Actress: domain-specific modeling of self-adaptive software architectures. In: Proceedings of the 29th Annual ACM Symposium on Applied Computing, SAC ’14, pp. 391–398. ACM, New York, NY, USA (2014).  https://doi.org/10.1145/2554850.2555020
  118. 118.
    Krikava, F., Rouvoy, R., Seinturier, L.: Infrastructure as runtime models: towards model-driven resource management. In: ACM/IEEE 18th International Conference on Model Driven Engineering Languages and Systems (MODELS), 2015, pp. 100–105 (2015).  https://doi.org/10.1109/MODELS.2015.7338240
  119. 119.
    Kuhn, A., Verwaest, T.: FAME—a polyglot library for metamodeling at runtime. In: Proceedings of the 3rd International Models@Runtime Workshop, pp. 57–66 (2008)Google Scholar
  120. 120.
    Kusic, D., Kandasamy, N., Jiang, G.: Approximation modeling for the online performance management of distributed computing systems. In: 4th International Conference on Autonomic Computing, 2007. ICAC ’07, pp. 23–23 (2007).  https://doi.org/10.1109/ICAC.2007.8
  121. 121.
    Lee, J., Muthig, D., Naab, M.: An approach for developing service oriented product lines. In: Proceedings of the 12th International on Software Product Line Confer SPLC 2008, pp. 275–284 (2008).  https://doi.org/10.1109/SPLC.2008.34
  122. 122.
    Loulou, H., Saudrais, S., Soubra, H., Larouci, C.: Adapting security policy at runtime for connected autonomous vehicles. In: 2016 IEEE 25th International Conference on Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE), pp. 26–31 (2016).  https://doi.org/10.1109/WETICE.2016.16
  123. 123.
    Maes, P.: Concepts and experiments in computational reflection. In: Conference Proceedings on Object-Oriented Programming Systems, Languages and Applications, OOPSLA ’87, pp. 147–155. ACM, New York, NY, USA (1987).  https://doi.org/10.1145/38765.38821
  124. 124.
    Maier, M.W.: Architecting principles for systems-of-systems. Syst. Eng. 1(4), 267–284 (1998).  https://doi.org/10.1002/(SICI)1520-6858(1998)1:4<267::AID-SYS3>3.0.CO;2-D
  125. 125.
    Maoz, S.: Using model-based traces as runtime models. Computer 42(10), 0028–36 (2009)CrossRefGoogle Scholar
  126. 126.
    Mocci, A., Sangiorgio, M.: Detecting component changes at run time with behavior models. Computing 95(3), 191–221 (2013).  https://doi.org/10.1007/s00607-012-0214-z CrossRefGoogle Scholar
  127. 127.
    Mongiello, M., Pelliccione, P., Sciancalepore, M.: Ac-contract: run-time verification of context-aware applications. In: Proceedings of the 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’15, pp. 24–34. IEEE Press, Piscataway, NJ, USA (2015). http://dl.acm.org/citation.cfm?id=2821357.2821363
  128. 128.
    Morin, B., Fleurey, F., Bencomo, N., Jézéquel, J.M., Solberg, A., Dehlen, V., Blair, G.: An aspect-oriented and model-driven approach for managing dynamic variability. In: Model Driven Engineering Languages and Systems, pp. 782–796. Springer (2008)Google Scholar
  129. 129.
    Morin, B., Nain, G., Barais, O., Jezequel, J.M.: Leveraging models from design-time to runtime. A live demo. In: Proceedings of the 4th Workshop on Models@run.time, pp. 21–30 (2009)Google Scholar
  130. 130.
    Morin, B., Barais, O., Jezequel, J., Fleurey, F., Solberg, A.: Models@ run. time to support dynamic adaptation. Computer 42(10), 44–51 (2009)CrossRefGoogle Scholar
  131. 131.
    Mosincat, A.D., Binder, W.: Self-tuning BPEL processes. In: Proceedings of the 6th International Conference on Autonomic Computing, pp. 47–48. ACM (2009).  https://doi.org/10.1145/1555228.1555239
  132. 132.
    Moyano, F., Fernandez-Gago, C., Lopez, J.: A model-driven approach for engineering trust and reputation into software services. J. Netw. Comput. Appl. 69, 134–151 (2016).  https://doi.org/10.1016/j.jnca.2016.04.018. http://www.sciencedirect.com/science/article/pii/S1084804516300698
  133. 133.
    Mullins, R.: The EternalS Roadmap—Defining a Research Agenda for Eternal Systems, pp. 135–147. Springer, Berlin (2013).  https://doi.org/10.1007/978-3-642-45260-4_10 Google Scholar
  134. 134.
    Nascimento, A., Rubira, C., Castor, F.: Using CVL to support self-adaptation of fault-tolerant service compositions. In: IEEE 7th International Conference on Self-Adaptive and Self-Organizing Systems (SASO), 2013, pp. 261–262 (2013).  https://doi.org/10.1109/SASO.2013.34
  135. 135.
    Neamtiu, I.G.: Practical Dynamic Software Updating. Ph.D. Thesis (2008)Google Scholar
  136. 136.
    Park, S., Hinchey, M., In, H.P., Schmid, K.: 8th International workshop on dynamic software product lines (dspl 2014). In: Proceedings of the 18th International Software Product Line Conference—Volume 1, SPLC ’14, pp. 355–355. ACM, New York, NY, USA (2014).  https://doi.org/10.1145/2648511.2648554
  137. 137.
    Parra, C., Blanc, X., Cleve, A., Duchien, L.: Unifying design and runtime software adaptation using aspect models. Sci. Comput. Program. 76(12), 1247–1260 (2011).  https://doi.org/10.1016/j.scico.2010.12.005 CrossRefGoogle Scholar
  138. 138.
    Pasquale, L., Baresi, L., Nuseibeh, B.: Towards adaptive systems through requirements@runtime. In: Proceedings of the 6th Workshop on Models@run.time, pp. 13–24 (2011)Google Scholar
  139. 139.
    Paucar, L.H.G., Bencomo, N., Yuen, K.K.F.: Juggling preferences in a world of uncertainty. In: 25th IEEE International Requirements Engineering Conference, RE 2017, Lisbon, Portugal, 4–8 September 2017, pp. 430–435 (2017).  https://doi.org/10.1109/RE.2017.12
  140. 140.
    Paucar, L.H.G., Bencomo, N.: Runtime models based on dynamic decision networks: enhancing the decision-making in the domain of ambient assisted living applications. In: Proceedings of the 11th International Workshop on Models@run.time Co-located with 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016), Saint Malo, France, 4 October 2016, pp. 9–17 (2016). http://ceur-ws.org/Vol-1742/MRT16_paper_12.pdf
  141. 141.
    Pickering, B., Robert, S., Menoret, S., Mengusoglu, E.: Model-driven management of complex systems. In: Proceedings of the 3rd International Models@ Runtime Workshop, pp. 117–126 (2008)Google Scholar
  142. 142.
    Piechnick, C., Piechnick, M., Götz, S., Püschel, G., Aßmann, U.: Managing distributed context models requires adaptivity too. In: Götz, S., Bencomo, N., Blair, G., Song, H. (eds.) Proceedings of the 10th International Workshop on Models@run.time, pp. 61–70. CEUR-WS.org (2015)Google Scholar
  143. 143.
    Porter, J., Menascé, D.A., Gomaa, H.: Desarm: a decentralized mechanism for discovering software architecture models at runtime in distributed systems. In: Proceedings of the 11th International Workshop on Models@run.time Co-located with 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016), Saint Malo, France, 4 October 2016, pp. 43–51 (2016). http://ceur-ws.org/Vol-1742/MRT16_paper_3.pdf
  144. 144.
    Ramirez, A.J., Cheng, B.H., Bencomo, N., Sawyer, P.: Relaxing claims: coping with uncertainty while evaluating assumptions at run time. In: Proceedings of the 15th International Conference on Model Driven Engineering Languages and Systems, pp. 53–69. Springer (2012)Google Scholar
  145. 145.
    Ramirez, A.J., Jensen, A.C., Cheng, B.H.C.: A taxonomy of uncertainty for dynamically adaptive systems. In: Proceedings of the 7th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’12, pp. 99–108. IEEE Press, Piscataway, NJ, USA (2012). http://dl.acm.org/citation.cfm?id=2666795.2666812
  146. 146.
    Redlich, D., Blair, G.S., Rashid, A., Molka, T., Gilani, W.: Research challenges for business process models at run-time. In: Models@run.time—Foundations, Applications, and Roadmaps (Dagstuhl Seminar 11481, 27 November–2 December 2011), pp. 208–236 (2014).  https://doi.org/10.1007/978-3-319-08915-7_8
  147. 147.
    Ressia, J., Renggli, L., Girba, T., Nierstrasz, O.: Run-time evolution through explicit meta-objects. In: Proceedings of the 5th Workshop on Models@run.time, pp. 37–48 (2010)Google Scholar
  148. 148.
    Riva, C., Rodriguez, J.V.: Combining static and dynamic views for architecture reconstruction. In: Proceedings of the 6th European Conference on Software Maintenance and Reengineering, pp. 47–55 (2002).  https://doi.org/10.1109/CSMR.2002.995789
  149. 149.
    Rothenberg, J., Widman, L.E., Loparo, K.A., Nielsen, N.R.: The nature of modeling. In: Artificial Intelligence, Simulation and Modeling, pp. 75–92. Wiley (1989)Google Scholar
  150. 150.
    Sabatucci, L., Cossentino, M.: From means-end analysis to proactive means-end reasoning. In: Proceedings of the 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’15, pp. 2–12. IEEE Press, Piscataway, NJ, USA (2015). http://dl.acm.org/citation.cfm?id=2821357.2821361
  151. 151.
    Salehie, M., Tahvildari, L.: Self-adaptive software: landscape and research challenges. ACM Trans. Auton. Adapt. Syst. 4(2), 141–1442 (2009).  https://doi.org/10.1145/1516533.1516538 CrossRefGoogle Scholar
  152. 152.
    Samuel, A.L.: Some studies in machine learning using the game of checkers. IBM J. Res. Dev. 44(1.2), 206–226 (2000).  https://doi.org/10.1147/rd.441.0206 CrossRefGoogle Scholar
  153. 153.
    Sanchez, M., Barrero, I., Villalobos, J., Deridder, D.: An execution platform for extensible runtime models. In: Proceedings of the 3rd International Models@ Runtime Workshop, pp. 107–116 (2008)Google Scholar
  154. 154.
    Saudrais, S., Staikopoulos, A., Clarke, S.: Using specification models for runtime adaptations. In: Proceedings of the 4th Workshop on Models@run.time, pp. 109–117 (2009)Google Scholar
  155. 155.
    Sawyer, P., Bencomo, N., Whittle, J., Letier, E., Finkelstein, A.: Requirements-aware systems: a research agenda for re for self-adaptive systems. In: 2010 18th IEEE International Requirements Engineering Conference, pp. 95–103 (2010).  https://doi.org/10.1109/RE.2010.21
  156. 156.
    Schneider, D., Becker, M., Trapp, M.: Approaching runtime trust assurance in open adaptive systems. In: Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’11, pp. 196–201. ACM, New York, NY, USA (2011).  https://doi.org/10.1145/1988008.1988036
  157. 157.
    Schneider, D., Becker, M.: Runtime models for self-adaptation in the ambient assisted living domain. In: Proceedings of the 3rd International Models@ Runtime Workshop, pp. 47–56 (2008)Google Scholar
  158. 158.
    Schneider, D., Trapp, M.: A safety engineering framework for open adaptive systems. In: 5th IEEE International Conference on Self-Adaptive and Self-Organizing Systems (SASO), 2011, pp. 89–98 (2011).  https://doi.org/10.1109/SASO.2011.20
  159. 159.
    Schneider, D., Trapp, M.: Conditional safety certification of open adaptive systems. ACM Trans. Auton. Adapt. Syst. 8(2), 8:1–8:20 (2013).  https://doi.org/10.1145/2491465.2491467 CrossRefGoogle Scholar
  160. 160.
    Schöne, R., Götz, S., Aßmann, U., Bürger, C.: Incremental runtime-generation of optimisation problems using rag-controlled rewriting. In: Proceedings of the 11th International Workshop on Models@run.time Co-located with 19th International Conference on Model Driven Engineering Languages and Systems (MODELS 2016), Saint Malo, France, 4 October 2016, pp. 26–34 (2016). http://ceur-ws.org/Vol-1742/MRT16_paper_5.pdf
  161. 161.
    Sheikh, M.B., Minhas, U.F., Khan, O.Z., Aboulnaga, A., Poupart, P., Taylor, D.J.: A Bayesian approach to online performance modeling for database appliances using Gaussian models. In: Proceedings of the 8th ACM International Conference on Autonomic Computing, pp. 121–130. ACM (2011).  https://doi.org/10.1145/1998582.1998603
  162. 162.
    Simmonds, J., Ben-David, S., Chechik, M.: Monitoring and recovery for web service applications. Computing 95(3), 223–267 (2013).  https://doi.org/10.1007/s00607-012-0215-y CrossRefzbMATHGoogle Scholar
  163. 163.
    Song, H., Huang, G., Chauvel, F., Sun, Y.: Applying MDE tools at runtime: experiments upon runtime models. In: Proceedings of the 5th Workshop on Models@run.time, pp. 25–36 (2010). (Tool demo paper) Google Scholar
  164. 164.
    Song, H., Huang, G., Xiong, Y.F., Chauvel, F., Sun, Y., Mei, H., et al.: Inferring meta-models for runtime system data from the clients of management APIs. In: Proceedings of the 13th International Conference on Model-Driven Engineering Languages and Systems (MODELS 2010), vol. 6395 (2010)Google Scholar
  165. 165.
    Song, H., Xiong, Y., Chauvel, F., Huang, G., Hu, Z., Mei, H.: Generating synchronization engines between running systems and their model-based views. In: Proceedings of the 4th Workshop on Models@run.time, pp. 11–20 (2009)Google Scholar
  166. 166.
    Song, H., Zhang, X., Ferry, N., Chauvel, F., Solberg, A., Huang, G.: Modelling adaptation policies as domain-specific constraints. In: Model-Driven Engineering Languages and Systems, pp. 269–285. Springer (2014)Google Scholar
  167. 167.
    Spinner, S., Kounev, S., Zhu, X., Lu, L., Uysal, M., Holler, A., Griffith, R.: Runtime vertical scaling of virtualized applications via online model estimation. In: IEEE 8th International Conference on Self-Adaptive and Self-Organizing Systems (SASO), 2014, pp. 157–166 (2014).  https://doi.org/10.1109/SASO.2014.29
  168. 168.
    Staikopoulos, A., Saudrais, S., Clarke, S., Padget, J., Cliffe, O., De Vos, M.: Mutual dynamic adaptation of models and service enactment in alive. In: Proceedings of the 3rd International Models@ Runtime Workshop, pp. 26–35 (2008)Google Scholar
  169. 169.
    Stehle, E., Lynch, K., Shevertalov, M., Rorres, C., Mancoridis, S.: On the use of computational geometry to detect software faults at runtime. In: Proceedings of the 7th International Conference on Autonomic Computing, pp. 109–118. ACM (2010).  https://doi.org/10.1145/1809049.1809069
  170. 170.
    Szvetits, M., Zdun, U.: Enhancing root cause analysis with runtime models and interactive visualizations. In: Proceedings of the 8th Workshop on Models@run.time, pp. 38–49. CEUR-WS.org (2013)Google Scholar
  171. 171.
    Szvetits, M., Zdun, U.: Reusable event types for models at runtime to support the examination of runtime phenomena. In: ACM/IEEE 18th International Conference on Model Driven Engineering Languages and Systems (MODELS), 2015, pp. 4–13 (2015).  https://doi.org/10.1109/MODELS.2015.7338230
  172. 172.
    Szvetits, M., Zdun, U.: Systematic literature review of the objectives, techniques, kinds, and architectures of models at runtime. Softw. Syst. Model. 15(1), 31–69 (2016)CrossRefGoogle Scholar
  173. 173.
    Tallabaci, G., Souza, V.E.S.: Engineering adaptation with Zanshin: an experience report. In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’13, pp. 93–102. IEEE Press, Piscataway, NJ, USA (2013)Google Scholar
  174. 174.
    Tamura, G., Villegas, N.M., Müller, H.A., Duchien, L., Seinturier, L.: Improving context-awareness in self-adaptation using the dynamico reference model. In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’13, pp. 153–162. IEEE Press, Piscataway, NJ, USA (2013)Google Scholar
  175. 175.
    Tanvir Al Amin, M., Li, S., Rahman, M., Seetharamu, P., Wang, S., Abdelzaher, T., Gupta, I., Srivatsa, M., Ganti, R., Ahmed, R., Le, H.: Social trove: a self-summarizing storage service for social sensing. In: IEEE International Conference on Autonomic Computing (ICAC), 2015, pp. 41–50 (2015).  https://doi.org/10.1109/ICAC.2015.47
  176. 176.
    Taylor, R.N., Medvidovic, N., Oreizy, P.: Architectural styles for runtime software adaptation. In: Joint Working IEEE/IFIP Conference on Software Architecture, 2009 and European Conference on Software Architecture. WICSA/ECSA 2009, pp. 171–180. IEEE (2009). (Need to define for fundamental) Google Scholar
  177. 177.
    Vasconcelos, A., Werner, C.: Software architecture recovery based on dynamic analysis. In: XVIII Brazilian Symposium on Software Engineering, Workshop on Modern Software Maintenance (2004)Google Scholar
  178. 178.
    Vialon, A., Tei, K., Aknine, S.: Soft-goal approximation context awareness of goal-driven self-adaptive systems. In: 2017 IEEE International Conference on Autonomic Computing (ICAC), pp. 233–238 (2017).  https://doi.org/10.1109/ICAC.2017.25
  179. 179.
    Vogel, T., Giese, H.: A language for feedback loops in self-adaptive systems: executable runtime megamodels. In: Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, pp. 129–138 (2012).  https://doi.org/10.1109/SEAMS.2012.6224399
  180. 180.
    Vogel, T., Giese, H.: Language and framework requirements for adaptation models. In: Proceedings of the 6th Workshop on Models@run.time, pp. 1–12 (2011)Google Scholar
  181. 181.
    Vogel, T., Giese, H.: On unifying development models and runtime models. In: Götz, S., Bencomo, N., France R. (eds.) Proceedings of the 9th International Workshop on Models@run.time, pp. 5–10. CEUR-WS.org (2014)Google Scholar
  182. 182.
    Vogel, T., Seibel, A., Giese, H.: Toward megamodels at runtime. In: Proceedings of the 5th Workshop on Models@run.time, pp. 13–24 (2010)Google Scholar
  183. 183.
    Vogel, T., Giese, H.: Model-driven engineering of self-adaptive software with eurema. ACM Trans. Auton. Adapt. Syst. 8(4), 18:1–18:33 (2014).  https://doi.org/10.1145/2555612 CrossRefGoogle Scholar
  184. 184.
    Vrbaski, M., Mussbacher, G., Petriu, D., Amyot, D.: Goal models as run-time entities in context-aware systems. In: Proceedings of the 7th Workshop on Models@Run.Time, MRT ’12, pp. 3–8. ACM, New York, NY, USA (2012).  https://doi.org/10.1145/2422518.2422520
  185. 185.
    Walter, J., Marco, A.D., Spinner, S., Inverardi, P., Kounev, S.: Online learning of run-time models for performance and resource management in data centers. In: Self-Aware Computing Systems, pp. 507–528. IEEE Press, Los Alamitos, CA, USA (2017).  https://doi.org/10.1007/978-3-319-47474-8_17
  186. 186.
    Wätzold, S., Giese, H.: Classifying distributed self-* systems based on runtime models and their coupling. In: Götz, S., Bencomo, N., France, R. (eds.) Proceedings of the 9th International Workshop on Models@run.time, pp. 11–20. CEUR-WS.org (2014)Google Scholar
  187. 187.
    Weissbach, M., Chrszon, P., Springer, T., Schill, A.: Decentralized coordination of adaptations in distributed self-adaptive software systems. In: 2017 IEEE 11th International Conference on Self-Adaptive and Self-Organizing Systems (SASO) (2017)Google Scholar
  188. 188.
    Welsh, K., Bencomo, N., Sawyer, P., Whittle, J.: Self-explanation in adaptive systems based on runtime goal-based models, pp. 122–145 (2014).  https://doi.org/10.1007/978-3-662-44871-7_5
  189. 189.
    Welsh, K., Sawyer, P., Bencomo, N.: Run-time resolution of uncertainty. In: RE 2011, 19th IEEE International Requirements Engineering Conference, Trento, Italy, 29 August 2011–2 September 2011, pp. 355–356 (2011).  https://doi.org/10.1109/RE.2011.6051673
  190. 190.
    Weyns, D., Iftikhar, M.U., Söderlund, J.: Do external feedback loops improve the design of self-adaptive systems? A controlled experiment. In: Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’13, pp. 3–12. IEEE Press, Piscataway, NJ, USA (2013). http://dl.acm.org/citation.cfm?id=2487336.2487341
  191. 191.
    Wolfe, C., Graham, T.N., Phillips, W.G.: An incremental algorithm for high-performance runtime model consistency. In: Model Driven Engineering Languages and Systems, pp. 357–371. Springer (2009)Google Scholar
  192. 192.
    Zhang, X., Chen, X., Zhang, Y., Wu, Y., Yao, W., Huang, G., Lin, Q.: Runtime model based management of diverse cloud resources. In: Model-Driven Engineering Languages and Systems, pp. 572–588. Springer (2013)Google Scholar
  193. 193.
    Zhong, C., DeLoach, S.A.: Runtime models for automatic reorganization of multi-robot systems. In: Proceedings of the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, SEAMS ’11, pp. 20–29. ACM, New York, NY, USA (2011).  https://doi.org/10.1145/1988008.1988012

Copyright information

© Springer-Verlag GmbH Germany, part of Springer Nature 2019

Authors and Affiliations

  1. 1.Aston UniversityBirminghamUK
  2. 2.Technische Universität DresdenDresdenGermany
  3. 3.Stiftelsen SINTEFTrondheimNorway

Personalised recommendations