Evolving Software Systems for Self-Adaptation

There is a strong synergy between the concepts of evolution and adaptation in software engineering: software adaptation refers to both the current software being adapted and to the evolution process that leads to the new adapted software. Evolution changes for the purpose of adaptation are usually made at development or compile time, and are meant to handle predictable situations in the form of software change requests. On the other hand, software may also change and adapt itself based on the changes in its environment. Such adaptive changes are usually dynamic, and are suitable for dealing with unpredictable or temporary changes in the software’s operating environment. A promising solution for software adaptation is to develop self-adaptive software systems that can manage changes dynamically at runtime in a rapid and reliable way. One of the main advantages of self-adaptive software is its ability to manage the complexity that stems from highly dynamic and nondeterministic operating environments. If a selfadaptive software system has been engineered and used properly, it can greatly improve the cost-effectiveness of software change through its lifespan. However, in practice, many of the existing approaches towards self-adaptive software are rather expensive and may increase the overall system complexity, as well as subsequent future maintenance costs. This means that in many cases, self-adaptive software is not a good solution, because its development and maintenance costs are not paid off. The situation is even worse in the case of making current (legacy) systems adaptive. There are several factors that have an impact on the cost-effectiveness and usability of self-adaptive software; however the main objective of this thesis is to make a software system adaptive in a cost-effective way, while keeping the target adaptive software generic, usable, and evolvable, so as to support future changes. In order to effectively engineer and use self-adaptive software systems, in this thesis we propose a new conceptual model for identifying and specifying problem spaces in the context of self-adaptive software systems. Based on the foundations of this conceptual model, we propose a model-centric approach for engineering self-adaptive software by designing a generic adaptation framework and a supporting evolution process. This approach is particularly tailored to facilitate and simplify the process of evolving and adapting current (legacy) software towards runtime adaptivity. The conducted case studies reveal the applicability and effectiveness of this approach in bringing self-adaptive behaviour into non-adaptive applications that essentially demand adaptive behaviour to sustain.

[1]  Mary Shaw,et al.  Engineering Self-Adaptive Systems through Feedback Loops , 2009, Software Engineering for Self-Adaptive Systems.

[2]  Mary Shaw,et al.  Visibility of control in adaptive systems , 2008, ULSSIS '08.

[3]  Abhijit S. Pandya,et al.  A neural network approach for predicting software development faults , 1992, [1992] Proceedings Third International Symposium on Software Reliability Engineering.

[4]  Ladan Tahvildari,et al.  Change Support in Adaptive Software: A Case Study for Fine-Grained Adaptation , 2009, 2009 Sixth IEEE Conference and Workshops on Engineering of Autonomic and Autonomous Systems.

[5]  Wouter Joosen,et al.  A Reflective Framework for Fine-Grained Adaptation of Aspect-Oriented Compositions , 2008, SC@ETAPS.

[6]  Bing Wu,et al.  Legacy Information Systems: Issues and Directions , 1999, IEEE Softw..

[7]  Steve Rabin,et al.  AI Game Programming Wisdom , 2002 .

[8]  Wassiou Sitou,et al.  Towards Requirements Engineering for Context Adaptive Systems , 2007, 31st Annual International Computer Software and Applications Conference (COMPSAC 2007).

[9]  Mieczyslaw M. Kokar,et al.  Control theory-based foundations of self-controlling software , 1999, IEEE Intell. Syst..

[10]  Ladan Tahvildari,et al.  Adaptive Action Selection in Autonomic Software Using Reinforcement Learning , 2008, Fourth International Conference on Autonomic and Autonomous Systems (ICAS'08).

[11]  Harvey P. Siy,et al.  Predicting Fault Incidence Using Software Change History , 2000, IEEE Trans. Software Eng..

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

[13]  Arie van Deursen,et al.  A Systematic Survey of Program Comprehension through Dynamic Analysis , 2008, IEEE Transactions on Software Engineering.

[14]  Bradley R. Schmerl,et al.  Increasing System Dependability through Architecture-Based Self-Repair , 2002, WADS.

[15]  S. Lightstone,et al.  Foundations of Autonomic Computing Development , 2007, Fourth IEEE International Workshop on Engineering of Autonomic and Autonomous Systems (EASe'07).

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

[17]  Lawrence Chung,et al.  Process-Oriented Metrics for Software Architecture Adaptability , 2001, Proceedings Fifth IEEE International Symposium on Requirements Engineering.

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

[19]  Thomas Vogel,et al.  Comprehensive support for management of enterprise applications , 2008, 2008 IEEE/ACS International Conference on Computer Systems and Applications.

[20]  Mary Shaw,et al.  Prospects for an engineering discipline of software , 1990, IEEE Software.

[21]  Robert Hanmer,et al.  Patterns for Fault Tolerant Software , 2007 .

[22]  John Mylopoulos,et al.  Non-Functional Requirements in Software Engineering , 2000, International Series in Software Engineering.

[23]  Theodosius Dobzhansky,et al.  What is an Adaptive Trait? , 1956, The American Naturalist.

[24]  Ladan Tahvildari,et al.  Journal of Software Maintenance and Evolution: Research and Practice Improving Design Quality Using Meta-pattern Transformations: a Metric-based Approach , 2022 .

[25]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[26]  Jacques Noyé,et al.  A declarative approach for designing and developing adaptive components , 2000, Proceedings ASE 2000. Fifteenth IEEE International Conference on Automated Software Engineering.

[27]  David Lorge Parnas,et al.  Functional Documents for Computer Systems , 1995, Sci. Comput. Program..

[28]  Bashar Nuseibeh,et al.  Security Requirements Engineering: A Framework for Representation and Analysis , 2008, IEEE Transactions on Software Engineering.

[29]  Lawrence Chung,et al.  Tool support for engineering adaptability into software architecture , 2002, IWPSE '02.

[30]  Axel van Lamsweerde,et al.  Requirements Engineering: From System Goals to UML Models to Software Specifications , 2009 .

[31]  Hassan Gomaa,et al.  Software reconfiguration patterns for dynamic evolution of software architectures , 2004, Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004).

[32]  Don S. Batory,et al.  Evolving Object-Oriented Designs with Refactorings , 2004, Automated Software Engineering.

[33]  Pattie Maes,et al.  Situated agents can have goals , 1990, Robotics Auton. Syst..

[34]  James H. Cross,et al.  Reverse engineering and design recovery: a taxonomy , 1990, IEEE Software.

[35]  Per Jönsson,et al.  Impact Analysis : Organisational Views and Support Techniques , 2005 .

[36]  Audris Mockus,et al.  Predictors of customer perceived software quality , 2005, ICSE.

[37]  Jeff Magee,et al.  Analysing dynamic change in software architectures: a case study , 1998, Proceedings. Fourth International Conference on Configurable Distributed Systems (Cat. No.98EX159).

[38]  Dániel Varró,et al.  The model transformation language of the VIATRA2 framework , 2007, Sci. Comput. Program..

[39]  Marin Litoiu,et al.  Automating discovery of software tuning parameters , 2008, SEAMS '08.

[40]  Pentti Tarvainen.  Adaptability Evaluation of Software Architectures; A Case Study , 2007, 31st Annual International Computer Software and Applications Conference (COMPSAC 2007).

[41]  Ladan Tahvildari,et al.  StarMX: A framework for developing self-managing Java-based systems , 2009, 2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems.

[42]  Jing Ren,et al.  A neuro-fuzzy model for software cost estimation , 2003, Third International Conference on Quality Software, 2003. Proceedings..

[43]  Frank Buschmann,et al.  Pattern-Oriented Software Architecture, a Pattern Language for Distributed Computing , 2007 .

[44]  Stephen Fickas,et al.  Goal-Directed Requirements Acquisition , 1993, Sci. Comput. Program..

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

[46]  Keith H. Bennett,et al.  Approaches to program comprehension , 1991, J. Syst. Softw..

[47]  Mohamed E. Fayad.  Software Maintenance , 2005, IEEE Softw..

[48]  Giuliano Antoniol,et al.  Recovering Traceability Links between Code and Documentation , 2002, IEEE Trans. Software Eng..

[49]  John Mylopoulos,et al.  From object-oriented to goal-oriented requirements analysis , 1999, CACM.

[50]  Lawrence Chung,et al.  Metrics for Software Adaptability , 2001 .

[51]  Michael R. Lyu,et al.  Handbook of software reliability engineering , 1996 .

[52]  Tom Mens,et al.  A Taxonomy of Model Transformation , 2006, GRaMoT@GPCE.

[53]  Tassilo Horn,et al.  The GReTL Transformation Language , 2011, ICMT@TOOLS.

[54]  Mary Shaw,et al.  Software Engineering for Self-Adaptive Systems: A Research Roadmap , 2009, Software Engineering for Self-Adaptive Systems.

[55]  Jesper Andersson,et al.  FORMS: a formal reference model for self-adaptation , 2010, ICAC '10.

[56]  Bertrand Meyer,et al.  Object-Oriented Software Construction, 2nd Edition , 1997 .

[57]  Ji Zhang,et al.  Using temporal logic to specify adaptive program semantics , 2006, J. Syst. Softw..

[58]  Rodney A. Brooks,et al.  A Robust Layered Control Syste For A Mobile Robot , 2022 .

[59]  Meir M. Lehman,et al.  Software Evolution and Software Evolution Processes , 2002, Ann. Softw. Eng..

[60]  Walter Cazzola,et al.  Evaluation of Object-Oriented Reflective Models , 1998, ECOOP Workshops.

[61]  Jochen Ludewig,et al.  Models in software engineering - an introduction , 2004, Informatik Forschung und Entwicklung.

[62]  Michael L. Littman,et al.  Reinforcement learning for autonomic network repair , 2004 .

[63]  Gerald Tesauro,et al.  Reinforcement Learning in Autonomic Computing: A Manifesto and Case Studies , 2007, IEEE Internet Computing.

[64]  Ruven E. Brooks,et al.  Towards a Theory of the Comprehension of Computer Programs , 1983, Int. J. Man Mach. Stud..

[65]  Andres J. Ramirez,et al.  Design patterns for developing dynamically adaptive systems , 2010, SEAMS '10.

[66]  Leslie Lamport,et al.  The temporal logic of actions , 1994, TOPL.

[67]  Martin J. Shepperd,et al.  Comparing Software Prediction Techniques Using Simulation , 2001, IEEE Trans. Software Eng..

[68]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[69]  Seyed Masoud Sadjadi,et al.  Composing adaptive software , 2004, Computer.

[70]  Richard S. Sutton,et al.  Reinforcement Learning: An Introduction , 1998, IEEE Trans. Neural Networks.

[71]  Jesper Andersson,et al.  Modeling Dimensions of Self-Adaptive Software Systems , 2009, Software Engineering for Self-Adaptive Systems.

[72]  J. Steven Perry,et al.  Java Management Extensions , 2002 .

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

[74]  Michael Jackson,et al.  Software requirements & specifications , 1995 .

[75]  Heather Goldsby,et al.  Goal-oriented specification of adaptation requirements engineering in adaptive systems , 2006, SEAMS '06.

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

[77]  Joshua Kerievsky,et al.  Refactoring to Patterns , 2004, XP/Agile Universe.

[78]  Alexander Chatzigeorgiou,et al.  Predicting the probability of change in object-oriented systems , 2005, IEEE Transactions on Software Engineering.

[79]  Bart Selman,et al.  Encoding Plans in Propositional Logic , 1996, KR.

[80]  John A. Zinky,et al.  Building adaptive distributed applications with middleware and aspects , 2004, AOSD '04.

[81]  Sheela Ramanna,et al.  Rough Neural Network for Software Change Prediction , 2002, Rough Sets and Current Trends in Computing.

[82]  Alex M. Andrew,et al.  Reinforcement Learning: : An Introduction , 1998 .

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

[84]  Elaine J. Weyuker,et al.  Predicting the location and number of faults in large software systems , 2005, IEEE Transactions on Software Engineering.

[85]  Richard C. Holt,et al.  The top ten list: dynamic fault prediction , 2005, 21st IEEE International Conference on Software Maintenance (ICSM'05).

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

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

[88]  Seyed Masoud Sadjadi,et al.  TRAP/J: Transparent Generation of Adaptable Java Programs , 2004, CoopIS/DOA/ODBASE.

[89]  Holger H. Hoos,et al.  Programming by optimization , 2012, Commun. ACM.

[90]  Tom Mens,et al.  A survey of software refactoring , 2004, IEEE Transactions on Software Engineering.

[91]  Anneliese Amschler Andrews,et al.  Industrial experience with an integrated code comprehension model , 1995, Softw. Eng. J..

[92]  Jürgen Dingel,et al.  A survey of self-management in dynamic software architecture specifications , 2004, WOSS '04.

[93]  Martin Schulz,et al.  Dynamic Binary Instrumentation and Data Aggregation on Large Scale Systems , 2007, International Journal of Parallel Programming.

[94]  James R. Cordy,et al.  The TXL source transformation language , 2006, Sci. Comput. Program..

[95]  Keith H. Bennett,et al.  Software maintenance and evolution: a roadmap , 2000, ICSE '00.

[96]  Jim Dowling,et al.  The Decentralised Coordination of Self-Adaptive Components for Autonomic Distributed Systems , 2005 .

[97]  Laurence Duchien,et al.  JAC: an aspect‐based distributed dynamic framework , 2004, Softw. Pract. Exp..

[98]  Anneke Kleppe,et al.  MDA explained - the Model Driven Architecture: practice and promise , 2003, Addison Wesley object technology series.

[99]  Nelson Weiderman,et al.  Approaches to Legacy System Evolution. , 1997 .

[100]  José M. Troya,et al.  Specification and Refinement of Dynamic Software Architectures , 1999, WICSA.

[101]  E. B. Swanson,et al.  Software maintenance management , 1980 .

[102]  Katsuhiko Ogata,et al.  Modern Control Engineering , 1970 .

[103]  Ladan Tahvildari,et al.  A Weighted Voting Mechanism for Action Selection Problem in Self-Adaptive Software , 2007, First International Conference on Self-Adaptive and Self-Organizing Systems (SASO 2007).

[104]  Lynne Blair,et al.  Using Dynamic Aspect-Oriented Programming to Implement an Autonomic System , 2004 .

[105]  M. Salehie,et al.  Autonomic computing , 2005, ACM SIGSOFT Softw. Eng. Notes.

[106]  Debzani Deb,et al.  Towards Autonomic Computing: Injecting Self-Organizing and Self-Healing Properties into Java Programs , 2006, SoMeT.

[107]  Gerardo Canfora,et al.  Achievements and challenges in software reverse engineering , 2011, Commun. ACM.

[108]  T. Dobzhansky.  Genetics and the Origin of Species , 1937 .

[109]  Bashar Nuseibeh,et al.  Specifying Monitoring and Switching Problems in Context , 2007, 15th IEEE International Requirements Engineering Conference (RE 2007).

[110]  Barry W. Boehm,et al.  Software Engineering Economics , 1993, IEEE Transactions on Software Engineering.

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

[112]  Jean Bézivin,et al.  ATL: a QVT-like transformation language , 2006, OOPSLA '06.

[113]  Gabriele Taentzer,et al.  Dynamic Change Management by Distributed Graph Transformation: Towards Configurable Distributed Systems , 1998, TAGT.

[114]  Andreas Zeller,et al.  Mining version histories to guide software changes , 2005, Proceedings. 26th International Conference on Software Engineering.

[115]  Daniel Hoffman,et al.  Commonality and Variability in Software Engineering , 1998, IEEE Softw..

[116]  Thomas A. Corbi,et al.  The dawning of the autonomic computing era , 2003, IBM Syst. J..

[117]  Anneliese Amschler Andrews,et al.  Program Comprehension During Software Maintenance and Evolution , 1995, Computer.

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

[119]  Priya Narasimhan,et al.  Retrofitting networked applications to add autonomic reconfiguration , 2005, ACM SIGSOFT Softw. Eng. Notes.

[120]  Lawrence Chung,et al.  Software architecture adaptability: an NFR approach , 2001, IWPSE '01.

[121]  Taghi M. Khoshgoftaar,et al.  Predictive modeling of software quality for very large telecommunications systems , 1996, Proceedings of ICC/SUPERCOMM '96 - International Conference on Communications.

[122]  Hausi A. Müller,et al.  A framework for evaluating quality-driven self-adaptive software systems , 2011, SEAMS '11.

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

[124]  Evans,et al.  Domain-driven design , 2003 .

[125]  Stéphane Ducasse,et al.  Modeling history to analyze software evolution , 2006, J. Softw. Maintenance Res. Pract..

[126]  Elliot Soloway,et al.  Mental models and software maintenance , 1986, J. Syst. Softw..

[127]  Caro Lucas,et al.  A GENETIC ALGORITHM APPROACH TO DESIGN EVOLUTION USING DESIGN PATTERN TRANSFORMATION , 2010 .

[128]  Emerson Murphy-Hill,et al.  Programmer friendly refactoring tools , 2009 .

[129]  Gail E. Kaiser,et al.  Retrofitting Autonomic Capabilities onto Legacy Systems , 2006, Cluster Computing.

[130]  L. Dooley.  Case Study Research and Theory Building , 2002 .

[131]  Meir M. Lehman,et al.  Laws of Software Evolution Revisited , 1996, EWSPT.

[132]  Shawn A. Bohner,et al.  Extending software change impact analysis into COTS components , 2002, 27th Annual NASA Goddard/IEEE Software Engineering Workshop, 2002. Proceedings..

[133]  Xia Liu,et al.  Study on application of a quantitative evaluation approach for software architecture adaptability , 2005, Fifth International Conference on Quality Software (QSIC'05).

[134]  Barry W. Boehm,et al.  Software Engineering Economics (Reprint) , 2002, Software Pioneers.

[135]  Tom Mens,et al.  Towards a taxonomy of software change , 2005, J. Softw. Maintenance Res. Pract..

[136]  Krzysztof Czarnecki,et al.  Classification of Model Transformation Approaches , 2003 .

[137]  Ladan Tahvildari,et al.  Temporal Software Change Prediction Using Neural Networks , 2009, Int. J. Softw. Eng. Knowl. Eng..

[138]  Julio Rosenblatt,et al.  DAMN: a distributed architecture for mobile navigation , 1997, J. Exp. Theor. Artif. Intell..

[139]  James R. Cordy,et al.  STAC: software tuning panels for autonomic control , 2006, CASCON.

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

[141]  Luciano Baresi,et al.  Fuzzy Goals for Requirements-Driven Adaptation , 2010, 2010 18th IEEE International Requirements Engineering Conference.

[142]  Jean-Marie Favre,et al.  Towards a Basic Theory to Model Model Driven Engineering , 2004 .

[143]  David Garlan,et al.  Specifying and Analyzing Dynamic Software Architectures , 1998, FASE.

[144]  Yijun Yu,et al.  Towards requirements-driven autonomic systems design , 2005, ACM SIGSOFT Softw. Eng. Notes.

[145]  Frederick P. Brooks,et al.  No Silver Bullet: Essence and Accidents of Software Engineering , 1987 .

[146]  Grace A. Lewis,et al.  Modernizing Legacy Systems - Software Technologies, Engineering Processes, and Business Practices , 2003, SEI series in software engineering.

[147]  Jürgen Ebert,et al.  Meta-CASE in Practice: a Case for KOGGE , 1997, CAiSE.

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

[149]  Jürgen Ebert,et al.  Reverse Engineering Using Graph Queries , 2010, Graph Transformations and Model-Driven Engineering.

[150]  Michael Jackson,et al.  A Reference Model for Requirements and Specifications , 2000, IEEE Softw..

[151]  William F. Opdyke,et al.  Refactoring object-oriented frameworks , 1992 .

[152]  Ladan Tahvildari,et al.  A Quality-Driven Approach to Enable Decision-Making in Self-Adaptive Software , 2007, 29th International Conference on Software Engineering (ICSE'07 Companion).

[153]  Karl J. Lieberherr,et al.  Customizing Adaptive Software to Object-Oriented Software Using Grammars , 1994, Int. J. Found. Comput. Sci..

[154]  Franck Fleurey,et al.  A Domain Specific Modeling Language Supporting Specification, Simulation and Execution of Dynamic Adaptive Systems , 2009, MoDELS.

[155]  Ladan Tahvildari,et al.  Coordinating Self-Healing and Self-Optimizing Disciplines in Autonomic Elements , 2006 .

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

[157]  Gustavo Alonso,et al.  Dynamic weaving for aspect-oriented programming , 2002, AOSD '02.

[158]  Ned Chapin,et al.  Types of software evolution and software maintenance , 2001, J. Softw. Maintenance Res. Pract..

[159]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[160]  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).

[161]  Peter Norvig,et al.  Artificial Intelligence: A Modern Approach , 1995 .

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

[163]  Anas N. Al-Rabadi,et al.  A comparison of modified reconstructability analysis and Ashenhurst‐Curtis decomposition of Boolean functions , 2004 .

[164]  Václav Rajlich,et al.  JRipples: a tool for program comprehension during incremental change , 2005, 13th International Workshop on Program Comprehension (IWPC'05).

[165]  Jürgen Ebert,et al.  Graph Technology in Reverse Engineering: The TGraph Approach , 2008, Workshop Software Reengineering.

[166]  Jeffrey O. Kephart,et al.  An artificial intelligence perspective on autonomic computing policies , 2004, Proceedings. Fifth IEEE International Workshop on Policies for Distributed Systems and Networks, 2004. POLICY 2004..

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

[168]  Ji Zhang,et al.  The Four Levels of Requirements Engineering for and in Dynamic Adaptive Systems , 2005 .

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

[170]  Marin Litoiu,et al.  Identifying implicitly declared self-tuning behavior through dynamic analysis , 2009, 2009 ICSE Workshop on Software Engineering for Adaptive and Self-Managing Systems.