Fine-Grained Software Evolution Using UML Activity and Class Models

Modern software systems that play critical roles in society's infrastructures are often required to change at runtime so that they can continuously provide essential services in the dynamic environments they operate in. Updating open, distributed software systems at runtime is very challenging. Using runtime models as an interface for updating software at runtime can help developers manage the complexity of updating software while it is executing. In this work we describe an approach to updating Java software at runtime through the use of runtime models consisting of UML class and activity diagrams. Changes to models are turned into changes on Java source code, which is then propagated to the runtime system using the JavAdaptor technology. In particular, the presented approach permits in-the-small software changes, i.e., changes at the code statement level, as opposed to in-the-large changes, i.e., changes at the component level. We present a case study that demonstrates the major aspects of the approach and its use.

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

[2]  Naoyasu Ubayashi,et al.  Pointcut-based architectural interface for bridging a gap between design and implementation , 2009, RAM-SE@ECOOP.

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

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

[5]  Michael Hicks,et al.  Dynamic software updating , 2005 .

[6]  Eleni Stroulia,et al.  Differencing logical UML models , 2007, Automated Software Engineering.

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

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

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

[10]  Jennifer Pérez,et al.  A Reflective Approach for Supporting the Dynamic Evolution of Component Types , 2009, 2009 14th IEEE International Conference on Engineering of Complex Computer Systems.

[11]  Bradley R. Schmerl,et al.  Rainbow: Architecture-Based Self-Adaptation with Reusable Infrastructure , 2004, Computer.

[12]  Bernhard Rumpe,et al.  ADDiff: semantic differencing for activity diagrams , 2011, ESEC/FSE '11.

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

[14]  Gunter Saake,et al.  Co-evolving application code and design models by exploiting meta-data , 2007, SAC '07.

[15]  Ladan Tahvildari,et al.  Self-adaptive software: Landscape and research challenges , 2009, TAAS.

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

[17]  Alessandro Orso,et al.  A technique for dynamic updating of Java software , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[18]  Michael Hicks,et al.  Mutatis Mutandis : Safe and predictable dynamic software updating , 2007 .

[19]  Jeff Magee,et al.  Self-Managed Systems: an Architectural Challenge , 2007, Future of Software Engineering (FOSE '07).

[20]  Robert B. France,et al.  Fine-Grained Semi-automated Runtime Evolution , 2014, Models@run.time@Dagstuhl.

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

[22]  Edoardo Vacchi,et al.  @Java: annotations in freedom , 2013, SAC '13.

[23]  Gunter Saake,et al.  JavAdaptor—Flexible runtime updates of Java applications , 2013, Softw. Pract. Exp..

[24]  David Notkin,et al.  Software Reflexion Models: Bridging the Gap between Design and Implementation , 2001, IEEE Trans. Software Eng..