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. (shrink)

We document the influence on programming language semantics of the Platonism/formalism divide in the philosophy of mathematics.

The semantics of programming languages tend to be discussed with high levels of formality; much of the previous research—both philosophical and historical—has investigated them from this perspective. In this paper, I draw on the philosophical and cognitive theories of metaphor and use the early work of Adriaan van Wijngaarden as a historical case study to explore the conceptual and discursive surroundings of semantics. I investigate the relationships between the texts of semantics, the abstract entities they denote, and the (...) metaphors, analogies, and illustrative language used to accompany or explain the same. This serves to further understanding of the historical developments of work in this area, the nature of programming languages and their semantics, and the importance of the communicative methods used in dissemination and education of computer science. (shrink)

This collection of current research on logic programming languages presents results from a three-year, ESPRIT-funded effort to explore the integration of the foundational issues of functional, logic, and object-oriented programming. It offers valuable insights into the fast-developing extensions of logic programming with functions, constraints, concurrency, and objects. Chapters are grouped according to the unifying themes of functional programming, constraint, logic programming, and object-oriented programming.

Without programming languages, machines would be idle devices much like cars without drivers or hairdressers without combs. In this chapter, we provide a guide to their definitions, and their containing paradigms. This will serve as background to one of the main objectives of this section of the book, namely to explore the semantic issues that surround programming languages.

In 1978, Brian Kernighan and Dennis Ritchie insisted that the first program to write in a new language is one to print the words “hello, world.” From then until now, “hello, world” has frequently been the first exercise in introductory programming courses. On one hand, this does seem like a good first program because it makes something familiar—a greeting—appear on the screen. On the other hand, it is extremely strange. How can it be understood as a greeting? Who is (...) greeting whom? Unfortunately, the bulk of formal means for defining programming languages provides very little help for assigning a meaning to the “hello, world” program. It is argued that the weakness of older theories and methods of programming language semantics is due to the historical, disciplinary segregation (in logic, semiotics, and linguistics) of semantics as a study apart from syntax and pragmatics. Drawing from both more recent work in programming language semantics that addresses side effects and on speech-act-based programming language design, this paper proposes a possible reintegration of semantics and pragmatics in order to better define the meaning of “hello, world” and the programming languages used to produce speech acts more generally. (shrink)

The Joint International Conference on Logic Programming, sponsored by the Association for Logic Programming, is a major forum for presentations of research, applications, and implementations in this important area of computer science. Logic programming is one of the most promising steps toward declarative programming and forms the theoretical basis of the programming language Prolog and its various extensions. Logic programming is also fundamental to work in artificial intelligence, where it has been used for nonmonotonic (...) and commonsense reasoning, expert systems implementation, deductive databases, and applications such as computer-aided manufacturing. Krzysztof R. Apt is project leader at the Centre for Mathematics and Computer Science in Amsterdam and part-time Professor in Computer Science at the University of Amsterdam. Topics covered: Theory Foundations. Programming Languages. Implementation. Programming Methodologies and Tools. Applications. Deductive Databases. Artificial Intelligence. Parallelism. (shrink)

This paper investigates intensional differences between programming languages—understood as differences in how computational processes are expressed, structured, and specified rather than merely in what they compute. While such differences have been studied in classical models of computation, they remain underexplored in the context of programming languages. Yet, programming languages undeniably compute, and any account of what “computing” means must include the ways in which they do so. The paper first clarifies the extensional/intensional distinction and (...) introduces a methodological framework to study this distinction based on Carnapian explication. It then follows an idealized programming workflow, which I structure according to the Carnapian framework, to identify where and how intensional differences arise—including during problem specification, algorithm design, language choice, data representation, and physical implementation. The final part situates intensionality within the broader epistemology of programming practice, examining how it is shaped by type-theoretic assumptions, social and historical context, and the implications of bounded outcomes. Throughout, the paper examines both the “nature” (inherent features of computable functions) and “nurture” (human factors influencing programming language design and use) of intensional differences. (shrink)

As a result of these restrictions, an implementation of L [subscript lambda] does not need to implement full higher-order unification. Instead, an extension to first-order unification that respects bound variable names and scopes is all that is required. Such unification problems are shown to be decidable and to possess most general unifiers when unifiers exist. A unification algorithm and logic programming interpreter are described and proved correct. Several examples of using L[subscript lambda] as a meta-programming language are presented.

What is a computer? I define a computer as a machine which follows an arbitrary sequence of instructions: the nature of the machine is such that one does not have to give it these instructions, if one instructs it; but that might include some washing machines. What is a dead programming language: a language which is only of interest for scholarly or nostalgic reasons. Is BASIC a dead coding language? I don’t know, but I give some reasons to think (...) not: by learning it you can converse with other parents about coding, if you are one; and the computer industry might well have a way of supporting families who supported it during its 1980s expansion; if you missed out, you have to learn BASIC. This paper is written as an imitation of P.F. Strawson. (shrink)

This paper provides an analysis of the meaning–reference problem, as traditionally advanced in the philosophy of language, for imperative programming languages. Addressing the problem is relevant for the philosophy of computer science in the context of the debate of whether simulative programs can be considered representational theories of their simulated systems. This paper challenges the thesis that, since programming languages have semantics, they also have reference, presumably to the external world. First, denotational, operational, game theoretic, and (...) axiomatic semantics are epistemologically analysed to provide a theory of meaning for high-level language programs. It is argued that programming language semantics can be seen, to some extent, under the light of Fregean descriptivism, thereby rejecting the view that it is reference that determines meaning. Secondly, descriptivist, causal, character, and intentionalist theories of reference are examined to argue that meaning is not sufficient for programming languages to determine reference, thereby rejecting the view that meaning determines reference. It is argued that it is the intentions of agents that allow programming language semantics to identify referents. The paper concludes that if the semantics of programming languages may determine their reference, the latter is not to the external world but to the internal operations of the implementation executing them. This does not prevent simulative programs from representing empirical systems, but they do so not on the basis of programming language semantics. (shrink)

Programming languages have developed significantly over the past century to provide complex models to think about and describe the world and processes of computation. Out of Alan Kay’s Smalltalk and a number of earlier languages, object-oriented programming has emerged as a preeminent mode of writing and organizing programs. Tracing the history of object-oriented programming from its origins in Simula and Sketchpad through Smalltalk, particularly its philosophical and technical developments, offers unique insights into philosophical questions about (...) objects, language, and our digital technologies. These early attempts to understand objects as basic elements of computation demonstrate the ways in which language, while firmly planted in the material reality of computation, must delimit objects from each other. This essay critically explores this history and explicates a theory of objects suggested by the development of object-oriented programming languages, which insists on the importance of language for representing and delimiting objects. It argues that the philosophies behind object-oriented programming are ultimately opposed to the claims of object-oriented ontology and find themselves more closely allied with philosophies that insist on the mediation of what exists through language. (shrink)

1. Do models formulated in programming languages use explicit rules where connectionist models do not? 2. Are rules as found in programming languages hard, precise, and exceptionless, where connectionist rules are not? 3. Do connectionist models use rules operating on distributed representations where models formulated in programming languages do not? 4. Do connectionist models fail to use structure sensitive rules of the sort found in "classical" computer architectures? In this chapter we argue that the (...) answer to each of these questions is negative. (shrink)

Recently, there have been some attempts towards developing programming languages based on situation theory. These languages employ situation-theoretic constructs with varying degrees of divergence from the ontology of the theory. In this paper, we review three of these programming languages.

Good programming depends upon well-designed programming languages, and this has been recognized from the beginnings of the discipline. Indeed, the design of programming languages is one of the core activities of professional computer scientists. There are many properties that are taken to be necessary for a good design. Most critically, the language should aid the construction of well-designed and correct programs, and this leads to principles that more directly govern language design. However, we shall not (...) try to provide a comprehensive overview and analysis of such design principles. (shrink)

Elephant 2000 is a proposed programming language good for writing and verifying programs that interact with people (eg. transaction processing) or interact with programs belonging to other organizations (eg. electronic data interchange) 1. Communication inputs and outputs are in an I-O language whose sentences are meaningful speech acts identified in the language as questions, answers, offers, acceptances, declinations, requests, permissions and promises. 2. The correctness of programs is partly defined in terms of proper performance of the speech acts. Answers (...) should be truthful and responsive, and promises should be kept. Sentences of logic expressing these forms of correctness can be generated automatically from the form of the program. 3. Elephant aource programs may not need data structures, because they can refer directly to the past. Thus a program can say that an airline passenger has a reservation if he has made one and hasn't cancelled it. 4. Elephant programs themselves can be represented as sentences of logic. Their extensional properties follow from this representation without an intervening theory of programming or anything like Hoare axioms. 5. Elephant programs that interact non-trivially with the outside world can have both input-output specification, relating the programs inputs and outputs, and accomplishment specifications concerning what the program accomplishes in the world. These concepts are respectively generalizations of the philosophers' illocutionary and perlocutionary speech acts. 6. Programs that engage in commercial transactions assume obligations on behalf of their owners in exchange for obligations assumed by other entities. It may be part of the specification of an Elephant 2000 program that these obligations are exchanged as intended, and this too can be expressed by a logical sentence. 7. Human speech acts involve intelligence. Elephant 2000 is on the borderline of AI, but the article emphasizes the Elephant usages that do not require AI. (shrink)

The construction of complex simulation models and the application of new computer hardware to ecological problems has resulted in the need for many ecologists to rely on computer programmers to develop their modelling software. However, this can lead to a lack of flexibility and understanding in model implementation and in resource problems for researchers. This paper presents a new programming language, Viola, based on a simple organisational concept which can be used by most researchers to develop complex simulations much (...) more easily than could be achieved with standard programming languages such as C++. The language is object oriented and implemented through a visual interface. It is specifically designed to cope with complicated individual based behavioural simulations and comes with embedded concurrency handling abilities. (shrink)

A number of proposals exist concerning how to support the concept of roles at the level of programming languages. While some of these proposals indeed exhibit very promising properties, the concept of roles has not found its way into mainstream programming languages. We argue that this is due to the richness of the concept of roles and the fact that each existing proposal focuses on some aspects of roles while neglecting others. We present the programming (...) language ObjectTeams/Java and using the categories of Steimann (2000) we demonstrate that this language covers more aspects of roles than previous approaches. We suggest that a thoroughly defined programming language featuring roles may contribute to a better understanding also in other fields using roles. (shrink)

This article argues that the English-language nonsense words “foo,” “bar,” “baz,” and others in a more or less standardized sequence of so-called metasyntactic variables commonly used in computer programming ought to be understood as meta-abstractive, re-representing a linguistically derived code’s abstraction of language and the abstraction of the programming language hierarchy itself, making it legible in a manner that rewards culturally oriented study: for example, of programming as a culture and of cultures of software development or engineering.

The Lisp programming language is often described as the first functional programming language and also as an important early AI language. In the history of functional programming, however, it occupies a rather anomalous position, as the circumstances of its development do not fit well with the widely accepted view that functional languages have been developed through a theoretically-inspired project of deriving practical programming languages from the lambda calculus. This paper examines the origins of Lisp (...) in the early AI programming work of the mid-to-late 1950s, and in particular in the work of Allen Newell, Cliff Shaw and Herbert Simon. Their 1956 program, the Logic Theory Machine, introduced new ideas about data and program structures that were articulated in response to perceived limitations in existing programming technique. Later writers, notably John Backus, have described these features as constituting a “programming language style” distinct from the traditional style that preceded it. The paper examines the origins of the earlier style in practices of manual computation, analyses the key technical differences between it and the style first manifested in the Logic Theory Machine, and concludes that programming practice and experience play a large and underappreciated role in the development of programming styles and languages. (shrink)

The paper studies a simply typed term system Mω providing a primitive recursive concept of parallelism in the sense of Plotkin. The system aims at defining and computing partial continuous functionals. Some connections between denotational and operational semantics → for Mω are investigated. It is shown that → is correct with respect to the denotational semantics. Conversely, → is complete in the sense that if a program denotes some number k, then it is reducible to the numeral nk. Restricting to (...) the primitive recursive kernel Rω of Mω, it is shown that → is strongly normalising with uniquely determined normal forms. The twist is the design of fixed point style conversion rules for constants accounting for parallelly bounded parallel search such that correctness and strong normalisation hold. Thereupon, minor alternations to → bring about that every reduction sequence for a program of Rω terminates either in a numeral nk if the program denotes k, or in the term 0 if the program denotes the “undefined” object. Thus, Rω can be considered a primitive recursive version of Plotkin's PA+·. (shrink)

We build on an existing a term-sequent logic for the λ-calculus. We formulate a general sequent system that fully integrates αβη-reductions between untyped λ-terms into first order logic. We prove a cut-elimination result and then offer an application of cut-elimination by giving a notion of uniform proof for λ-terms. We suggest how this allows us to view the calculus of untyped αβ-reductions as a logic programming language (as well as a functional programming language, as it is traditionally seen).

Mathematical models are an important tool in the development ofsoftware technology, including programming languages and algorithms.During the last few years, a new class of such models has beendeveloped based on the notion of a mathematical game that isespecially well-suited to address the interactions between thecomponents of a system. This paper gives an introduction to thesegame-semantical models of programming languages, concentrating onmotivating the basic intuitions and putting them into context.

Can human languages help us write programs in a different way than we usually do? To examine this question, we first define exactly what it means for a programming language to be “derived from” a human language. Next, we analyse cases in which translating a program from one human language to another does not significantly change the program’s structure. Finally, we examine two game-changing cases: a programming language derived from Latin, in which syntax plays a limited role (...) compared to morphology, and another derived from Classical Chinese, in which little linguistic recursion is available. These examples show that human languages, even ancient ones, are a reservoir for innovation in program writing. One can encourage programming language designers to dare learn foreign languages and not be ashamed of their own native language. (shrink)

• Lisp was intended to be compiled at first. However, a universal Lisp function eval in 1959 to show that neater language for computability theory than Turing Steve Russell pointed out that the universal function taken as an interpreter for pure Lisp, and hand-compiled..

Many animals can be trained to perform novel tasks. People, too, can be trained, but sometime in early childhood people transition from being trainable to something qualitatively more powerful—being programmable. We argue that such programmability constitutes a leap in the way that organisms learn, interact, and transmit knowledge, and that what facilitates or enables this programmability is the learning and use of language. We then examine how language programs the mind and argue that it does so through the manipulation of (...) embodied, sensorimotor representations. The role language plays in controlling mental representations offers important insights for understanding its origin and evolution. (shrink)

This paper adds temporal logic to public announcement logic (PAL) and dynamic epistemic logic (DEL). By adding a previous-time operator to PAL, we express in the language statements concerning the muddy children puzzle and sum and product. We also express a true statement that an agent’s beliefs about another agent’s knowledge flipped twice, and use a sound proof system to prove this statement. Adding a next-time operator to PAL, we provide formulas that express that belief revision does not take place (...) in PAL. We also discuss relationships between announcements and the new knowledge agents thus acquire; such relationships are related to learning and to Fitch’s paradox. We also show how inverse programs and hybrid logic each can be used to help determine whether or not an arbitrary structure represents the play of a game. We then add a past-time operator to DEL, and discuss the importance of adding yet another component to the language in order to prove completeness. (shrink)

The following paper examines Tuomela’s explanation of the appearance of basic social facts. In this proposal, the elementary components of a social ontology are due to the “collective intentionality” shared by different actors. Even though Tuomela alludes to language being present in some forms of intentionality in his exhibition, his reconstruction is oriented towards other forms of generating social facts that suppos-edly would not include it. In this writing, it will be argued, on the contrary, that it is not possible (...) to avoid the main mechanism of generation of basic phenomena of sociality in any of its instances. Once language takes its central place as the main mechanism for coordinating action, creator of social groups and guide for a social ontology, many of the distinctions of the intentionalist program lose relevance from an ontological point of view. (shrink)

The Language of First-Order Logic is a complete introduction to first-order symbolic logic, consisting of a computer program and a text. The program, an aid to learning and using symbolic notation, allows one to construct symbolic sentences and possible worlds, and verify that a sentence is well formed. The truth or falsity of a sentence can be determined by playing a deductive game with the computer.