Euclid

Program design languages: How much detail should they include?

Why do some programming languages fail and others succeed? What does the answer tell us about programming language design, implementation, and principles? To help answer these and other questions, we argue for examining the sociological groundings of programming language theory: socio-PLT.Researchers in the social sciences have studied adoption in many contexts. We show how their findings are applicable to programming language design. For example, many programming language features provide benefits that programmers cannot directly or immediately observe and therefore may not find compelling. From clean water to safe sex, the health community has repeatedly identified and surmounted similar observability barriers. We use such results from outside of programming language theory to frame a research agenda that should help us understand the social foundations of languages. Finally, we examine implications of our approach, such as for the design space of language features and the assessment of scientific research into programming languages.

Hundreds of programming languages are in use todayscripting languages for Internet commerce, user interface programming tools, spreadsheet macros, page format specification languages, and many others. Designing a programming language is a metaprogramming activity that bears certain similarities to programming in a regular language, with clarity and simplicity even more important than in ordinary programming. This comprehensive text uses a simple and concise framework to teach key ideas in programming language design and implementation. The book's unique approach is based on a family of syntactically simple pedagogical languages that allow students to explore programming language concepts systematically. It takes as its premise and starting point the idea that when language behaviors become incredibly complex, the description of the behaviors must be incredibly simple. The book presents a set of tools (a mathematical metalanguage, abstract syntax, operational and denotational semantics) and uses it to explore a comprehensive set of programming language design dimensions, including dynamic semantics (naming, state, control, data), static semantics (types, type reconstruction, polymporphism, effects), and pragmatics (compilation, garbage collection). The many examples and exercises offer students opportunities to apply the foundational ideas explained in the text. Specialized topics and code that implements many of the algorithms and compilation methods in the book can be found on the book's Web site, along with such additional material as a section on concurrency and proofs of the theorems in the text. The book is suitable as a text for an introductory graduate or advanced undergraduate programming languages course; it can also serve as a reference for researchers and practitioners.

The PLDI conference is one of the premier forums for the presentation of new and exciting research in the areas of programming language design and implementation. The conference attracts a wide audience including researchers, practitioners, and educators. The program committee is pleased to present this proceedings of the 2003 ACM SIGPLAN Conference on Programming Language Design and Implementation which contains a collection of 28 technical papers covering a wide range of exciting topics.This year a total of 131 manuscripts were received from 20 countries. We received 96 submissions from North America, 17 submissions from Europe, 16 submissions from Asia, and 2 submissions from Australia. A total of 36 papers had at least one author from industry. From the 131 submissions, the program committee selected 28 submissions for inclusion in the program.The submission and review process worked as follows. Each submission was assigned to three program committee members for review. In addition, one external review was solicited for each paper. For papers with conflicting reviews email discussions preceded the program committee meeting. For papers with low confidence reviews additional reviews were sought from experts before the program committee meeting. The program committee meeting was held in New Orleans on January 19 and 20. Early in the meeting, the 131 papers were narrowed down to 75 papers whose discussion occupied the rest of the meeting.

International audience

There has long been a close association between research in software engineering and the design of programming languages. Part of the IMPACT project involves an exploration of the interrelations of these two fields and documentation in a report of how fundamental research in software engineering has been a valuable resource for programming language features commonly used today. The resulting report investigates the relationship by considering features in currently used languages, including exceptions, control and data abstractions, types, inheritance, concurrency and visualization mechanisms.This paper, exerpted from the report, focuses on the influence of software engineering research on the development of exceptions. The paper demonstrates that there is a symbiotic relationship between software engineering research and the design of exception handing in programming languages. Publication of these partial results is aimed at soliciting feedback and comments from both the programming languages and software engineering communities.

Christopher Strachey’s paper on Fundamental Concepts in Programming Languages is being published here for the first time. Written in the autumn of 1967, it is based on the lectures given by Strachey at an International School in Computer Programming, held in Copenhagen in August 1967. Strachey intended the paper to be published in the proceedings of the School—but the proceedings never materialized, and Strachey’s paper has remained an unpublished preprint for more than three decades. It is, however, one of Strachey’s most significant and lengthy papers; widely circulated in the original typescript version, it has also been highly influential. Strachey’s paper starts with some philosophical remarks about the need to focus on semantic issues in the design of programming languages, and to “recognise and isolate the central concepts—things analogous to the concepts of continuity and convergence in analysis”. Strachey then proceeds to give a clear and incisive exposition of many of his insights into programming language design and formal semantics, covering the following main topics: r assignment commands, Land R-values; r expression evaluation and environments; r commands and sequencing; r modes of parameter-passing and variable binding; r functions and routines as data items; r types and (parametric) polymorphism; and r compound data structures and pointers.

This paper reports some misconceptions that are frequently detected in students of introductory compiler construction courses. Compiler construction is a topic included in many university computer science programs. It deals with the design and implementation of programming and other computer languages. These misconceptions have been identified by the author when teaching the topic at the Complutense University of Madrid (Spain). The misconceptions are classified according to the different stages approached in compiler construction: lexical level, syntactic level, semantic level. At the lexical level the following misconceptions are documented: (i) incorrect identification of token types; (ii) transitions with more than one symbol in the state transition diagrams; and (iii) inadequate treatment of keywords. Misconceptions at the syntactic level include: (i) confusing non-determinism and ambiguity; (ii) considering ε (the empty string) as a terminal symbol; (iii) misinterpreting operator precedence; (iv) attempting to perform type checking at the syntactic level; and (v) grammar transformation errors. Finally, the following misconceptions are reported at the semantic level: (i) transformations that do not preserve semantics; (ii) difficulties in determining the abstract syntax trees of complex sentences; (iii) incorrect interpretation of how the symbol table works during the analysis of lexically-scoped languages; (iv) variable addressing errors; and (v) errors related to the translation of complex designators. Identifying these errors is very useful in developing instructional strategies to help students avoid them.

This is the 23rd Self-Assessment Procedure. 1 The purpose of this procedure is to let its readers test their knowledge of some of the more important features of significant programming languages. The features of imperative languages like Fortran, Algol 60, PL/I, Pascal, Modula-2, C, and Ada considered are data types, data structures, control structures, program units, scope of names, and parameter passing. Some of the corresponding features of functional languages like Lisp, logic programming languages like Prolog, and ohject-oriented programming languages like C++ and Smalltalk, are reviewed. Finally brief consideration is given to syntax and semantics, chiefly by reference to the Backus-Naur form, BNF. The features of programming languages affect all aspects of programming, including the ease of writing and maintaining programs, the reliahility of software, and the efficiency and portability of programs. Knowledge of programming language concepts and constructs is of importance to software developers, programmers, and designers of programming languages and compilers. The topic of this procedure should be of interest to any computer science student or practitioner who wishes to test his or her knowledge and learn more about one of the most important and broad areas in the computer field. The language used most often in the questions is Pascal, with Ada, Lisp, and Prolog also featured prominently. A glossary is included which defines some of the terms used in the procedure. The questions are either multiple-choice or short answer. Some of the multiple-choice questions allow for more than one correct answer.

Approaches for programming language design used commonly in the research community today center around theoretical and performance-oriented evaluation. Recently, researchers have been considering more approaches to language design, including the use of quantitative and qualitative user studies that examine how different designs might affect programmers. In this paper, we argue for an interdisciplinary approach that incorporates many different methods in the creation and evaluation of programming languages. We argue that the addition of user-oriented design techniques can be helpful at many different stages in the programming language design process.

PLACES 2015 (full title: Programming Language Approaches to Concurrency- and Communication-Centric Software) is the eighth edition of the PLACES workshop series. After the first PLACES, which was affiliated to DisCoTec in 2008, the workshop has been part of ETAPS every year since 2009 and is now an established part of the ETAPS satellite events. PLACES 2015 was held on 18th April in London, UK. The workshop series was started in order to promote the application of novel programming language ideas to the increasingly important problem of developing software for systems in which concurrency and communication are intrinsic aspects. This includes software for both multi-core systems and large-scale distributed and/or service-oriented systems. The scope of PLACES includes new programming language features, whole new programming language designs, new type systems, new semantic approaches, new program analysis techniques, and new implementation mechanisms. This volume consists of revised versions of the papers that were presented at the workshop.

PLACES 2017 (full title: Programming Language Approaches to Concurrency- and\nCommunication-cEntric Software) is the tenth edition of the PLACES workshop\nseries. After the first PLACES, which was affiliated to DisCoTec in 2008, the\nworkshop has been part of ETAPS every year since 2009 and is now an established\npart of the ETAPS satellite events. PLACES 2017 was held on 29th April in\nUppsala, Sweden. The workshop series was started in order to promote the\napplication of novel programming language ideas to the increasingly important\nproblem of developing software for systems in which concurrency and\ncommunication are intrinsic aspects. This includes software for both multi-core\nsystems and large-scale distributed and/or service-oriented systems. The scope\nof PLACES includes new programming language features, whole new programming\nlanguage designs, new type systems, new semantic approaches, new program\nanalysis techniques, and new implementation mechanisms. This volume consists of\nthe papers accepted for presentation at the workshop.\n

Current software development practices, including those specified in DOD-STD-2167, frequently prescribe the use of program design languages (PDLs) during preliminary and critical design. Lockheed has developed an Ada design language (ADL) that supports management goals such as cost reduction, process control, and evaluation by customers during the entire software development life-cycle.The literature shows the many ways that Ada-based PDLs support software engineering goals1 like modularity, readability, loose coupling, strong cohesion, and data abstraction2. A negative aspect of many previous Ada-based PDLs is that the languages tend to allow developers and designers to provide too much detail early in the life-cycle, as the full Ada language is allowed by these design languages. This detail can cause harmful early focus on “how” the functionality is implemented, at the expense of considering “what” functionality is required. Managers and their customer counterparts may find it impractical to master all the facets of the full Ada programming language, and therefore may not understand the designs represented by a full Ada-based design language. Other deficiencies of full Ada-based design languages include the lack of a clear distinction between ADL as a language, and support for that language via tools, as well as the absence of clear connection to life-cycle milestones. Industry writers recently3 have observed that the connectivity of the PDL and milestones remains unclear.

This volume contains the proceedings of the 21th Brazilian Symposium on Programing Languages (SBLP 2017), held during September 21-22, 2017, at Fortaleza, Brazil. SBLP is a well-established symposium, promoted by the Brazilian Computer Society since 1996, and provides a venue for researchers and practitioners interested in the fundamental principles and innovations in the design and implementation of programming languages and systems. Since 2010, SBLP has been organized in the context of CBSoft (Brazilian Conference on Software: Theory and Practice), colocated with a number of other events on computer science and software engineering.

The combination of Ada® used as a programming language and as a program design language (PDL) can effectively help automate the enforcement of design methods and the creation of design documentation. This paper discusses how design automation can be applied successfully to the development of complex Ada systems under DOD-STD-2167. In particular, the use of an Ada-based PDL as the basis for capturing design decisions is examined. The paper also explores the implications of such an approach in the context of integrated tool support, namely, the ability to produce documents automatically, to enforce project-specific design rules, to provide interactive traversing between design and implementation, and to facilitate traceability.