Please note that these pages are not actively maintained. If you wish to get involved, please contact us

This is an archived version of the page
Call for papers is now closed, See abstracts here

Philosophy of Computer Science

Track in: European conference on Computing And Philosophy—ECAP'06
22-24 June 2006, NTNU, Trondheim, Norway

Best submissions to the track will also be considered for revision and publication in: Minds and Machines, special issue on the philosophy of computer science (fall 2007)

Contents:

Important dates

Submission to the PCS track in E-CAP 2006 is closed. The conference programme is available. We thank all participants for their contributions towards an exciting event!

Presentations accepted to the PCS track in E-CAP 2006 are invited to submit their manuscripts to Minds and Machines, special issue on the philosophy of computer science.

Topics

What is the philosophy of computer science (PCS)? We take the PCS to be that branch of philosophy which is concerned with the investigation of philosophical problems that arise from within computer science. By analogy, the PCS stands to computer science as does the philosophy of mathematics to mathematics and the philosophy of physics to physics. Timothy Colburn (2003) suggested that the PCS is concerned with philosophical investigation at a level in which questions of knowledge (epistemology), existence (ontology), and value (ethics) are posed within the context of computer science.

Computer scientists are engaged with activities that can be broadly classified in terms of three philosophical positions:

  1. From its inception as a branch of mathematics and during most of its infancy (1936-1969), modern computer science had been committed primarily to the investigation of “the extent and limitations of mechanistic explanation” (von Newman about Turing's work, in Copeland 2004, p. 3). The earliest computing 'scientists' were mathematicians who developed automata theories, investigated the notion of computability and produced a well-founded vocabulary for computing (e.g., complexity, see Urquhart 2004). Theoretical computer science has emerged from the treatment of computer programs as mathematical objects on a par with differential equations: Tony Hoar (1986) suggested that “computer programs are mathematical expressions”; Edsger Dijkstra (1988) argued that “the construction of computer programs is a mathematical activity like the solution of differential equations”; and the earliest (compiled) programming languages were designed to solve problems in numerical analysis (FORTRAN, in 1954) and symbolic processing (LISP, in 1958).

  2. Since the software crisis (Naur & Randell 1969), focus has been shifted towards the engineering of reliable, efficient, and maintainable software, thereby treating software as other engineered artefacts such as bridges and automobiles. 'Third generation' programming languages were designed to address engineering concerns, including modularity (Pascal, in 1970), reliability (Ada, in 1980), and reuse (Java, in 1994). Even though its perspective has all but taken over the academic curriculum, software engineering has been observed as a term of aspiration (Gibbs 1994; Eden 2005) and its narrow focus on technology has been widely criticized (“computer science is no more about computers than astronomy is about telescopes”, Dijkstra 1988).

  3. Software science is the discipline which emanates from treating computer programs as 'natural kinds' (Copeland 2005). While it endorses analytical means for mathematical modelling, it treats computer programs not as mathematical objects but rather as 'natural phenomena', much in the way that zoology treats natural species and astronomy treats stellar bodies. In line with Quine's (1961) view of scientific theory (“the simplest conceptual scheme to which fragments of raw experience can be fitted and arranged”), software science implies scientific methods of investigation such as observation, analysis, measurement, and empirical validation. Software science stands to software engineering in the way chemistry stands to chemical engineering and material science stands to civil engineering: scientists are distinguished from engineers by being concerned with descriptive rather then normative claims. Contributions to software science include theories of programming languages and paradigms (Tennent 2000), formal methods and program verification (Wing 1990), Lehman's (1996) laws of software evolution, Turner's (forthcoming) foundations to the theory of functional specifications, software complexity (Zuse 1998), and the Intension/Locality criteria (Eden & Kazman 2003).

We solicit papers investigating philosophical questions arising from theoretical computer science, software engineering, and software science. Particularly pertinent are questions that fall into three philosophical categories:

  • Metaphysics. What is the subject matter of computer science? Are computer programs mathematical entities, human artefacts, or 'natural kinds'? Alternatively, is computer science indeed a science, is it a branch of mathematics, or perhaps an engineering discipline? Is there a realism/antirealism issue in CS as there is in mathematics? For example, can it be argued that UNIX was discovered rather than invented?

  • Ontology. What is the (top-level) taxonomy of computer programs? What is the relation between meta-software, software, and hardware? Which ontological commitments (Smith 2004) are made in programs (“source code”): are they committed to objects in the real world, to objects in the programming paradigm's vocabulary (such as mathematical functions in functional programming and objects and classes in object-oriented programming), or perhaps to the types defined in the program? Is this ontology shaped by the programming language as Alan Perlis suggested (“A good programming language is a conceptual universe for thinking about programming”), possibly in the same way that general ontology is shaped by natural language? How exactly do programming paradigms carve the universe of programs?

  • Epistemology. What is the role of mathematics in computer science? Is mathematical modelling there to supplement or replace the engineering enterprise? Is computer science an empirical theory? What would an experiment in computer science look like, and how would it be different (if at all) from an experiment in empirical sciences? Should methods of psychology serve as a model for experiments? Are experiments conducted in evolutionary programming, genetic programming, and robotics methodologically sound? What is the status of knowledge gained from conducting an experiment in computer science: is it knowledge about the real world or is it something about algorithms? Is a computer program a scientific theory?

Programme co-chairs

  • Amnon H Eden, Department of Computer Science, University of Essex, UK and Center For Inquiry, USA

  • Raymond Turner, Department of Computer Science, University of Essex, UK

Programme committee

References

  • Thomas J. Bergin II, Richard G. Gibson, II (eds.) History of Programming Languages-II. New York: ACM Press, 1996.
  • Timothy R. Colburn. Philosophy and Computer Science. Armonk: M.E. Sharpe, 2003.
  • B. Jack Copeland (ed.) The Essential Turing. Oxford University Press, 2004.
  • B. Jack Copeland. “Computability”. In: L. Floridi (ed.) The Blackwell Guide to Philosophy of Computing and Information. Malden: Blackwell, 2004.
  • B. Jack Copeland. Personal correspondence (4 Aug., 2005).
  • Edsgar W. Dijkstra. “The cruelty of really teaching computer science.” Unpublished manuscript, 1988 [Transcript]
  • Amnon H. Eden, Raymond Turner. “Problems in the ontology of computer programs.” Technical report CSM-461 (Sep. 2006), Department of Computer Science, University of Essex, ISSN 1744-8050.
  • Amnon H. Eden, Rick Kazman, Yoram Hirshfeld. “Abstraction Classes in Software Design.”  IEE Software (in press). London, UK: The Institution of Engineering and Technology.
  • W. Wayt Gibbs. “Software's chronic crisis”. Scientific American (Sep. 1994), p. 86–95.
  • C.A.R. Hoare. “Mathematics of programming.” Byte (Aug. 1986), pp. 115-149.
  • Saul Kripke. "From Church's Thesis to the First Order Algorithm Theorem." Notes from lecture, The Origins and Nature of Computing (12–15 Jun. 2006), Tel Aviv & Jerusalem, Israel.
  • Manny Lehman. “Laws of software evolution revisited”. Lecture Notes in Computer Science 1149 (Proc. 5th European Workshop on Software Process Technology), pp. 108–124. Berlin: Springer-Verlag, 1996.
  • Brain P. McLaughlin. “Computationalism, connectionism, and the philosophy of mind.” In: L. Floridi (ed.) The Blackwell Guide to Philosophy of Computing and Information. Malden: Blackwell, 2004.
  • Robin Milner. “Is Computing an Experimental Science?” (Transcript of the inaugural Lecture for the Laboratory for Foundations of Computer Science.) Tech. rep. ECS-LFCS-86-1, University of Edinburgh, 1986.
  • Peter Naur, Brian Randell (eds.) Software Engineering: Report of a conference sponsored by the NATO Science Committee (7–11 Oct. 1968), Garmisch, Germany. Brussels, Scientific Affairs Division, NATO, 1969.
  • John von Neumann. "The General & Logical Theory of Automata." Ch. in: A.H. Taub. John von Neumann: Collected Works, Vol. V: Design of Computers, Theory of Automata, and Numerical Analysis, pp. 289-326. Oxford, UK: Pergamon Press, 1951.
  • Willard Van Orman Quine. “On what there is.” In: From a Logical Point of View. Cambridge: Harvard University Press, 1961.
  • Barry Smith (ed.) The Monist, Vol. 82, No. 1 (Jan. 1999). Special issue on: “Philosophy of Computer Science.”
  • Barry Smith. “Ontology”. In: L. Floridi (ed.) The Blackwell Guide to Philosophy of Computing and Information. Malden: Blackwell, 2004.
  • Robert D. Tennent. Principles of Programming Languages. Englewood Cliffs: Prentice Hall, 1981.
  • Ray Turner. “The Foundations of Specification”. Journal of Logic and Computation, Vol. 15, No. 5 (Oct. 2005), pp. 623–663.
  • Alasdair Urquhart. “Complexity.” Ch. in: Luciano Floridi (ed.) The Blackwell Guide to Philosophy of Computing and Information. Malden: Blackwell, 2004.
  • Richard L. Wexelblatt (ed.) History of Programming Languages. New York: Academic Press, 1981.
  • Janet M. Wing. “A Specifier's introduction to formal methods.” IEEE Computer, Vol. 23, No. 9 (Sep. 1990), pp. 8–24.
  • Horst Zuse. Software Complexity. Berlin: Walter de Gruyter, 1998.

Links

Philosophy of computer science at the University of Essex. DISCLAIMER. These pages reflect our ongoing investigation of a nascent discipline. Expect omissions and errors. Comments and other contributions are welcome. (View My Stats)

 

University of Essex