Advertisement

Software & Systems Modeling

, Volume 18, Issue 5, pp 2821–2842 | Cite as

A Multi-Paradigm Modelling approach to live modelling

  • Yentl Van TendelooEmail author
  • Simon Van Mierlo
  • Hans Vangheluwe
Regular Paper

Abstract

To develop complex systems and tackle their inherent complexity, (executable) modelling takes a prominent role in the development cycle. But whereas good tool support exists for programming, tools for executable modelling have not yet reached the same level of functionality and maturity. In particular, live programming is seeing increasing support in programming tools, allowing users to dynamically change the source code of a running application. This significantly reduces the edit–compile–debug cycle and grants the ability to gauge the effect of code changes instantly, aiding in debugging and code comprehension in general. In the modelling domain, however, live modelling only has limited support for a few formalisms. In this paper, we propose a Multi-Paradigm Modelling approach to add liveness to modelling languages in a generic way, which is reusable across multiple formalisms. Live programming concepts and techniques are transposed to (domain-specific) executable modelling languages, clearly distinguishing between generic and language-specific concepts. To evaluate our approach, live modelling is implemented for three modelling languages, for which the implementation of liveness substantially differs. For all three cases, the exact same structured process was used to enable live modelling, which only required a “sanitization” operation to be defined.

Keywords

Live programming Live modelling Debugging Multi-Paradigm Modelling 

Notes

Acknowledgements

This work was partly funded by PhD fellowships from the Research Foundation—Flanders (FWO) and Agency for Innovation by Science and Technology in Flanders (IWT). This research was partially supported by Flanders Make vzw, the strategic research centre for the manufacturing industry.

References

  1. 1.
    Armstrong, J.: The development of Erlang. In: Proceedings of the Second ACM SIGPLAN International Conference on Functional Programming (ICFP’97), pp. 196–203. ACM, New York (1997).  https://doi.org/10.1145/258948.258967
  2. 2.
    Bousse, E., Corley, J., Combemale, B., Gray, J., Baudry, B.: Supporting efficient and advanced omniscient debugging for xDSMLs. In: Proceedings of the 2015 ACM SIGPLAN International Conference on Software Language Engineering (SLE 2015), pp. 137–148. ACM, New York (2015)Google Scholar
  3. 3.
    Bousse, E., Mayerhofer, T., Combemale, B., Baudry, B.: A generative approach to define rich domain-specific trace metamodels. In: 11th European Conference on Modelling Foundations and Applications (ECMFA). L’Aquila, Italy (2015)Google Scholar
  4. 4.
    Brunet, G., Chechik, M., Easterbrook, S., Nejati, S., Niu, N., Sabetzadeh, M.: A manifesto for model merging. In: Proceedings of the 2006 International Workshop on Global Integrated Model Management (GaMMa’06), pp. 5–12. ACM, New York (2006).  https://doi.org/10.1145/1138304.1138307
  5. 5.
    Burckhardt, S., Fähndrich, M., Kato, J.: It’s alive! continuous feedback in UI programming. In: Proceedings of PLDI’13, pp. 95–104 (2013)Google Scholar
  6. 6.
    Burnett, M.M., Atwood, J.W., Jr., Welch, Z.T.: Implementing level 4 liveness in declarative visual programming languages. In: Proceedings of Visual Languages ’98, pp. 126–133 (1998)Google Scholar
  7. 7.
    Cellier, F.E.: Continuous System Modeling. Springer, Secaucus (1991)CrossRefzbMATHGoogle Scholar
  8. 8.
    Chiş, A., Denker, M., Gîrba, T., Nierstrasz, O.: Practical domain-specific debuggers using the moldable debugger framework. Comput. Lang. Syst. Struct. 44(A), 89–113 (2015)Google Scholar
  9. 9.
    Czaplicki, E.: Elm: Concurrent FRP for Functional GUIs. https://www.seas.harvard.edu/sites/default/files/files/archived/Czaplicki.pdf (2012)
  10. 10.
    Déva, G., Kovács, G.F., Ancsin, A.: Textual, executable, translatable UML. In: Proceedings of the Workshop on OCL and Textual Modeling Applications and Case Studies, pp. 3–12 (2014)Google Scholar
  11. 11.
    Edwards, J.: Subtext: Uncovering the simplicity of programming. In: Proceedings of OOPSLA’05, pp. 505–518 (2005)Google Scholar
  12. 12.
    Fabry, R.S.: How to design a system in which modules can be changed on the fly. In: Proceedings of ICSE’76, pp. 470–476 (1976)Google Scholar
  13. 13.
    Favre, J.M.: Languages evolve too! changing the software time scale. In: Proceedings of the Eighth International Workshop on Principles of Software Evolution, IWPSE’05, pp. 33–44. IEEE Computer Society, Washington, DC, USA (2005).  https://doi.org/10.1109/IWPSE.2005.22
  14. 14.
    Goldberg, A., Robson, D.: Smalltalk-80: The Language and Its Implementation. Addison-Wesley Longman, Boston (1983)zbMATHGoogle Scholar
  15. 15.
    Grönniger, H., Krahn, H., Rumpe, B., Schindler, M., Völkel, S.: Text-based modeling. In: Proceedings of the 4th International Workshop on Software Language Engineering (2007)Google Scholar
  16. 16.
    Hancock, C.M.: Real-Time Programming and the Big Ideas of Computational Literacy. Ph.D. thesis, Massachusetts Institute of Technology (2003)Google Scholar
  17. 17.
    Hopcroft, J.E., Motwani, R., Ullman, J.D.: Introduction to Automata Theory, Languages, and Computation, 3rd edn. Addison-Wesley Longman, Boston (2006)zbMATHGoogle Scholar
  18. 18.
    Kelly, S., Tolvanen, J.P.: Domain-Specific Modeling: Enabling Full Code Generation. Wiley, New York (2008)CrossRefGoogle Scholar
  19. 19.
    Kuhn, A., Murphy, G.C., Thompson, C.A.: An exploratory study of forces and frictions affecting large-scale model-driven development. In: Proceedings of the 15th International Conference on Model Driven Engineering Languages and Systems, MODELS’12, pp. 352–367. Springer, Berlin (2012).  https://doi.org/10.1007/978-3-642-33666-9_23
  20. 20.
    Kühne, T.: Matters of (meta-)modeling. Softw. Syst. Model. 5, 369–385 (2006)CrossRefGoogle Scholar
  21. 21.
    Lieberman, H., Fry, C.: Bridging the gulf between code and behavior in programming. In: Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, pp. 480–486 (1995)Google Scholar
  22. 22.
    Lindeman, R.T., Kats, L.C.L., Visser, E.: Declaratively defining domain-specific language debuggers. In: Proceedings of the 10th International Conference on Generative Programming and Component Engineering, pp. 127–136 (2011)Google Scholar
  23. 23.
    Lucio, L., Mustafiz, S., Denil, J., Vangheluwe, H., Jukss, M.: FTG+PM: An integrated framework for investigating model transformation chains. In: SDL 2013: Model-Driven Dependability Engineering, Lecture Notes in Computer Science, vol. 7916, pp. 182–202. Springer, Berlin (2013).  https://doi.org/10.1007/978-3-642-38911-5_11
  24. 24.
    Mannadiar, R., Vangheluwe, H.: Debugging in domain-specific modelling. In: Malloy, B., Staab, S., Brand, M. (Eds.) Software Language Engineering, Lecture Notes in Computer Science, vol. 6563, pp. 276–285. Springer, Berlin(2011).  https://doi.org/10.1007/978-3-642-19440-5_17
  25. 25.
    McDirmid, S.: Living it up with a live programming language. In: Proceedings of OOPSLA’07, pp. 623–638 (2007)Google Scholar
  26. 26.
    McDirmid, S.: Usable live programming. In: Proceedings of Onward! 2013, pp. 53–61 (2013)Google Scholar
  27. 27.
    Mellor, S.J., Balcer, M.J.: Executable UML: A Foundation for Model-Driven Architecture. Addison-Wesley, Reading (2002)Google Scholar
  28. 28.
    Meyers, B., Vangheluwe, H.: A framework for evolution of modelling languages. Sci. Comput. Program. 76(12), 1223–1246 (2011).  https://doi.org/10.1016/j.scico.2011.01.002 CrossRefGoogle Scholar
  29. 29.
    Morin, B., Barais, O., Jezequel, J.M., Fleurey, F., Solberg, A.: Models@ run.time to support dynamic adaptation. Computer 42(10), 44–51 (2009).  https://doi.org/10.1109/MC.2009.327
  30. 30.
    Mosterman, P.J., Vangheluwe, H.: Computer automated multi-paradigm modeling: an introduction. Simulation 80(9), 433–450 (2004).  https://doi.org/10.1177/0037549704050532 CrossRefGoogle Scholar
  31. 31.
    Murata, T.: Petri nets: properties, analysis and applications. Proc. IEEE 77(4), 541–580 (1989).  https://doi.org/10.1109/5.24143 CrossRefGoogle Scholar
  32. 32.
    National Science Foundation: Cyber-Physical Systems (CPS). https://www.nsf.gov/pubs/2016/nsf16549/nsf16549.pdf (2016). Document number: nsf16549
  33. 33.
    Oakes, B.: Optimizing Simulink Models. Tech. Rep’. CS-TR-2014.5, McGill University (2014)Google Scholar
  34. 34.
    Pavletic, D., Voelter, M., Raza, S.A., Kolb, B., Kehrer, T.: Extensible debugger framework for extensible languages. Lect. Notes Comput. Sci. 9111, 33–49 (2015)CrossRefGoogle Scholar
  35. 35.
    Petre, M.: Why looking isn’t always seeing: readership skills and graphical programming. Commun. ACM 38(6), 33–44 (1995).  https://doi.org/10.1145/203241.203251 CrossRefGoogle Scholar
  36. 36.
    Rohr, M., Boskovic, M., Giesecke, S., Hasselbring, W.: Model-driven development of self-managing software systems. In: Proceedings of the Models at run.time Workshop Co-located with the ACM/IEEE 9th International Conference Models 2006 (2006)Google Scholar
  37. 37.
    Sandewall, E.: Programming in an interactive environment: the “lisp” experience. ACM Comput. Surv. 10(1), 35–71 (1978).  https://doi.org/10.1145/356715.356719 CrossRefzbMATHGoogle Scholar
  38. 38.
    Sendall, S., Kozaczynski, W.: Model transformation: the heart and soul of model-driven software development. IEEE Softw. 20(5), 42–45 (2003).  https://doi.org/10.1109/MS.2003.1231150 CrossRefGoogle Scholar
  39. 39.
    Sorensen, A., Gardner, H.: Programming with time: cyber-physical programming with Impromptu. In: Proceedings of Onward! 2010, pp. 822–834 (2010)Google Scholar
  40. 40.
    Stewart, D., Chakravarty, M.M.: Dynamic applications from the ground up. In: Proceedings of the 2005 ACM SIGPLAN workshop on Haskell, pp. 27–38 (2005)Google Scholar
  41. 41.
    Tanimoto, S.L.: VIVA: a visual language for image processing. J. Vis. Lang. Comput. 1, 127–139 (1990)CrossRefGoogle Scholar
  42. 42.
    Ungar, D., Smith, R.B.: Self: the power of simplicity. SIGPLAN Not. 22(12), 227–242 (1987).  https://doi.org/10.1145/38807.38828 CrossRefGoogle Scholar
  43. 43.
    van Rozen, R., van der Storm, T.: Towards live domain-specific languages: from text differencing to adapting models at run time. Softw. Syst. Model. 1–18 (2017)Google Scholar
  44. 44.
    van der Storm, T.: Semantic deltas for live DSL environments. In: Proceedings of the 1st International Workshop on Live Programming, LIVE’13, pp. 35–38. IEEE Press, Piscataway, NJ, USA (2013)Google Scholar
  45. 45.
    Van Mierlo, S.: Explicitly modelling model debugging environments. In: Proceedings of the ACM Student Research Competition at MODELS 2015 Co-located with the ACM/IEEE 18th International Conference MODELS 2015, pp. 24–29 (2015)Google Scholar
  46. 46.
    Van Mierlo, S., Van Tendeloo, Y., Vangheluwe, H.: Debugging Parallel DEVS. Simulation 93(4), 285–306 (2017).  https://doi.org/10.1177/0037549716658360 CrossRefGoogle Scholar
  47. 47.
    Van Tendeloo, Y.: Foundations of a multi-paradigm modelling tool. In: Proceedings of the ACM Student Research Competition at MODELS 2015 Co-located with the ACM/IEEE 18th International Conference MODELS 2015 (2015)Google Scholar
  48. 48.
    Van Tendeloo, Y., Vangheluwe, H.: The Modelverse: a tool for multi-paradigm modelling and simulation. In: Proceedings of the 2017 Winter Simulation Conference, WSC 2017, pp. 944 – 955. IEEE (2017)Google Scholar
  49. 49.
    Vangheluwe, H., de Lara, J., Mosterman, P.J.: An introduction to Multi-paradigm Modelling and Simulation. In: Proceedings of the AIS’2002 Conference (AI, Simulation and Planning in High Autonomy Systems), pp. 9 – 20 (2002)Google Scholar
  50. 50.
    Vangheluwe, H., Riegelhaupt, D., Mustafiz, S., Denil, J., Van Mierlo, S.: Explicit modelling of a CBD experimentation environment. In: Proceedings of the 2014 Symposium on Theory of Modeling and Simulation—DEVS, TMS/DEVS’14, Part of the Spring Simulation Multi-Conference, pp. 379–386. Society for Computer Simulation International (2014)Google Scholar
  51. 51.
    Wu, H., Gray, J., Mernik, M.: Grammar-driven generation of domain-specific language debuggers. Softw. Pract. Exp. 38(10), 1073–1103 (2008)CrossRefGoogle Scholar
  52. 52.
    Zeller, A.: Why Programs Fail: A Guide to Systematic Debugging. Morgan Kaufmann, San Francisco (2005)Google Scholar

Copyright information

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

Authors and Affiliations

  • Yentl Van Tendeloo
    • 1
    Email author
  • Simon Van Mierlo
    • 1
  • Hans Vangheluwe
    • 1
    • 2
    • 3
  1. 1.University of AntwerpAntwerpBelgium
  2. 2.Flanders Make vzwLommelBelgium
  3. 3.McGill UniversityMontrealCanada

Personalised recommendations