The emperor's old clothes
TL;DR: The 1980 ACM Turing Award was presented to Charles Antony Richard Hoare, Professor of Computation at the University of Oxford, England, by Walter Carlson, Chairman of the Awards Committee, at the ACM Annual Conference in Nashville, Tennessee, October 27, 1980.
Abstract: The 1980 ACM Turing Award was presented to Charles Antony Richard Hoare, Professor of Computation at the University of Oxford, England, by Walter Carlson, Chairman of the Awards Committee, at the ACM Annual Conference in Nashville, Tennessee, October 27, 1980. Professor Hoare was selected by the General Technical Achievement Award Committee for his fundamental contributions to the definition and design of programming languages. His work is characterized by an unusual combination of insight, originality, elegance, and impact. He is best known for his work on axiomatic definitions of programming languages through the use of techniques popularly referred to as axiomatic semantics. He developed ingenious algorithms such as Quichsort and was responsible for inventing and promulgating advanced data structuring techniques in scientific programming languages. He has also made important contributions to operating systems through the study of monitors. His most recent work is on communicating sequential processes. Prior to his appointment to the University of Oxford in 1977, Professor Hoare was Professor of Computer Science at The Queen's University in Belfast, Ireland, from 1968 to 1977 and was a Visiting Professor at Stanford University in 1973. From 1960 to 1968 he held a number of positions with Elliott Brothers, Ltd., England.
Citations
More filters
Book•
01 Jan 2006
TL;DR: This revised edition of Software Abstractions updates the text, examples, and appendixes to be fully compatible with the latest version of Alloy, a language that captures the essence of software abstractions simply and succinctly, using a minimal toolkit of mathematical notions.
Abstract: In Software Abstractions Daniel Jackson introduces an approach to software design that draws on traditional formal methods but exploits automated tools to find flaws as early as possible. This approach--which Jackson calls "lightweight formal methods" or "agile modeling"--takes from formal specification the idea of a precise and expressive notation based on a tiny core of simple and robust concepts but replaces conventional analysis based on theorem proving with a fully automated analysis that gives designers immediate feedback. Jackson has developed Alloy, a language that captures the essence of software abstractions simply and succinctly, using a minimal toolkit of mathematical notions. This revised edition updates the text, examples, and appendixes to be fully compatible with the latest version of Alloy (Alloy 4). The designer can use automated analysis not only to correct errors but also to make models that are more precise and elegant. This approach, Jackson says, can rescue designers from "the tarpit of implementation technologies" and return them to thinking deeply about underlying concepts. Software Abstractions introduces the key elements: a logic, which provides the building blocks of the language; a language, which adds a small amount of syntax to the logic for structuring descriptions; and an analysis, a form of constraint solving that offers both simulation (generating sample states and executions) and checking (finding counterexamples to claimed properties).
1,641 citations
Additional excerpts
...As Tony Hoare famously put it in his Turing Award lecture [29]: There are two ways of constructing a software design: One way is to make it so simple there are obviously no deficiencies and...
[...]
IBM1
TL;DR: The authors introduce a new programming language concept, called typestate, which is a refinement of the concept of type, which determines the subset of operations which is permitted in a particular context.
Abstract: The authors introduce a new programming language concept, called typestate, which is a refinement of the concept of type. Whereas the type of a data object determines the set of operations over permitted on the object, typestate determines the subset of these operations which is permitted in a particular context. Typestate tracking is a program analysis technique which enhances program reliability by detecting at compile-time syntactically legal but semantically undefined execution sequences. These include reading a variable before it has been initialized and dereferencing a pointer after the dynamic object has been deallocated. The authors define typestate, give examples of its application, and show how typestate checking may be embedded into a compiler. They discuss the consequences of typestate checking for software reliability and software structure, and summarize their experience in using a high-level language incorporating typestate checking.
581 citations
Cites background from "The emperor's old clothes"
...Thus, typestate checking makes it possible for a language to satisfy a requirement urged by Hoare [9] and others, that a language enforce the security of programs....
[...]
...In practice, formal verification techniques, e.g., Hoare logic [8] presuppose either that there are no nonsensical programs co-resident with the program being verified, or that none of these programs are able to affect the program being formally verified ....
[...]
TL;DR: This paper identifies the major concepts and describes some of the more important language notations for writing concurrent programs and three general classes of concurrent programming languages are identified and compared.
Abstract: Much has been learned in the last decade about concurrent programming. This paper identifies the major concepts and describes some of the more important language notations for writing concurrent programs. The roles of processes, communication and syhchronization are discussed from both an operational and an axiomatic viewpoint. Language notations for expressing concurrent execution and for specifying process interaction are surveyed. Synchronization primitives based on shared variables and on message passing are described. Finally, three general classes of concurrent programming languages are identified and compared.
540 citations
Book•
01 Jul 1993TL;DR: The benefits of object-orientation, object-oriented programming and BETA introduction to basic concepts and examples of using virtual patterns are presented.
Abstract: Introduction - benefits of object-orientation, object-oriented programming and BETA introduction to basic concepts - perspectives on programming, object-oriented programming objects and patterns - overview, reference attributes, pattern attributes repetitions - reallocation, assignment and slice, the text pattern imperatives - introduction to evaluations, for-imperative, if-imperative, labels and jump imperatives, a large example, assignment and equality, computed references and computed remote name, detailed description of evaluations, block structure and scope rules, object kinds and construction modes sub-patterns - specialization by simple inheritance, specialization of actions, enter/exit-parts for sub-patterns, the object patterns, summary, qualifications and scope rules virtual procedure patterns, continued extension of a virtual patterns, more examples of using virtual patterns, benefits of virtual patterns, summary block structure - simple block structure, class grammar, flight reservation example virtual class patterns - directly qualified virtual class patterns, general parameterized class patterns part objects and reference attributes - part objects, reference attributes pattern variables - declaration of pattern variables, example procedural programming - functional classes, higher order procedure patterns, virtual classes and genericity deterministic alternation - execution stacks, generators, components and recursive procedure patterns, abstract super-patterns concurrency - concurrent execution of components, monitors, direct communication between components, compound systems, readers and writers problem non-determinstic alternation - alternating execution of components, a distributed calendar, bounded buffer, a simple game exception handling - simple exceptions, recovery, partial recovery, handlers for procedure patterns, system exceptions, language-defined exceptions, advanced design of exception patterns modularization - fragments, separation of interface and implementation, alternative implementations, programme variants, using several libraries, visibility and binding rules (part contents).
500 citations
TL;DR: This paper gives the view of what a distributed system is, and describes the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures.
Abstract: When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper.We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give the flavor of each. These examples include languages based on message passing, rendezvous, remote procedure call, objects, and atomic transactions, as well as functional languages, logic languages, and distributed data structure languages. The paper concludes with a comprehensive bibliography listing over 200 papers on nearly 100 distributed programming languages.
458 citations
References
More filters
Journal Article•
4,463 citations
TL;DR: A programming system called LISP (for LISt Processor) developed for the IBM 704 computer by the Artificial Intelligence group at M.I.T. was designed to facilitate experiments with a proposed system called the Advice Taker, whereby a machine could be instructed to handle declarative as well as imperative sentences and could exhibit "common sense" in carrying out its instructions.
Abstract: A programming system called LISP (for LISt Processor) has been developed for the IBM 704 computer by the Artificial Intelligence group at M.I.T. The system was designed to facilitate experiments with a proposed system called the Advice Taker, whereby a machine could be instructed to handle declarative as well as imperative sentences and could exhibit “common sense” in carrying out its instructions. The original proposal [1] for the Advice Taker was made in November 1958. The main requirement was a programming system for manipulating expressions representing formalized declarative and imperative sentences so that the Advice Taker system could make deductions. In the course of its development the LISP system went through several stages of simplification and eventually came to be based on a scheme for representing the partial recursive functions of a certain class of symbolic expressions. This representation is independent of the IBM 704 computer, or of any other electronic computer, and it now seems expedient to expound the system by starting with the class of expressions called S-expressions and the functions called S-functions.
1,435 citations
Book•
01 Jan 1941
TL;DR: The Calculi of Lambda Conversion as discussed by the authors is a book about Lambda conversion with a focus on the Lambda transformation process, and it is available in bookstores. (AM-6)
Abstract: The description for this book, The Calculi of Lambda Conversion. (AM-6), will be forthcoming.
1,069 citations
TL;DR: It is shown how some forms of expression in current programming languages can be modelled in Church's X-notation, and a way of "interpreting" such expressions is described, which suggests a method of analyzing the things computer users write.
Abstract: This paper is a contribution to the \"theory\" of the activity of using computers. It shows how some forms of expression used in current programming languages can be modelled in Church's X-notation, and then describes a way of \"interpreting\" such expressions. This suggests a method, of analyzing the things computer users write, that applies to many different problem orientations and to different phases of the activity of using a computer. Also a technique is introduced by which the various composite information structures involved can be formally characterized in their essentials, without commitment to specific written or other representations.
979 citations