Modern software systems are increasingly long-lived. In order to gracefully evolve these systems as they address new requirements, developers need to navigate effectively between domain concepts and the code that addresses those domains. One of the original promises of object-orientation was that the same object-oriented models would be used throughout requirements analysis, design and implementation. Software systems today however are commonly constructed from a heterogeneous “language soup” of mainstream code and dedicated DSLs addressing a variety of application and technical domains. Has object-oriented programming outlived its purpose?

In this essay we argue that we need to rethink the original goals of object-orientation and their relevance for modern software development. We propose as a driving maxim, “Programming is Modeling,” and explore what this implies for programming languages, tools and environments. In particular, we argue that: (1) source code should serve not only to specify an implementation of a software system, but should encode a queryable and manipulable model of the application and technical domains concerned; (2) IDEs should exploit these domain models to enable inexpensive browsing, querying and analysis by developers; and (3) barriers between the code base, the running application, and the software ecosystem at large need to be broken down, and their connections exploited and monitored to support developers in comprehension and evolution tasks.


Domain Model Domain Concept Technical Debt Software Ecosystem Mining Software Repository 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.



We thank Mircea Lungu for his comments on an early draft of this essay. We also gratefully acknowledge the financial support of the Swiss National Science Foundation for the project “Agile Software Analysis” (SNSF project No. 200020-162352, Jan 1, 2016 - Dec. 30, 2018), and its predecessor, “Agile Software Assessment” (SNSF project No. 200020-144126/1, Jan 1, 2013 - Dec. 30, 2015).


  1. 1.
    Achermann, F., Nierstrasz, O.: Applications = components + scripts—a tour of piccola. In: Aksit, M. (ed.) Software Architectures and Component Technology, pp. 261–292. Kluwer, Alphen aan den Rijn (2001)Google Scholar
  2. 2.
    Caracciolo, A., Chiş, A., Spasojević, B., Lungu, M.: Pangea: a workbench for statically analyzing multi-language software corpora. In: 2014 IEEE 14th International Working Conference on Source Code Analysis and Manipulation (SCAM), pp. 71–76. IEEE, September 2014Google Scholar
  3. 3.
    Caracciolo, A., Lungu, M., Nierstrasz, O.: A unified approach to architecture conformance checking. In: Proceedings of the 12th Working IEEE/IFIP Conference on Software Architecture (WICSA), pp. 41–50. ACM Pres, May 2015Google Scholar
  4. 4.
    Chiş, A., Denker, M., Gîrba, T., Nierstrasz, O.: Practical domain-specific debuggers using the moldable debugger framework. Comput. Lang. Syst. Struct. 44(Part A), 89–113 (2015). Special issue on the 6th and 7th International Conference on Software Language Engineering (SLE 2013 and SLE 2014)Google Scholar
  5. 5.
    Chiş, A., Gîrba, T., Nierstrasz, O., Syrel, A.: The moldable inspector. In: Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software. ACM, New York (2015) (Onward! 2015, page to appear)Google Scholar
  6. 6.
    Combemale, B., Deantoni, J., Baudry, B., France, R.B., Jézéquel, J.-M., Gray, J.: Globalizing modeling languages. Computer 47(6), 68–71 (2014)CrossRefGoogle Scholar
  7. 7.
    Fritz, T., Murphy, G.C.: Using information fragments to answer the questions developers ask. In: Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering, vol. 1, ICSE 2010, pp. 175–184. ACM, New York (2010)Google Scholar
  8. 8.
    Kay, A.C.: The early history of Smalltalk. In: ACM SIGPLAN Notices, vol. 28, pp. 69–95. ACM Press, March 1993Google Scholar
  9. 9.
    Klint, P., van der Storm, T., Vinju, J.: RASCAL: A domain specific language for source code analysis and manipulation. In: Ninth IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2009, pp. 168–177 (2009)Google Scholar
  10. 10.
    Kurš, J., Lungu, M., Nierstrasz, O.: Bounded seas. Comput. Lang. Syst. Struct. 44(Part A), 114–140 (2015). Special issue on the 6th and 7th International Conference on SoftwareLanguage Engineering (SLE 2013 and {SLE} 2014)Google Scholar
  11. 11.
    Maloney, J.H., Smith, R.B.: Directness and liveness in the morphic user interface construction environment. In: Proceedings of the 8th Annual ACM Symposium on User Interface and Software Technology, UIST 1995, pp. 21–28. ACM, New York (1995)Google Scholar
  12. 12.
    Nierstrasz, O., Ducasse, S., Gîrba, T.: The story of Moose: an agile reengineering environment. In: Proceedings of the European Software Engineering Conference (ESEC/FSE 2005), pp. 1–10. ACM Press, New York, September 2005 (invited paper)Google Scholar
  13. 13.
    Nierstrasz, O., Kurš, J.: Parsing for agile modeling. Sci. Comput. Program. 97(Part 1), 150–156 (2015)CrossRefGoogle Scholar
  14. 14.
    Renggli, L., Ducasse, S., Gîrba, T., Nierstrasz, O.: Practical dynamic grammars for dynamic languages. In: 4th Workshop on Dynamic Languages and Applications (DYLA 2010), Malaga, Spain, pp. 1–4, June 2010Google Scholar
  15. 15.
    Renggli, L., Gîrba, T., Nierstrasz, O.: Embedding languages without breaking tools. In: D’Hondt, T. (ed.) ECOOP 2010. LNCS, vol. 6183, pp. 380–404. Springer, Heidelberg (2010)CrossRefGoogle Scholar
  16. 16.
    Sillito, J., Murphy, G.C., De Volder, K.: Asking and answering questions during a programming change task. IEEE Trans. Softw. Eng. 34, 434–451 (2008)CrossRefGoogle Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg 2016

Authors and Affiliations

  1. 1.Software Composition GroupUniversity of BernBernSwitzerland

Personalised recommendations