Skip to main content
SpringerLink
Log in

Programming Languages as Technical Artifacts

  • Special Issue
  • Published:
Philosophy & Technology Aims and scope Submit manuscript

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, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

Notes

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

  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. 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. 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. 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. 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. 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. One might note in passing that this seems to make computers redundant.

  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. 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. Quus: a function that is only identical to plus up to a certain pair of numbers.

  12. What I would like to refer to as computational artifacts.

References

  • 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 

  • 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.

  • Aho, A.V., Lam, S., Sethi, R., Ullman, J.D. (1992). Compilers: principles, techniques, and tools, 2007. Boston: Pearson.

    Google Scholar 

  • 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 

  • Boghossian, P. (1989). The rule-following considerations. Mind, 98(392), 507–549.

    Article  Google Scholar 

  • 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 

  • Cardelli, L., & Abadi, M. (1996). A theory of objects. Mongraphs in computer science. New York: Springer. IBSN: 0387947752.

    Google Scholar 

  • Colburn, T. (2000). Philosophy and computer science. New York: London.

    Google Scholar 

  • Colburn, T., & Shute, G. (2007). Abstraction in computer science. Minds and Machines, 17(2), 169–184.

    Article  Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  • 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 

  • Fernandez, M. (2004). Programming languages and operational semantics: An introduction. London: King’s College Publications.

    Google Scholar 

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

    Article  Google Scholar 

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

    Article  Google Scholar 

  • Franssen, M., Lokhorst, G., Poel, I. (2009). Philosophy of technology. Stanford Encyclopedia of Philosophy. http://plato.stanford.edu/entries/technology.

  • 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.

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

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

    Book  Google Scholar 

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

  • Gunter, C.A. (1992). Semantics of programming languages: structures and techniques. Cambridge, MIT.

    Google Scholar 

  • Hanson, M., & Rischel, H. (1999). Introduction to programming using SML. Boston, Pearson.

    Google Scholar 

  • Hilbert, D. (1899). The foundations of geometry, 2nd edn. Chicago: Open Court.

    Google Scholar 

  • 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 

  • Irmak, N. (2012). Software is an abstract artifact. http://miami.academia.edu/NurbayIrmak/Papers/1314637.

  • Jones, C.B. (1990). Systematic software development using VDM, 2nd edn. Upper Saddle River: Prentice Hall International.

    Google Scholar 

  • 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 

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

    Book  Google Scholar 

  • Kripke, S. (1982). Wittgenstein on rules and privaye language. Cambridge: Harvard University Press.

    Google Scholar 

  • Landin, P.J. (1964). The mechanical evaluation of expressions. Computer Journal, 6(4), 308–320.

    Article  Google Scholar 

  • McLaughlin, P. (2001). What functions explain. Functional explanation and self-reproducing systems. Cambridge: Cambridge University Press.

    Google Scholar 

  • 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 

  • Milne, R., & Strachey, C. (1977). A theory of programming language semantics. New York: Halsted.

    Google Scholar 

  • 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 

  • Mitchell, J.C. (1996). Foundations for Programming languages. Cambridge: MIT.

    Google Scholar 

  • Moor, J.H. (1978). Three myths of computer Science. British Journal for the Philosophy of Science, 29(3), 213–222.

    Article  Google Scholar 

  • Mulmuley, K. (1987). Full abstraction and semantic equivalence. Cambridge: MIT.

    Google Scholar 

  • Piccinini, G. (2010). Computation in physical systems, Stanford encyclopedia of philosophy. http://plato.stanford.edu/entries/computation-physicalsystems.

  • Piccinini, G. (2008). Computation without representation. Philosophical Studies, 137, 205–241.

    Article  Google Scholar 

  • Pierce, B.C. (2002). Types and programming languages. Cambridge: MIT. ISBN 0-262-16209-1.

    Google Scholar 

  • Plotkin, G.D. (1981). A structural approach to operational semantics. Tech. Rep.19. Denmark, Aarhus: Computer Science Department, Aarhus University.

  • Putnam, H. (1988). Representation and reality. Cambridge: MIT.

    Google Scholar 

  • 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 

  • Putnam, H. (1975). Philosophical papers: Volume 2. Mind, language and reality. Cambridge: Cambridge University Press.

    Google Scholar 

  • Reynolds, J.C. (1994). An introduction to polymorphic lambda calculus in logical foundations of functional programming (pp. 77-86). England: Addison-Wesley.

    Google Scholar 

  • Searle, J.R. (1995). The construction of social reality. London: Penguin.

    Google Scholar 

  • Schmidt, D.A. (1988). Denotational semantics: a methodology for language development. Boston: Allyn & Bacon, 1986. Reprint, 1988.

  • 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.

  • Stoughton, A. (1988). Fully abstract models of programming languages. London: Pitman/Wiley.

    Google Scholar 

  • 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 

  • Stoy, J. (1977). Denotational semantics: the Scott-Strachey approach to programming language semantics. Cambridge: MIT.

    Google Scholar 

  • 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 

  • Thompson, S. (2011). Haskell: the craft of functional programming. England: Addison-Wesley. ISBN 0-201-34275-8.

    Google Scholar 

  • Thompson, S. (1995). Miranda: the craft of functional programming. England: Addison-Wesley. ISBN: 0201422794.

    Google Scholar 

  • Thomasson, A.L. (2003). Realism and human kinds. Philosophy and Phenomenological Research, 67(3), 580–609. CrossRefWeb of Science.

    Article  Google Scholar 

  • 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 

  • Tennent, R.D. (1991). Semantics of programming languages. Upper Saddle River: Prentice Hall.

    Google Scholar 

  • Turner, R. (2007). Understanding programming language. Minds and Machines, 17(2), 129–133.

    Article  Google Scholar 

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

    Article  Google Scholar 

  • Turner, R. (2011). Computable models. London: Springer.

    Google Scholar 

  • 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 

  • Winskel, G. (1993). The formal semantics of programming languages: an introduction. Cambridge: MIT.

    Google Scholar 

  • Wittgenstein, L. (1939). Wittgenstein’s lectures on the foundations of mathematics. Cambridge: University of Chicago Press.

    Google Scholar 

  • 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

Authors and Affiliations

  1. CSEE, University of Essex, Wivenhoe Park, CO43SQ, Colchester, UK

    Raymond Turner

Authors
  1. Raymond Turner
    View author publications

    You can also search for this author in PubMed Google Scholar

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

  • Received:

  • Accepted:

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s13347-012-0098-z

Keywords

Search

Navigation