Philosophy of Computer Science
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)
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
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.
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:
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).
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
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).
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,
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
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
Tim Colburn, U. of Minnesota-Duluth, USA
B. Jack Copeland, U. of Canterbury, New Zealand
Amnon H Eden, U. of Essex, UK and Center For Inquiry, USA
Barry Smith, U. of Buffalo, USA, and Institute for Formal Ontology and Medical Information Science, Saarland U., Germany
Raymond Turner, U. of Essex, UK
- 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.
- B. Jack Copeland (ed.) The Essential Turing. Oxford University
- 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:
- 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.