Abstract
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.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Preview
Unable to display preview. Download preview PDF.
References
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.
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.
Brand, S. (1994). How Buildings Learn. Viking Books.
Brooks, F. (1995). The Mythical Man-Month: Essays on Software Engineering. Addison-Wesley.
Buschmann, F., Meunier, R., Rohnert, H., Sommerlad, P. and Stal, M. (1996). Pattern-Oriented Software Architecture: A System of Patterns. Wiley.
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.
Cusumano, M.A. and Selby, R.W. (1997). Microsoft Secrets. HarperCollins.
Garlan, D. (1995). What is style? In First International Workshop on Architectures for Software Systems.
Holt (1994). The Architecture of Open VME. ICL, Stevenage, UK.
IEEE (1990). IEEE Standard Glossary of Software Engineering Terminology. IEEE Std 610.12–1990, IEEE, Los Alamitos, CA.
IEEE (1999). Special issue on LINUX. IEEE Software, 16(1).
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.
Kirby, G., Morrison, R. and Stemple, D. (1998). Linguistic reflection in Java. Software Practice and Experience, 28(10), 1045–1077.
Lehman, M.M. (1980). Programs, lifecycles, and the laws of software evolution. IEEE Transactions on Software Engineering,68(9), 1060–1076.
Lehman, M.M. (1985). Program Evolution. Academic Press, London.
Lehman, M.M. and Belady, L.A. (1976). A model of large program development. IBM Systems Journal, 3, 225–252.
Lehman, M.M. (1984). Program evolution. Information Processing Management, 20, 19–36.
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.
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.
Lientz, B., Swanson, E.B. and Tompkins, G.E. (1978). Characteristics of applications software maintenance. Communications of the ACM, 21, 466–471.
McDermid, J.A. (ed.) (1991). The Software Engineer’s Reference Book. Butterworth-Heinemann.
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.
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.
Perry, D.E. and Wolf, A.L. (1992). Foundations for the study of software architecture. ACM SIGSOFT Software Engineering Notes, 17(4), 40–52.
SEBPC (1999). Systems Engineering for Business Process Change. UK EPSRC, May 1999. URL at http://www.staff.ecs.soton.ac.uk/~ph/sebpc (valid 13 August 1999).
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.
Shaw, M. and Garlan, D. (1996). Software Architecture: Perspectives on an Emerging Discipline. Prentice Hall.
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.
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.
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2000 Springer-Verlag London
About this chapter
Cite this chapter
Rank, S., Bennett, K., Glover, S. (2000). FLEXX: Designing Software for Change Through Evolvable Architectures. In: Henderson, P. (eds) Systems Engineering for Business Process Change. Springer, London. https://doi.org/10.1007/978-1-4471-0457-5_4
Download citation
DOI: https://doi.org/10.1007/978-1-4471-0457-5_4
Publisher Name: Springer, London
Print ISBN: 978-1-4471-1146-7
Online ISBN: 978-1-4471-0457-5
eBook Packages: Springer Book Archive