A Foreword to ‘Fundamental Concepts in 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.

In many universities programming is taught using the current mainstream languages C, C++, C#, or Java. For Universities of Applied Sciences (Fachhochschulen) in Germany this is almost mandatory, as the contents of their curricula are always scrutinized with respect to (immediate) practical applicability. This contribution presents the concepts behind an elective course on ‘Concepts of programming Languages' in the master's degree program of the computer science department of the Fachhochschule Rosenheim. The course has been taught over the years, using the programming language Ada as a central subject throughout the course. In spite of the contrast to mainstream languages the use of Ada in this course has received positive feedback from the students and the colleagues and may well be designated as successful.

Early generic concepts in programming languages were mixed-type arithmetic (e.g., “+” used with any combination of fixed-and floating-point numbers) and “print” functions which could be applied to any of a language's objects. Generic concepts reduce the number of terms which must be remembered and permit considerable condensation of language design. Three different paths in the development of generic-concept languages have been followed by APL, Algol 68, and object-oriented languages such as SIMULA 67 and Smalltalk. APL was the earliest and one of the most interesting applications of generic-concept methods, but now makes the weakest use of these ideas. My talk will use slides and movies to show how the message-object programming system Smalltalk makes use of generic concepts embedded in class descriptions to give rise to a wide variety of simply programmed dynamic simulations including graphic animation, music synthesis, document layout and retrieval, and APL-like calculation features. Many of these systems have been brought to life by child and adult novice programmers. A short list of references is given for those wishing more introductory information about Smalltalk.

article Free Access Share on Values and objects in programming languages Author: B. J. MacLennan Naval Postgraduate School, Monterey, CA Naval Postgraduate School, Monterey, CAView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 17Issue 12December 1982 pp 70–79https://doi.org/10.1145/988164.988172Online:01 December 1982Publication History 43citation121DownloadsMetricsTotal Citations43Total Downloads121Last 12 Months27Last 6 weeks14 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

This paper traces the development of data abstraction concepts in programming languages. A data abstraction, or abstract data type, describes a collection of abstract entities and operations on the entities. A program which uses a data abstraction can access or modify the entities only through the abstract operations. Specific research topics discussed in the paper include: the role of type in a programming language, the formal specification of the semantics of a data abstraction, data abstraction language construct design issues, type hierarchies, and type-checking.

From the Publisher: This best-selling book, now in its fourth edition, provides a wide-ranging and in-depth discussion of programming language concepts. As in previous editions, the author describes fundamental concepts of programming languages by presenting design issues of the various language constructs, examining the design choices for these constructs in a few common languages, and critically comparing the design alternatives. The book covers the most widely used methods of syntax description and introduces the most common approaches to describing the semantics of programming languages. Discussions of implementation methods and issues are integrated throughout the book.

Three key forces are shaping the modern Computer Science (CS) curriculum: (1) new topics/courses are squeezing out existing ones; (2) a focus on "big picture" and interdisciplinary aspects of CS is leading to curricula in which the traditional core courses + electives model is being superseded by a more flexible approach based on tracks/threads; and (3) project-based courses are increasingly relying on a notion of just-in-time teaching in which particular skills are not bundled into a particular course, but are covered at a point when they are needed for particular project work. The undergraduate programming language curriculum is feeling the pressure of these forces. Core courses on programming languages and compilers are being changed to electives, relegated to a software/systems track, or phased out altogether. Particular programming languages and programming language concepts are being taught in a more piecemeal fashion on an as-needed basis. Unfortunately, these changes make it increasingly likely that CS majors can graduate without being exposed to certain "big ideas" of programming languages. Programming languages (along with many other subdisciplines of CS) contains ideas that every well-educated computer scientist needs to know and which are relevant to a wide variety of projects/careers. In a CS curriculum based on tracks and projects, how can we ensure that vital intellectual components are not lost in the shuffle? One way to think about this problem is to view the CS curriculum as a collection of aspects that can be combined in different arrangements to produce various projects/courses. In this paper, we consider the benefits and challenges of an aspect-oriented view of the CS curriculum, particularly in regard to programming language concepts.

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.

Program design languages: How much detail should they include?

Users often struggle with cloud file-sharing applications. Problems appear to arise not only from interface flaws, but also from misunderstanding the underlying semantics of operations like linking, attaching, downloading, and editing. We argue that these difficulties echo long-standing challenges in understanding concepts in programming languages like aliasing, copying, and mutation.

We provide a set of syntactic tools for structuring large collections of logical theories. Their use is demonstrated by a formalisation of algebras that are used in describing the semantics of concepts in programming languages, but also of more general systems.KeywordsTemporal LogicRelation AlgebraSequential CompositionParallel CompositionRelative CompletenessThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Due to the ubiquitous nature of mobile devices, they are now considered as an emerging platform for facilitating both teaching and learning experiences. In this paper, we presented a tailored mobile learning system, namely the Integrated English and Programming Language Learning System (IEPLS), which aims at learning English vocabulary before studying programming language concepts. The IEPLS supports programming language learning in three ways; (a) Recommending to learn specific English vocabulary used in programming language concepts (b) Adaptation to the learning flow of the learner and (c) Motivating and encouraging learners to learn items based on individual learner's performance. The IEPLS was used by one hundred and fifty undergraduate students for six months. Evaluation results revealed the attainment of IEPLS in supporting learners in learning programming languages backed by precise English vocabulary.

A highly significant benefit of MDA is that it raises the level of abstraction at which the soft-ware developer is able to work. However, the languages available to the developer have not seen much change in the last decade. Modeling languages offer high level concepts, but the pre-dominant modeling language (UML) offers too little expressive power to be able to specify a system completely. Meanwhile, the level of abstraction of most programming language con-cepts is the same as 10 to 15 years ago. Although transformation tools may to some extent bridge the gap between modeling and programming languages, in practice the developer still needs to do both modeling and programming. This means switching between the two levels of abstractions, which is difficult for most people. We argue that a general purpose, high level, software language is necessary to get MDA adopted. This language will enable any developer to focus on the problem at hand while the supporting tools – transformation tools or generators- take care of the nitty gritty details. This paper introduces an early version of such a language, which brings together a number of powerful concepts from various sources: UML, OCL, design patterns, existing programming languages, and eventually aspect-oriented languages.

YouTube is one of the most popular video sharing platforms that hosts many video tutorials which aim to teach concepts of various programming languages. Most of these tutorials include code snippets in the videos. However, it is important that the learners have hands-on experience while learning various programming concepts. Providing a code editor along with the video tutorial could help learners get a better learning experience, as they have a scope to learn by practice. Existing solutions of accompanying video tutorials with code editors are either pre-programmed or require a separate web portal. We are not aware of any solutions in the current literature that aim to support Youtube video tutorials. Hence, we present YTCoder in this paper that aims to improve the learning experience by integrating videos related to various programming languages with the development environments of the respective programming languages. Demonstration of YTCoder can be found here - https://youtu.be/iONtO7cuQwo.

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.