Advertisement

Philosophy & Technology

, Volume 27, Issue 3, pp 377–397 | Cite as

Programming Languages as Technical Artifacts

  • Raymond TurnerEmail author
Special Issue

Abstract

Taken at face value, a programming language is defined by a formal grammar. But, clearly, there is more to it. By themselves, the naked strings of the language do not determine when a program is correct relative to some specification. For this, the constructs of the language must be given some semantic content. Moreover, to be employed to generate physical computations, a programming language must have a physical implementation. How are we to conceptualize this complex package? Ontologically, what kind of thing is it? In this paper, we shall argue that an appropriate conceptualization is furnished by the notion of a technical artifact.

Keywords

Programming languages Semantics Technical artifacts Philosophy of mathematics Philosophy of technology 

References

  1. Abramsky, S., Jagadeesan, R., Malacaria, P. (1994). In M. Hagiya, & J.C. Mitchell (Eds.), Full abstraction for PCF in Theoretical aspects of computer software. London: Springer.Google Scholar
  2. Abramsky, S., & McCusker, G. (1995). Games and full abstraction for the lazy lambda-calculus. In D. Kozen (Ed.), Proceedings of the 10th annual symposium on logic in computer science. IEEE Computer Society Press.Google Scholar
  3. Aho, A.V., Lam, S., Sethi, R., Ullman, J.D. (1992). Compilers: principles, techniques, and tools, 2007. Boston: Pearson.Google Scholar
  4. Barendregt, H.P. (1992). Lambda calculi with types. In S. Abramsky, D.M. Gabbay, T.S.E. Maibaum (Eds.), Handbook of logic in computer science (Vol. III). Oxford: Oxford Univeristy Press.Google Scholar
  5. Boghossian, P. (1989). The rule-following considerations. Mind, 98(392), 507–549.CrossRefGoogle Scholar
  6. Börger, E., & Schulte, W. (2007). A programmer friendly modular definition of the semantics of java. Lecture Notes in Computer Science, 1523, 353–404. ISBN: 3-540-66158-1.CrossRefGoogle Scholar
  7. Cardelli, L., & Abadi, M. (1996). A theory of objects. Mongraphs in computer science. New York: Springer. IBSN: 0387947752.Google Scholar
  8. Colburn, T. (2000). Philosophy and computer science. New York: London.Google Scholar
  9. Colburn, T., & Shute, G. (2007). Abstraction in computer science. Minds and Machines, 17(2), 169–184.CrossRefGoogle Scholar
  10. Cummins, R. (1975). Functional analysis. Journal of Philosophy, 72, 741–765.CrossRefGoogle Scholar
  11. Chalmers, D.J. (1996). Does a rock implement every finite-state automaton. Synthese, 108, 309–333.CrossRefGoogle Scholar
  12. Copeland, B.J. (1996). What is computation?. Synthese, 108(3), 335–359.CrossRefGoogle Scholar
  13. Duhem, P. (1906). La Théorie physique. Paris: Chevalier & Riviere, Editeurs. http://www.ac-nancy-metz.fr/enseign/philo/textesph/Duhem_theorie_physique.pdf.Google Scholar
  14. Fernandez, M. (2004). Programming languages and operational semantics: An introduction. London: King’s College Publications.Google Scholar
  15. Fetzer, J.H. (1988). Program verification: the very idea. Communinications in ACM, 31(9), 1048–1063.CrossRefGoogle Scholar
  16. Fetzer, J.H. (1999). The role of models in computer science. Monist, 82(1), 20–36.CrossRefGoogle Scholar
  17. Franssen, M., Lokhorst, G., Poel, I. (2009). Philosophy of technology. Stanford Encyclopedia of Philosophy. http://plato.stanford.edu/entries/technology.
  18. Girard, J.-Y. (1971). Une Extension de l’Interpretation de Gödel à l’Analyse, et son Application à l’Élimination des Coupures dans l’Analyse et la Théorie des Types. In Proceedings of the 2nd scandinavian logic symposium (pp. 63–92), Amsterdam.Google Scholar
  19. Gödel, K. (1934). Some basic theorems on the foundations of mathematics and their implications, (pp. 304–323).Google Scholar
  20. Gordon, M.J.C. (1979). The denotational description of programming languages. Berlin: Springer.CrossRefGoogle Scholar
  21. Gordon, M.J.C. (1986). Hardware verification using higher-order logic.Google Scholar
  22. Gunter, C.A. (1992). Semantics of programming languages: structures and techniques. Cambridge, MIT.Google Scholar
  23. Hanson, M., & Rischel, H. (1999). Introduction to programming using SML. Boston, Pearson.Google Scholar
  24. Hilbert, D. (1899). The foundations of geometry, 2nd edn. Chicago: Open Court.Google Scholar
  25. Houkes, W., & Vermaas, P.E. (2010). Technical functions. On the use and design of artefacts. Philosophy of engineering and technology (Vol. 1). Dordrecht: Springer.Google Scholar
  26. Irmak, N. (2012). Software is an abstract artifact. http://miami.academia.edu/NurbayIrmak/Papers/1314637.
  27. Jones, C.B. (1990). Systematic software development using VDM, 2nd edn. Upper Saddle River: Prentice Hall International.Google Scholar
  28. Kroes, P. (2010). Engineering and the dual nature of technical artefacts. Cambridge Journal of Economics, 34(1), 51–62. doi: 10.1093/cje/bep019.CrossRefGoogle Scholar
  29. Kroes, P. (2012). Technical artefacts: creations of mind and matter: a philosophy of engineering design. Dordrecht, Springer.CrossRefGoogle Scholar
  30. Kripke, S. (1982). Wittgenstein on rules and privaye language. Cambridge: Harvard University Press.Google Scholar
  31. Landin, P.J. (1964). The mechanical evaluation of expressions. Computer Journal, 6(4), 308–320.CrossRefGoogle Scholar
  32. McLaughlin, P. (2001). What functions explain. Functional explanation and self-reproducing systems. Cambridge: Cambridge University Press.Google Scholar
  33. Meijers, A.W.M. (2001). The relational ontology of technical artefacts. In P.A. Kroes, & M.A.W.M. Amsterdam (Eds.), The empirical turn in the philosophy of technology research in philosophy and technology (Vol. 20), (series editor Carl Mitcham). Amsterdam: JAI/Elsevier.Google Scholar
  34. Milne, R., & Strachey, C. (1977). A theory of programming language semantics. New York: Halsted.Google Scholar
  35. Milner, R. (1993). The polyadic \(\pi -Calculus\): A tutorial. In F.L. Hamer , W. Brauer , H. Schwichtenberg (Eds.), Logic and algebra of specification. Berlin: Springer.Google Scholar
  36. Mitchell, J.C. (1996). Foundations for Programming languages. Cambridge: MIT.Google Scholar
  37. Moor, J.H. (1978). Three myths of computer Science. British Journal for the Philosophy of Science, 29(3), 213–222.CrossRefGoogle Scholar
  38. Mulmuley, K. (1987). Full abstraction and semantic equivalence. Cambridge: MIT.Google Scholar
  39. Piccinini, G. (2010). Computation in physical systems, Stanford encyclopedia of philosophy. http://plato.stanford.edu/entries/computation-physicalsystems.
  40. Piccinini, G. (2008). Computation without representation. Philosophical Studies, 137, 205–241.CrossRefGoogle Scholar
  41. Pierce, B.C. (2002). Types and programming languages. Cambridge: MIT. ISBN 0-262-16209-1.Google Scholar
  42. Plotkin, G.D. (1981). A structural approach to operational semantics. Tech. Rep.19. Denmark, Aarhus: Computer Science Department, Aarhus University.Google Scholar
  43. Putnam, H. (1988). Representation and reality. Cambridge: MIT.Google Scholar
  44. Putnam, H. (1967). Psychological predicates In W.H. Capitan, & D.D. Merrill (Eds.), Art, mind, and religion (pp. 37–48). Pittsburgh: University of Pittsburgh Press. Reprinted in Putnam 1975a as “The Nature of Mental States,” pp. 150–161.Google Scholar
  45. Putnam, H. (1975). Philosophical papers: Volume 2. Mind, language and reality. Cambridge: Cambridge University Press.Google Scholar
  46. Reynolds, J.C. (1994). An introduction to polymorphic lambda calculus in logical foundations of functional programming (pp. 77-86). England: Addison-Wesley.Google Scholar
  47. Searle, J.R. (1995). The construction of social reality. London: Penguin.Google Scholar
  48. Schmidt, D.A. (1988). Denotational semantics: a methodology for language development. Boston: Allyn & Bacon, 1986. Reprint, 1988.Google Scholar
  49. Spivey, M. (1988). Understanding Z: a specification language and its formal semantics. In Cambridge tracts in theoretical computer science (Vol. 3). Cambridge: Cambridge University Press. ISBN 978-0-521-05414-0.Google Scholar
  50. Stoughton, A. (1988). Fully abstract models of programming languages. London: Pitman/Wiley.Google Scholar
  51. Sprevak, M. (2010). Computation, individuation, and the representation condition. Studies in History and Philosophy of Science Part A, 41(3), 260–270. Computation and cognitive science.CrossRefGoogle Scholar
  52. Stoy, J. (1977). Denotational semantics: the Scott-Strachey approach to programming language semantics. Cambridge: MIT.Google Scholar
  53. Strachey, C. (2000). Fundamental concepts in programming languages. Higher-Order and Symbolic Computation, 13, 11–49. Manufactured in The Netherlands: Kluwer Academic.CrossRefGoogle Scholar
  54. Thompson, S. (2011). Haskell: the craft of functional programming. England: Addison-Wesley. ISBN 0-201-34275-8.Google Scholar
  55. Thompson, S. (1995). Miranda: the craft of functional programming. England: Addison-Wesley. ISBN: 0201422794.Google Scholar
  56. Thomasson, A.L. (2003). Realism and human kinds. Philosophy and Phenomenological Research, 67(3), 580–609. CrossRefWeb of Science.CrossRefGoogle Scholar
  57. Thomasson, A.L. (2007). Artifacts and human concepts. In S. Laurence, & E. Margolis (Eds.), Creations of the mind: essays on artifacts and their representations. Oxford: Oxford University Press.Google Scholar
  58. Tennent, R.D. (1991). Semantics of programming languages. Upper Saddle River: Prentice Hall.Google Scholar
  59. Turner, R. (2007). Understanding programming language. Minds and Machines, 17(2), 129–133.CrossRefGoogle Scholar
  60. Turner, R. (2010). Specification. Minds and Machines, 21(2), 135–152.CrossRefGoogle Scholar
  61. Turner, R. (2011). Computable models. London: Springer.Google Scholar
  62. Vermaas, P.E., & Houkes, W. (2003). Ascribing functions to technical artefacts: a challenge to etiological accounts of function. British Journal of the Philosophy of Science, 54, 261–289.CrossRefGoogle Scholar
  63. Winskel, G. (1993). The formal semantics of programming languages: an introduction. Cambridge: MIT.Google Scholar
  64. Wittgenstein, L. (1939). Wittgenstein’s lectures on the foundations of mathematics. Cambridge: University of Chicago Press.Google Scholar
  65. White, G. (2004). The philosophy of computer languages. In L. Floridi (Ed.), The Blackwell guide to the philosophy of computing and information (pp. 318–326). Malden: Blackwell.Google Scholar

Copyright information

© Springer Science+Business Media Dordrecht 2013

Authors and Affiliations

  1. 1.CSEEUniversity of EssexColchesterUK

Personalised recommendations