Skip to main content

Programming Languages as Technical Artifacts

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.

This is a preview of subscription content, access via your institution.

Notes

  1. 1.

    We shall use the terms grammar/grammatical and syntax/syntactical interchangeably.

  2. 2.

    Of course programs are artifacts in their own right, but in an inherited way. The distinction might be best seen in terms of a simple analogy. Consider a sophisticated knitting machine with its own input interface. As an artifact, it must be distinguished from any cardigans it produces. Indeed, the situation is even more complex than this: the knitting machine is more like a universal Turing machine, the knitting-machine program is like a computer program (written in its own programming language), and the cardigan is its output.

  3. 3.

    This may be formalized in the abstract data type of finite sets or any functional language; one certainly does not need to assume the whole of set theory (ZF).

  4. 4.

    This is related to the Hoare notation

    $$s\{P\}s^{\prime }$$

    but in our case, the state \(s^{\prime }\) has to be a terminating state. The Hoare notation is closer to the so called small step operational semantics.

  5. 5.

    Indeed, much work has been done to construct denotational definitions that are in harmony with the operational ones. This often requires the use of a version of denotational semantics based upon games (Abramsky et al. 1994; Abramsky and McCusker 1995; Stoughton 1988; Mulmuley 1987).

  6. 6.

    This is unlike the classical role of the Tarski notion of truth for predicate logic which is taken to fix the meaning of the logical constants.

  7. 7.

    Category theoretic interpretations fair much better in giving a more intensional flavor to the interpretation (White 2004) and could be argued to provide an alternative framework for the axiomatization of computational notions.

  8. 8.

    One might note in passing that this seems to make computers redundant.

  9. 9.

    What makes programming languages special as constructed language? Is it possible to see a language like Esperanto as a technical artifact? Does the latter have a physical realization?

  10. 10.

    In the case of programming languages, the user is the programmer and the maker is the implementor. The normative use of the definition of the language in the user case is complex and the issue of correctness brings in the specification of individual programs. We shall not discuss this further here but see (Turner 2011).

  11. 11.

    Quus: a function that is only identical to plus up to a certain pair of numbers.

  12. 12.

    What I would like to refer to as computational artifacts.

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.

  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.

    Article  Google 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.

    Article  Google 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.

    Article  Google Scholar 

  10. Cummins, R. (1975). Functional analysis. Journal of Philosophy, 72, 741–765.

    Article  Google Scholar 

  11. Chalmers, D.J. (1996). Does a rock implement every finite-state automaton. Synthese, 108, 309–333.

    Article  Google Scholar 

  12. Copeland, B.J. (1996). What is computation?. Synthese, 108(3), 335–359.

    Article  Google 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.

    Article  Google Scholar 

  16. Fetzer, J.H. (1999). The role of models in computer science. Monist, 82(1), 20–36.

    Article  Google 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.

  19. Gödel, K. (1934). Some basic theorems on the foundations of mathematics and their implications, (pp. 304–323).

  20. Gordon, M.J.C. (1979). The denotational description of programming languages. Berlin: Springer.

    Book  Google Scholar 

  21. Gordon, M.J.C. (1986). Hardware verification using higher-order logic.

  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.

    Article  Google Scholar 

  29. Kroes, P. (2012). Technical artefacts: creations of mind and matter: a philosophy of engineering design. Dordrecht, Springer.

    Book  Google 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.

    Article  Google 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.

    Article  Google 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.

    Article  Google 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.

  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.

  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.

  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.

    Article  Google 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.

    Article  Google 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.

    Article  Google 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.

    Article  Google Scholar 

  60. Turner, R. (2010). Specification. Minds and Machines, 21(2), 135–152.

    Article  Google 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.

    Article  Google 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 

Download references

Author information

Affiliations

Authors

Corresponding author

Correspondence to Raymond Turner.

Rights and permissions

Reprints and Permissions

About this article

Cite this article

Turner, R. Programming Languages as Technical Artifacts. Philos. Technol. 27, 377–397 (2014). https://doi.org/10.1007/s13347-012-0098-z

Download citation

Keywords

  • Programming languages
  • Semantics
  • Technical artifacts
  • Philosophy of mathematics
  • Philosophy of technology