Archive for the ‘Theoretical Computer Science’ Category

The Science of Delegation

March 28, 2014 Leave a comment

Most people, if they think about the topic at all, probably imagine computer science involves the programming of computers.  But what are computers?  In most cases, these are just machines of one form or another.  And what is programming?  Well, it is the issuing of instructions (“commands” in the jargon of programming) for the machine to do something or other, or to achieve some state or other.   Thus, we can view Computer Science as nothing more or less than the science of delegation.

When delegating a task to another person, we are likely to be more effective (as the delegator or commander) the more we know about the skills and capabilities and current commitments and attitudes of that person (the delegatee or commandee).   So too with delegating to machines.   Accordingly, a large part of theoretical computer science is concerned with exploring the properties of machines, or rather, the deductive properties of mathematical models of machines.  Other parts of the discipline concern the properties of languages for commanding machines, including their meaning (their semantics) – this is programming language theory.

Because the vast majority of lines of program code nowadays are written by teams of programmers, not individuals, then much of computer science – part of the branch known as software engineering – is concerned with how to best organize and manage and evaluate the work of teams of people.   Because most machines are controlled by humans and act in concert for or with or to humans, then another, related branch of this science of delegation deals with the study of human-machine interactions.   In both these branches, computer science reveals itself to have a side which connects directly with the human and social sciences, something not true of the other sciences often grouped with Computer Science: pure mathematics, physics, or chemistry.  With the rise of networked machines, we may find ourselves delegating tasks not simply to one machine, but to multiple machines, acting in concert or in parallel in some way.   The branch of computer science known as distributed computing thus deals with delegation to, and co-ordination of,  multiple machines.  As a consequence of this, computer scientists think a lot about combinations of actions and concurrency, more than do researchers in any other discipline.   This is exactly as we would expect for a science of delegation.

And from its modern beginnings 70 years ago, computer science has been concerned with trying to automate whatever can be automated – in other words, with delegating the task of delegating.  This is the branch known as Artificial Intelligence.   We have intelligent machines which can command other machines, and manage and control them in the same way that humans could.   But not all bilateral relationships between machines are those of commander-and-subordinate.  More often in distributed networks, machines are peers of one another, intelligent and autonomous (to varying degrees).  Thus, commanding is useless – persuasion is what is needed for one intelligent machine to ensure that another machine does what the first desires, just as with human beings.   And so, as one would expect in a science of delegation, computational argumentation arises as an important area of study.

Computation and Intension

April 20, 2012 Leave a comment

The first programmable device was a Jacquard Loom, a textile loom invented by Joseph Jacquard in 1801 which used punched cards to control the pattern woven by the machine.   Changing the punched cards meant the same machine could be used to weave different patterns.      In the 1980s in a factory in Zimbabwe I saw a very similar manufacturing process – relying on punched rubber belts rather than on punched cards – to place bristles into floor brushes; this was on machines made in Sheffield in the 1880s.

As is so often the case in computer science, practice comes before theory, and often long before.  Despite the widespread use of such programmable machines, a mathematical theory of programming languages only made an appearance  in the 1960s.  One of the ways we have to understand a computer program is to translate the statements made in the programming language into some other form, such as statements about mathematical objects.  We would call these statements the semantics of the computer program.

It turns out the the process of doing this may also be applied to understanding human languages, and so there is an area of common interest between theoretical computer science, lingustic theory and the philosophy of language.    This brief introduction is just to point to an interesting seminar series in this area of overlap taking place in London, organized by  Walter Dean (of Warwick University) and Sean Walsh (of Birkbeck College, London).  The series is called Computation and Intension, and the seminars will mostly be held on Friday afternoons.

Speakers in the seminar series include computer scientists, logicians and philosophers: Samson Abramsky (Computer Science, Oxford), Melvin Fitting (Philosophy, Math, Computer Science, CUNY), Peter Fritz (Philosophy, Oxford), Leon Horsten (Philosophy, Bristol), Kevin Klement (Philosophy, UMass), and Raymond Turner (Computer Science, Essex).

As always with the Humanities, no one seems able or willing to place the program on a simple web-page, only making it available as a document.  (To read a document, we need first another application, and then we need to open the document in the application, with all the attendant risks and hassle.   Why not use the browser instead?)

To do what the organizers themselves should have done, here is the program on the web:

Session 1: Friday 27 April (London Week 1)
Location: McFetridge Room, 14 Gower St., Philosophy Department, Birkbeck [map]
Seminar (13:15-14:45): Introduction: intension versus extension and the role of procedures.

Session 2: Friday 4 May (London Week 2)
Location: McFetridge Room, 14 Gower St., Philosophy Department, Birkbeck
Seminar (13:15-14:45): Background on intensional logic (Frege, Church, Montague, Tichy).

Session 3: Friday 11 May (London Week 3)
Location: McFetridge Room, 14 Gower St., Philosophy Department, Birkbeck
Seminar (13:15-14:45): Two-Dimensional Semantics and the Method of Intension and Extension (session led by Mahrad Almotahari).

Session 4: Friday 18 May (London Week 4)
Location: McFetridge Room, 14 Gower St., Philosophy Department, Birkbeck
Seminar (13:15-14:45): Russell-Myhill Paradox & Tucker-Thomason on Paradoxes of Intensionality
Speaker (15:00-16:30): Peter Fritz (Oxford), TBA.

Session 5: Friday 25 May (London Week 5)
Location: STB2 (basement level) Stewart House [map]
Seminar (13:15-14:45): Epistemic Arithmetic, Reinhardt’s argument, and Church’s Thesis
Speaker (15:00-16:30) Kevin Klement (UMass Amherst) “Russell’s Theory of Incomplete Symbols and the Paradoxes”

Session 6: Friday 1 June (London Week 6)
Location: S264 (second floor) Senate House [map]
Seminar (13:15-14:45): The recursion theorems and domain theory
Speaker (15:00-16:30): Leon Horsten (Bristol) “Epistemic Church’s Thesis”

Session 7: Friday 8 June (London Week 7)
Location: STB3 (basement level) Stewart House
Seminar (13:15-14:45): Around and about programming language semantics
Speaker (15:00-16:30): Samson Abramsky (Oxford) “Programs as data and intensional recursion”

Session 8: Friday 15 June (London Week 8)
Location: G35 (ground floor) Senate House
Seminar (13:15-14:45): Moschovakis’ theory of algorithms, intensional logic, and synonymy
Speaker (15:00-16:30): Raymond Turner (Essex) TBA.

Session 9: Friday 22 June (London Week 9)
Location: McFetridge Room, 14 Gower St., Philosophy Department, Birkbeck
Seminar (13:15-14:45): Kripke and de re beliefs about natural numbers

Session 10: THURSDAY 28 June (London Week 10)
Location: TBA
Seminar (13:15-14:45): Fixed point semantics, bilattices, and PROLOG (session led by Jonne Speck)
Speaker (15:00-16:30): Melvin Fitting (CUNY) “Bilattices in Logic Programming and the Theory of Truth”

%d bloggers like this: