Abstract
We propose here a mathematical framework for incremental software construction and for controlled software evolution. The framework allows incremental changes of a software system to be described on a high architecture level, but still with mathematical precision so that we can reason about the correctness of the changes. The framework introduces refinement diagrams as a visual way of presenting the architecture of large software systems. Refinement diagrams are based on lattice theory and allow reasoning about lattice elements to be carried out directly in terms of diagrams. A refinement diagram proof will be equivalent to a Hilbert like proof in lattice theory.
We use refinement calculus as the logic for reasoning about software systems. The calculus models software parts as elements in a lattice of predicate transformers. In this way, we can use refinement diagrams to reason about the properties of software systems. We show here how to apply refinement diagrams and refinement calculus to the incremental construction of large software system. We concentrate on three topics: (i) modularization of software systems with component specifications and the role of information hiding in this approach, (ii) layered extension of software by adding new features one-by-one and the role of inheritance and dynamic binding in this approach, and (iii) evolution of software over time and the control of successive versions of software.
This is a preview of subscription content, log in via an institution.
Buying options
Tax calculation will be finalised at checkout
Purchases are for personal use only
Learn about institutional subscriptionsPreview
Unable to display preview. Download preview PDF.
References
Anttila, H., Back, R.-J., Ketola, P., Konkka, K., Leskela, J., and Rysa, E. (2002). Combining stepwise feature introduction with user-centric design. Technical Report 495, TUCS-Turku Centre for Computer Science, www.tucs.fi.
Back, R.-J. (1980). Correctness Preserving Program Refinements: Proof Theory and Applications, volume 131 of Mathematical Center Tracts. Mathematical Centre, Amsterdam.
Back, R.-J. (1988). A calculus of refinements for program derivations. Acta Informatica, 25:593–624.
Back, R. J. (1991). Refinement diagrams. In Morris, J. M. and Shaw, R. C. F., editors, Proceedings of the 4th Refinement Workshop, Workshops in Computer Science, pages 125–137, Cambridge, England. Springer-Verlag.
Back, R.-J. (2002). Software construction by stepwise feature introduction. In Bert, D., Bowen, J., Henson, M., and Robinson, K., editors, ZB 2002: Formal Specification and Development in Z and B, proceedings of the 2nd International Conference of B and Z Users, LNCS, pages 162–183, Grenoble, France. Springer Verlag. Also appeared as TUCS Technical Report 496.
Back, R.-J., Martin, A., and Sere, K. (1996). Specifying the caltech asynchronous microprocessor. R Science of Computer Programming, 26:79–97.
Back, R.-J., Mikhajlov, L., and von Wright, J. (March 2000.). Formal semantics of inheritance and object substitutability. Technical Report 337, TUCS-Turku Centre for Computer Science, Turku, Finland.
Back, R.-J., Mikhajlova, A., and von Wright, J. (1999a). Reasoning about interactive systems. In J. Wing, J. W. and Davies, J., editors, Proc. of the World Conference on Formal Methods (FM’99), Toulouse, France., volume 1709 of Lecture Notes in Computer Science, pages 1460–1476. Springer-Verlag.
Back, R.-J., Milovanov, L., Porres, I., and Preoteasa, V. (2002). An experiment on extreme programming and stepwise feature introduction. Technical Report 451, TUCS-Turku Centre for Computer Science.
Back, R.-J., Petre, L., and Porres-Paltor, I. (1999b). Analyzing uml use cases as contracts. In France, R. and Rumpe, B., editors, UML’99-Second International Conference on the Unified Modeling Language: Beyond the Standard, number 1723 in Lecture Notes in Computer Science, pages 518–533. Springer-Verlag,.
Back, R.-J. and Sere, K. (1991). Stepwise refinement of action systems. Structured Programming, 12:17–30.
Back, R.-J. and Sere, K. (1996.). Superposition refinement of reactive systems. Formal Aspects of Computing, 8(3):324–346.
Back, R.-J. and von Wright, J. (1998). Refinement Calculus: A Systematic Introduction. Springer-Verlag.
Back, R.-J. and von Wright, J. (2000). Encoding, decoding and data refinemen. Formal Aspects of Computing.
Barr, M. and Wells, C. (1990). Category Theory for Computing Science. Prentice-Hall.
Birkhoff, G. (1961). Lattice Theory. American Mathematical Society, Providence.
Davey, B. A. and Priestley, H. A. (1990). Introduction to Lattices and Order. Cambridge University Press.
Dijkstra, E. W. (1976). A Discipline of Programming. Prentice-Hall International.
Dijkstra, E. W. and Scholten, C. S. (1990). Predicate Calculus and Program Semantics. Springer-Verlag.
Gardiner, P. H. and Morgan, C. C. (1993). A single complete rule for data refinement. Formal Aspects of Computing, 5(4):367–383.
Hoare, C. A. R. (1972). Proofs of correctness of data representation. Acta Informatica, 1(4):271–281.
Morgan, C. C. (1990). Programming from Specifications. Prentice-Hall.
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2005 Springer
About this paper
Cite this paper
Back, RJ. (2005). Incremental Software Construction with Refinement Diagrams. In: Broy, M., Grünbauer, J., Harel, D., Hoare, T. (eds) Engineering Theories of Software Intensive Systems. NATO Science Series, vol 195. Springer, Dordrecht. https://doi.org/10.1007/1-4020-3532-2_1
Download citation
DOI: https://doi.org/10.1007/1-4020-3532-2_1
Publisher Name: Springer, Dordrecht
Print ISBN: 978-1-4020-3530-2
Online ISBN: 978-1-4020-3532-6
eBook Packages: Computer ScienceComputer Science (R0)