Skip to main content
SpringerLink
Log in

The Logic of Correctness in Software Engineering

  • Chapter
A Science of Operations

Part of the book series: History of Computing ((HC))

Abstract

This chapter describes the approach taken by those working in the Algol research programme to the problem of how to improve the quality of software development and in particular to ensure that software systems met their users’ expectations and were completed economically and on schedule. These concerns came to prominence in the mid-1960s in response to a perceived software crisis, and were extensively discussed at the well-known NATO conference in 1968 which brought the term ’software engineering’ to prominence. Two major results emerged from this work. Firstly, a novel notion of ’correctness’ was defined for software, namely the existence of a particular type of consistency between a program and its specification. Secondly, practical programming techniques were put forward which, it was hoped, would increase the likelihood of correct programs being developed.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

Log in via an institution
Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 139.00
Price excludes VAT (USA)
  • Available as EPUB and PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 179.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info
Hardcover Book
USD 179.99
Price excludes VAT (USA)
  • Durable hardcover edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Notes

  1. 1.

    Naur and Randell (1969).

  2. 2.

    Aiken and Hopper (1946), p. 525.

  3. 3.

    Aiken and Hopper (1946), p. 525.

  4. 4.

    Miller (1949).

  5. 5.

    Wilkes et al. (1951), p. 38, see also Brooker et al. (1952).

  6. 6.

    Bloch (1999), p. 97.

  7. 7.

    Wilkes et al. (1951), p. 41.

  8. 8.

    Miller (1949), emphasis in original.

  9. 9.

    Gill (1951).

  10. 10.

    Diehm (1952).

  11. 11.

    Benington (1956).

  12. 12.

    Diehm (1952), p. 19, Gill (1953), p. 291.

  13. 13.

    Bemer (1984).

  14. 14.

    Katz (1957), p. 21.

  15. 15.

    Gill (1959).

  16. 16.

    McCarthy (1962), p. 22.

  17. 17.

    Dijkstra (1962b), p. 537.

  18. 18.

    Dijkstra (1969b), p. 85.

  19. 19.

    Naur (1966), pp. 310–311.

  20. 20.

    Naur (1966), p. 312.

  21. 21.

    Floyd (1967), p. 19.

  22. 22.

    Bloch (1999), p. 94.

  23. 23.

    Goldstine and von Neumann (1947), p. 92.

  24. 24.

    Turing (1949).

  25. 25.

    Naur (1966), p. 324.

  26. 26.

    Floyd (1967), p. 19.

  27. 27.

    Hoare (1969), p. 576.

  28. 28.

    McCarthy (1961), p. 225.

  29. 29.

    Dijkstra (1968a).

  30. 30.

    Naur (1969).

  31. 31.

    Hoare (1971).

  32. 32.

    Hoare (1971), p. 41.

  33. 33.

    Hoare (1971), p. 45, Wirth (1971a).

  34. 34.

    Floyd (1971).

  35. 35.

    Programs had always been expected to do what their specifications stated, or course. The point is that theoretical accounts of correctness were increasingly phrased in terns of a program “meeting its specification” rather than “being correct”.

  36. 36.

    Manna and Waldinger (1971), p. 152.

  37. 37.

    Liskov and Zilles (1975), pp. 7–8.

  38. 38.

    Manna and Waldinger (1978), p. 201.

  39. 39.

    Dijkstra (1969a), p. 222, Dijkstra (1969b), p. 225.

  40. 40.

    Dijkstra (1968c).

  41. 41.

    Dijkstra (1969b), p. 255.

  42. 42.

    Dijkstra (1972), p. 19.

  43. 43.

    Henderson and Snowdon (1972), pp. 38, 51.

  44. 44.

    Ledgard (1974), p. 49.

  45. 45.

    Liskov (1973), p. 5.

  46. 46.

    Liskov (1973), p. 6.

  47. 47.

    Baker (1972a, 1972b).

  48. 48.

    McCracken (1973).

  49. 49.

    Wirth (1974), p. 252.

  50. 50.

    Donaldson (1973).

  51. 51.

    Stevens et al. (1974).

  52. 52.

    McCracken (1973).

  53. 53.

    Hoare (1969), p. 579.

  54. 54.

    Hoare (1971), p. 39.

  55. 55.

    Hoare (1996).

  56. 56.

    Lakatos (1967).

  57. 57.

    Dijkstra (1968a), p. 185.

  58. 58.

    Mills (1976), p. 269.

  59. 59.

    Shapiro (1997).

  60. 60.

    Gerhart and Yelowitz (1976), p. 206.

  61. 61.

    Hoare (1996).

  62. 62.

    Fetzer (1988).

  63. 63.

    Dijkstra (1968c), p. 344.

  64. 64.

    Goodenough and Gerhart (1975), p. 157.

  65. 65.

    Fetzer (1988), p. 1062.

  66. 66.

    Dasgupta (1991), p. 353.

  67. 67.

    Bauer and Wössner (1972).

  68. 68.

    Schick and Wolverton (1978), p. 105.

  69. 69.

    Randell (2000).

  70. 70.

    In the 1990s, a particular approach to software engineering characterized itself as ‘empirical’, based on the belief that “the most important thing to understand is the relationship between various process characteristics and product characteristics”; See Basili (1996), for example. In the Lakatosian framework, this approach would seem to fall squarely in the Euclidean tradition, but emphasizing the external, managerial aspects of the development process rather than the internal properties of software-related artefacts. What is being proposed appears to be an empirical study of a Euclidean process, not an empirical approach to development itself.

  71. 71.

    Ross (1968).

  72. 72.

    McCracken and Jackson (1982), p. 31.

  73. 73.

    Boehm (1984).

  74. 74.

    Larman and Basili (2003).

  75. 75.

    Callon (1987), Pickering (1995).

  76. 76.

    See Robinson et al. (1998), for example.

  77. 77.

    Mills (1986).

  78. 78.

    Boehm (1976).

  79. 79.

    See McCracken (1973), Knuth (1974), for example.

References

  • Aiken, H.H., Hopper, G.M.: The Automatic Sequence Controlled Calculator. Electr. Eng. 65, 384–391, 449–454, 522–528 (1946)

    Article  MathSciNet  Google Scholar 

  • Baker, F.T.: Chief programmer team management of production programming. IBM Syst. J. 11(1), 56–73 (1972a)

    Article  Google Scholar 

  • Baker, F.T.: System quality through structured programming. In: AFIPS Proceedings of the 1972 Fall Joint Computer Conference. AFIPS Conference Proceedings, vol. 41, pp. 339–344. AFIPS Press, Montvale (1972b)

    Google Scholar 

  • Basili, V.: The role of experimentation in software engineering: past, present and future. In: ISCE’96: Proceedings of the 18th International Conference on Software Engineering, pp. 442–449. IEEE Comput. Soc., Los Alamitos (1996)

    Chapter  Google Scholar 

  • Bauer, F.L., Wössner, H.: The “Plankalkül” of Konrad Zuse: A forerunner of today’s programming languages. Commun. ACM 15(1), 678–685 (1972)

    Article  MATH  Google Scholar 

  • Bemer, R.W.: Computing prior to FORTRAN. Ann. Hist. Comput. 6(1), 16–18 (1984)

    Google Scholar 

  • Benington, H.D.: Production of large computer programs. In: Proceeding of the Symposium on Advanced Programming Methods for Digital Computers, pp. 15–28. Office of Naval Research, Arlington (1956)

    Google Scholar 

  • Bloch, R.M.: Programming Mark I (1999). In: Cohen, I.B., Welch, G.W. (eds.) Makin’ Numbers: Howard Aiken and the Computer. MIT Press, Cambridge (1999)

    Google Scholar 

  • Boehm, B.W.: Software engineering. IEEE Trans. Comput. C-25(12), 1226–1241 (1976)

    Article  Google Scholar 

  • Boehm, B.W.: Verifying and validating software requirements and design specifications. IEEE Softw. 1(1), 75–88 (1984)

    Article  Google Scholar 

  • Brooker, R.A., Gill, S., Wheeler, D.J.: The adventures of a blunder. Math. Tables Other Aids Comput. 6(38), 112–113 (1952)

    Article  Google Scholar 

  • Callon, M.: Society in the making: the study of technology as a tool for sociological analysis. In: Bijker, W.E., Hughes, T.P., Pinch, T.J. (eds.) The Sociological Construction of Technological Systems, pp. 83–103. MIT Press, Cambridge (1987)

    Google Scholar 

  • Dasgupta, S.: Design Theory and Computer Science. Cambridge University Press, Cambridge (1991)

    Book  Google Scholar 

  • Diehm, I.C.: Computer aids to code checking (1952). In: Forrester, J.W., Hamming, R.W. (eds.) Proceedings of the 1952 ACM National Meeting, Toronto, pp. 19–21 (1952)

    Google Scholar 

  • Dijkstra, E.W.: Some meditations on advanced programming (1962b). In: Popplewell, C.M. (ed.) Information Processing 1962: Proceedings of IFIP Congress, vol. 62, pp. 535–538. North-Holland, Amsterdam (1963)

    Google Scholar 

  • Dijkstra, E.W.: A constructive approach to the problem of program correctness. BIT Numer. Math. 8, 174–186 (1968a)

    Article  MATH  Google Scholar 

  • Dijkstra, E.W.: The structure of the “THE”-multiprogramming system. Commun. ACM 11(5), 341–346 (1968c)

    Article  MATH  Google Scholar 

  • Dijkstra, E.W.: EWD249: notes on structured programming (1969a). Unpublished manuscript, available at http://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF (accessed 4 May 2008). Circulated as Dijkstra (1970), and published with additional material as Dijkstra (1972)

  • Dijkstra, E.W.: Structured programming. In: Buxton, J.N., Randell, B. (eds.) Software Engineering Techniques: Report on a Conference Sponsored by the NATO Science Committee, Rome, Italy, 27th to 31st October 1969, pp. 84–88. NATO (1969b)

    Google Scholar 

  • Dijkstra, E.W.: Notes on structured programming (1972). In: Dahl, O.-J. et al. (eds.) Structured Programming, pp. 1–82. Academic Press, San Diego (1972)

    Google Scholar 

  • Donaldson, J.R.: Structured programming. Datamation 19(12), 52–54 (1973)

    Google Scholar 

  • Fetzer, J.H.: Program verification: the very idea. Commun. ACM 31(9), 1048–1063 (1988)

    Article  Google Scholar 

  • Floyd, R.W.: Assigning meanings to programs. In: Schwartz, J.T. (ed.) Mathematical Aspects of Computer Science. Proceedings of Symposia in Applied Mathematics, vol. XIX, pp. 19–32. American Mathematical Society, Providence (1967)

    Chapter  Google Scholar 

  • Floyd, R.W.: Toward interactive design of correct programs (1971). In: Freiman, C.V. (ed.) Information Processing 71: Proceedings of the IFIP Congress, vol. 71, pp. 7–10. North-Holland, Amsterdam (1972)

    Google Scholar 

  • Gerhart, S.L., Yelowitz, L.: Observations of fallibility in applications of modern programming methodologies. IEEE Trans. Softw. Eng. SE-2(3), 195–207 (1976)

    Article  MathSciNet  Google Scholar 

  • Gill, S.: The diagnosis of mistakes in programmes on the EDSAC. Proc. R. Soc. Lond. Ser. A, Math. Phys. Sci. 206, 538–554 (1951)

    Article  MATH  Google Scholar 

  • Gill, S.: Getting programmes right. In: Automatic Digital Computation, pp. 289–292. National Physical Laboratory, HMSO, London (1953). Reprinted in Williams and Campbell-Kelly, pp. 209–498 (1989)

    Google Scholar 

  • Gill, S.: Current theory and practice of automatic programming. Comput. J. 2(3) (1959)

    Google Scholar 

  • Goldstine, H.H., von Neumann, J.: Planning and coding problems for an electronic computing instrument, Part II, vol. 1. Technical Report, Institute of Advanced Study (1947). Reprinted in Aspray and Burks, pp. 151–222 (1987)

    Google Scholar 

  • Goodenough, J.B., Gerhart, S.L.: Toward a theory of test data selection. IEEE Trans. Softw. Eng. SE-1(2), 156–173 (1975)

    Article  MathSciNet  Google Scholar 

  • Henderson, P., Snowdon, R.: An experiment in structured programming. BIT Numer. Math. 12, 38–53 (1972)

    Article  MATH  Google Scholar 

  • Hoare, C.A.R.: An axiomatic basis for computer programming. Commun. ACM 12(10), 576–580 (1969)

    Article  MATH  Google Scholar 

  • Hoare, C.A.R.: Proof of a program: FIND. Commun. ACM 14(1), 39–45 (1971)

    Article  MATH  Google Scholar 

  • Hoare, C.A.R.: How did software get so reliable without proof? In: Gaudel, M.-C., Woodcock, J. (eds.) FME’96: Industrial Benefit and Advances in Formal Methods. Proceedings of the Third International Symposium of Formal Methods Europe. Lecture Notes in Computer Science, vol. 1051, pp. 1–17. Springer, Berlin (1996)

    Chapter  Google Scholar 

  • Katz, C.: Systems of debugging automatic coding. In: Automatic Coding: Proceedings of the Symposium, 24–25 January 1957. Franklin Institute, Philadelphia (1957). J. Franklin Inst., Monograph No. 3, pp. 17–27

    Google Scholar 

  • Knuth, D.E.: Structured programming with go to statements. ACM Comput. Surv. 6(4), 260–301 (1974)

    Article  MathSciNet  Google Scholar 

  • Lakatos, I. (ed.): Problems in the Philosophy of Mathematics. North-Holland, Amsterdam (1967)

    MATH  Google Scholar 

  • Larman, C., Basili, V.R.: Iterative and incremental development: a brief history. Computer 36(6), 47–56 (2003)

    Article  Google Scholar 

  • Ledgard, H.F.: The case for structured programming. BIT Numer. Math. 14, 45–57 (1974)

    Article  MATH  Google Scholar 

  • Liskov, B.: Report of session on structured programming. ACM SIGPLAN Not. 8(9), 5–10 (1973)

    Article  Google Scholar 

  • Liskov, B.H., Zilles, S.N.: Specification techniques for data abstractions. IEEE Trans. Softw. Eng. SE-1(1), 7–19 (1975)

    Article  Google Scholar 

  • Manna, Z., Waldinger, R.J.: Toward automatic program synthesis. Commun. ACM 14(3), 151–165 (1971)

    Article  MATH  Google Scholar 

  • Manna, Z., Waldinger, R.J.: The logic of computer programming. IEEE Trans. Softw. Eng. SE-4(3), 199–229 (1978)

    Article  MathSciNet  Google Scholar 

  • McCarthy, J.: A basis for a mathematical theory of computation, preliminary report. In: Proceedings of the Western Joint Computer Conference, pp. 225–238 (1961)

    Google Scholar 

  • McCarthy, J.: Towards a mathematical science of computation (1962). In: Popplewell, C.M. (ed.) Information Processing 1962: Proceedings of IFIP Congress, vol. 62, pp. 21–28. North-Holland, Amsterdam (1963)

    Google Scholar 

  • McCracken, D.: Revolution in programming: an overview. Datamation 19(12), 50–52 (1973). Reprinted in Yourdon (1979)

    Google Scholar 

  • McCracken, D.D., Jackson, M.A.: Life cycle concept considered harmful. Softw. Eng. Notes 7(2), 29–32 (1982)

    Article  Google Scholar 

  • Miller, J.C.P.: Remarks on checking (1949). In: Report of a Conference on High Speed Automatic Calculating Machines, 22–25 June 1949, pp. 123–124. University Mathematical Laboratory, Cambridge (1950)

    Google Scholar 

  • Mills, H.D.: Software development. IEEE Trans. Softw. Eng. SE-2(4), 265–273 (1976)

    Article  Google Scholar 

  • Mills, H.D.: Structured programming: retrospect and prospect. IEEE Softw. 3(6), 58–66 (1986)

    Article  Google Scholar 

  • Naur, P.: Proof of algorithms by general snapshots. BIT Numer. Math. 6, 310–316 (1966)

    Article  Google Scholar 

  • Naur, P.: Programming by action clusters. BIT Numer. Math. 9, 250–258 (1969)

    Article  MATH  Google Scholar 

  • Naur, P., Randell, B. (eds.): Software Engineering: Report on a Conference Sponsored by the NATO Science Committee, Garmisch, Germany, 7th to 11th October 1968. Scientific Affairs Division, NATO, Brussels (1969)

    Google Scholar 

  • Pickering, A.: The Mangle of Practice: Time, Agency and Science. University of Chicago Press, Chicago (1995)

    Book  MATH  Google Scholar 

  • Randell, B.: Facing up to faults. Comput. J. 43(2), 95–106 (2000)

    Article  Google Scholar 

  • Robinson, H., Hall, P., Hovenden, F., Rachel, J.: Postmodern software development. Comput. J. 41(6), 363–375 (1998)

    Article  MATH  Google Scholar 

  • Ross, D.T.: Design and production in software engineering: discussion contribution (1968). In: Naur, P., Randell, B. (eds.) Software Engineering: Report on a Conference Sponsored by the NATO Science Committee, Garmisch, Germany, 7th to 11th October 1968, p. 32. Scientific Affairs Division, NATO, Brussels (1969)

    Google Scholar 

  • Schick, G.J., Wolverton, R.W.: An analysis of competing software reliability models. IEEE Trans. Softw. Eng. SE-4(2), 104–120 (1978)

    Article  Google Scholar 

  • Shapiro, S.: Splitting the difference: the historical necessity of synthesis in software engineering. IEEE Ann. Hist. Comput. 19(1), 20–54 (1997)

    Article  Google Scholar 

  • Stevens, W., Myers, G., Constantine, L.: Structured design. IBM Syst. J. 13(2), 115–139 (1974)

    Article  Google Scholar 

  • Turing, A.M.: Checking a large routine (1949). In: Report of a Conference on High Speed Automatic Calculating Machines, 22–25 June 1949, pp. 70–72. University Mathematical Laboratory, Cambridge (1950)

    Google Scholar 

  • Wilkes, M.V., Wheeler, D.J., Gill, S.: The Preparation of Programs for an Electronic Digital Computer. Addison-Wesley, Reading (1951)

    MATH  Google Scholar 

  • Wirth, N.: Program development by stepwise refinement. Commun. ACM 14(4), 221–227 (1971a)

    Article  MATH  Google Scholar 

  • Wirth, N.: On the composition of well-structured programs. ACM Comput. Surv. 6(4), 247–259 (1974)

    Article  MATH  Google Scholar 

Download references

Author information

Authors and Affiliations

  1. London, UK

    Dr. Mark Priestley

Authors
  1. Dr. Mark Priestley
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Mark Priestley .

Rights and permissions

Reprints and permissions

Copyright information

© 2011 Springer-Verlag London Limited

About this chapter

Cite this chapter

Priestley, M. (2011). The Logic of Correctness in Software Engineering. In: A Science of Operations. History of Computing. Springer, London. https://doi.org/10.1007/978-1-84882-555-0_10

Download citation

  • DOI: https://doi.org/10.1007/978-1-84882-555-0_10

  • Publisher Name: Springer, London

  • Print ISBN: 978-1-84882-554-3

  • Online ISBN: 978-1-84882-555-0

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics

Search

Navigation