FLEXX: Designing Software for Change Through Evolvable Architectures

  • S. Rank
  • K. Bennett
  • S. Glover


Software-based systems need to evolve, to meet the changing requirements of their users and to maintain market competitiveness. The design of the system architecture is a key component in allowing this sort of flexibility. A project, named FLEXX, is described which addresses this general problem. The aim of the project is to explore flexible architectures that can cope with unexpected requirements changes. Evolution is separated into two forms: integration evolution, in which new capabilities are required that must be integrated with existing capabilities; and reconfiguration evolution, in which new capabilities are in the form of changes to existing instances. The major challenges are concerned with integration evolution, and this is the focus of FLEXX. A general framework and model for software evolution and architectures is presented. The specific problem we are using to understand the role of architectural design is dynamic update evolution. In a largescale distributed system, it is the requirement to replace, add or extend a component without halting the execution of the system’s code yet maintaining system properties. The new component may have different functional and/or interface properties. We present two novel components of the project: the use of reflection to establish a framework for flexible architectures; and dynamic automatic update of component versions in a pipe and filter architecture. A short example is used to illustrate the solution. The project has completed 18 months of its three-year period, and we summarise the current state and planned direction.


Software Architecture Ripple Effect Software Maintenance Architectural Style Output Stream 
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.


Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.


  1. Bennett, K.H., Rajlich, V.T., Wilde, N. and Rank S. (1999). Report on a workshop on software change and evolution. ACM Software Engineering Notes, accepted for publication.Google Scholar
  2. Buchi, M. and Weck, W. (1997). A plea for grey-box components. Technical Report 122, Turku Centre for Computer Science, Lemmink’aisenkatu 14A, FIN-20520 Turku, Finland.Google Scholar
  3. Brand, S. (1994). How Buildings Learn. Viking Books.Google Scholar
  4. Brooks, F. (1995). The Mythical Man-Month: Essays on Software Engineering. Addison-Wesley.Google Scholar
  5. Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P. and Stal, M. (1996). Pattern-Oriented Software Architecture: A System of Patterns. Wiley.Google Scholar
  6. Cazzola, W., Savigni, A., Sosio, A. and Tisato, E (1998). Architectural reflection: Bridging the gap between a running system and its specification. In Proceedings of the Second Euromicro Conference on Software Maintenance and Reengineering, Florence, Italy.Google Scholar
  7. Cusumano, M.A. and Selby, R.W. (1997). Microsoft Secrets. HarperCollins.Google Scholar
  8. Garlan, D. (1995). What is style? In First International Workshop on Architectures for Software Systems. Google Scholar
  9. Holt (1994). The Architecture of Open VME. ICL, Stevenage, UK.Google Scholar
  10. IEEE (1990). IEEE Standard Glossary of Software Engineering Terminology. IEEE Std 610.12–1990, IEEE, Los Alamitos, CA.Google Scholar
  11. IEEE (1999). Special issue on LINUX. IEEE Software, 16(1).Google Scholar
  12. Kiczales, G., Ashley, J.M., Rodriguez, L., Vandat, A. and Bobrow, D.G. (1993). Metaobject protocols: Why we want them and what else they can do. In Paepcke, A. (ed.), Object-Oriented Programming: The CLOS Perspective. MIT Press, pp. 101–118.Google Scholar
  13. Kirby, G., Morrison, R. and Stemple, D. (1998). Linguistic reflection in Java. Software Practice and Experience, 28(10), 1045–1077.CrossRefGoogle Scholar
  14. Lehman, M.M. (1980). Programs, lifecycles, and the laws of software evolution. IEEE Transactions on Software Engineering,68(9), 1060–1076.Google Scholar
  15. Lehman, M.M. (1985). Program Evolution. Academic Press, London.Google Scholar
  16. Lehman, M.M. and Belady, L.A. (1976). A model of large program development. IBM Systems Journal, 3, 225–252.Google Scholar
  17. Lehman, M.M. (1984). Program evolution. Information Processing Management, 20, 19–36.CrossRefGoogle Scholar
  18. Lehman, M.M. and Ramil, J.F. (1998). The impact of feedback in the global software process. In Proceedings of ProSim 1998 Workshop,Silver Falls, OR, June 1998 (to appear in Journal of Software and Systems.Google Scholar
  19. Lientz, B. and Swanson, E.B. (1980). Software Maintenance Management: A Study of the Maintenance of Computer Application Software in 487 Data Processing Organisations. Addison-Wesley.Google Scholar
  20. Lientz, B., Swanson, E.B. and Tompkins, G.E. (1978). Characteristics of applications software maintenance. Communications of the ACM, 21, 466–471.CrossRefGoogle Scholar
  21. McDermid, J.A. (ed.) (1991). The Software Engineer’s Reference Book. Butterworth-Heinemann.Google Scholar
  22. Oreizy, P. and Medvidovic, N. (1998). Architecture-based runtime software evolution. In Proceedings of the International Conference on Software Engineering 1998 (ICSE ‘88), Kyoto, Japan.Google Scholar
  23. Oreizy, P. and Taylor, R.N. (1998). On the role of software architectures in runtime system reconfiguration. In Proceedings of the International Conference on Configurable Distributed Systems (ICCDS 4), Annapolis, MD.Google Scholar
  24. Perry, D.E. and Wolf, A.L. (1992). Foundations for the study of software architecture. ACM SIGSOFT Software Engineering Notes, 17(4), 40–52.CrossRefGoogle Scholar
  25. SEBPC (1999). Systems Engineering for Business Process Change. UK EPSRC, May 1999. URL at (valid 13 August 1999).
  26. Shaw, M. (1993). Procedure calls are the assembly language of software interconnection: Connectors deserve first class status. Technical Report CMU/ SEI-94-TR-2, Software Engineering Institute, Carnegie Mellon University. Presented at the Workshop of Software Design, 1994. Published in the proceedings: LNCS 1994. Google Scholar
  27. Shaw, M. and Garlan, D. (1996). Software Architecture: Perspectives on an Emerging Discipline. Prentice Hall.MATHGoogle Scholar
  28. Smith, B.C. (1982). Reflection and semantics in a procedural language. PhD thesis, MIT Laboratory for Computer Science, MIT Technical Report MIT/LCS/TR-272.Google Scholar
  29. Steindl, C. (1997). Reflection in Oberon. In Mossenbock, H. (ed.), Modular Programming Languages: Joint Modular Programming Languages Conference, JMLC ‘87, number 1204 in Lecture Notes in Computer Science, Linz, Austria. Springer-Verlag, pp. 282–296. Google Scholar

Copyright information

© Springer-Verlag London 2000

Authors and Affiliations

  • S. Rank
  • K. Bennett
  • S. Glover

There are no affiliations available

Personalised recommendations