Abstract: The literature on programming languages contains an abundance of informal claims on the relative expressive power of programming languages, but there is no framework for formalizing such statements nor for deriving interesting consequences. As a first step in this direction, we develop a formal notion of expressiveness and investigate its properties. To demonstrate the theory's closeness to published intuitions on expressiveness, we analyze the expressive power of several extensions of functional languages. Based on these results, we believe that our system correctly captures many of the informal ideas on expressiveness, and that it constitutes a good basis for further research in this direction.

Abstract: Constraint Logic Programming (CLP) is an extension of Logic Programming aimed at replacing the pattern matching mechanism of unification, as used in Prolog, by a more general operation called constraint satisfaction. This aritcle provides a panoramic view of the recent work done in designing and implementing CLP languages. It also presents a summary of their theoretical foundations, discusses implementation issues, compares the major CLP languages, and suggests directions for further work.

Abstract: This book is based on a course given to second-year computer science undergraduates at the University of Sussex in the spring of 1988 and 1989. It offers an elementary introduction to the semantics of programming languages in a form which is designed to be accessible to students who are not very advanced in their undergraduate career. All the material in the book may easily be covered in a one-term course. There are very few prerequisites. Students who have undertaken an introductory programming course and who are familiar with elementary mathematical notation should have little difficulty in following it. A first course in discrete mathematics would be more than sufficient to cover the required background material.

Abstract: We propose a new object-oriented programming language called RTC++ for programming real-time applications. RTC++ is an extension of C++ and its features are to specify i) a real-time object which is an active entity, ii) timing constraints in an operation as well as in statements, and iii) a periodic task with rigid timing constraints.In this paper, we first discuss real-time programming issues and what language support should be provided for building real-time applications. Then, the key features of RTC++ are described. Some programming examples are shown to demonstrate RTC++'s expressive power. A comparison to other programming languages are also discussed.

Abstract: Distributed computing systems distributed programming without language support language support for programming distributed systems language for programming distributed systems the share data-object model implementation example programs and their performance .

Abstract: Emerald is a general-purpose language with aspects of traditional object-oriented languages, such as Smalltalk, and abstract data type languages, such as Modula-2 and Ada. It is strongly typed with a non-traditional object model and type system that emphasize abstract types, allow separation of typing and implementation, and provide the flexibility of polymorphism and subtyping with compile-time checking. This paper describes the Emerald language and its programming methodology. We give examples that demonstrate Emerald's features, and compare and contrast the Emerald approach to programming with the approaches used in other similar languages.

Abstract: Data-flow languages and visual programming environments are reviewed. The iconic data flow (IDF) system, a visual programming environment initially oriented toward the development of image processing and computer vision algorithms, is described. It is intended to exploit the intuitive nature of flow charts and the human capability for comprehending pictures, while providing a fully featured, easy to use programming language, including a full set of data types and control flow operators. Experimental performance results on the size of the programs that can be described and how fast they run are reported. Areas for future work are indicated. >

Abstract: This book introduces the basic concepts that underlie functional, object-oriented and imperative programming languages. It then goes on to cover more advanced topics.

Abstract: This chapter describes three ‘implicit theories’ of programming, which have at different times governed the styles of programming language design. Not surprisingly, the experiments performed by empirical researchers have also been deeply influenced by the prevailing theory of the day. (1) The first view regarded programming as transcription from an internally-held representation of the program. This leads to Fortran-like languages, and the early empirical studies of programming correspondingly emphasised particular language features and their incidence of errors. (2) The second view stressed program comprehension and required programs to be demonstrably correct, leading to Pascal-like languages and the pseudo-psychological theory of ‘structured programming’. Empirical research during this era showed that giving programmers easy access to information they needed (whether structured or not) was what really mattered. Visual programming began during this era, but most empirical studies failed to demonstrate any inherent advantage to visual presentation. Where advantages were found, they appeared to fit the same fundamental principle. (3) Today's view is that program design is exploratory, and that designs are created opportunistically and incrementally. Supporting opportunistic design means putting a minimum of unnecessary demands on working memory, permitting designers and programmers to postpone decisions until they are ready for them, allowing easy additions or changes to existing code, etc. Empirical research on change processes and reuse of code has demonstrated differences between language designs, but has a long way to go. The chapter ends with suggestions for ‘lowering the cognitive barriers to programming’ by more careful design of languages.

Abstract: This paper describes PM ∗ (read PM-star) a first-order logic based language, that is the basis of a knowledge based system designed to help non-expert users construct Linear Programming models in the Production, Distribution and Inventory planning domain. Problems specified in PM ∗ define a logic model which is used to generate problem-specific inferences and inferences required to automate model construction. PM ∗ extends previous work on the PM language (Krishnan, 1988) through the integration of problem representation and model construction within a uniform predicate logic frame.

Abstract: The authors consider software validation, a process common to both maintenance and development, in the context of systems written in an object-oriented language. The problems in using current testing techniques for object-oriented systems are shown. The question of whether the language features present in object-oriented programming languages enhance or inhibit the testing process is raised. Also considered is whether any new techniques designed for object-oriented programming could be used to ease the testing process, which in turn would help both developers and maintainers produce more reliable code. >

Abstract: Read more and get great! That's what the book enPDFd programming languages an interpreter based approach will give for every reader to read this book. This is an on-line book provided in this website. Even this book becomes a choice of someone to read, many in the world also loves it so much. As what we talk, when you read more every page of this programming languages an interpreter based approach, what you will obtain is something great.

Abstract: SKILL is a programming language that supports both command entry and procedural customization in OpusTM Design FrameworkTM. After briefly considering some related work, we examine the requirements that motivate the provision of a programming language available to the user and describe some of the technical characteristics of the language design and implementation. Finally, we describe our experience with the language and outline future work. A number of programming examples are appended.

Abstract: A very general lattice-based language of commands, based on the primitive operations of substitution and test for equality, is constructed. This base language permits unbounded nondeterminism, demonic and angelic nondeterminism. A dual language permitting miracles is constructed. Combining these two languages yields an extended base language which is complete, in the sense that all monotonic predicate transformers can be constructed in it. The extended base language provides a unifying framework for various specification languages; we show how two Dijkstra-style specification languages can be embedded in it. —Authors' Abstract

Abstract: Owing to the fast growing need for better means of building real-time systems, a number of representative languages used in real-time programming is surveyed. The evaluation focuses on seven languages which possess explicit real-time features. Based on a categorization of the latter, the seven languages are then compared with respect to their real-time capabilities. The strong points and the limitations of Ada and PEARL, the only high-level real-time languages readily applicable in industrial control environments, are covered in more detail. The evaluation reveals that none of the languages actually used in industry is genuinely real-time. Therefore, a number of new features is suggested for incorporation into existing or future languages and their run-time environments. These proposals are meant to advance the inadequate state of affairs, and also to reignite the discussion of this topic in the real-time community.

Abstract: Database programming languages represent an attempt to merge the technologies of programming languages and database management in order to improve the development of data-intensive applications. One aspect of the research on database programming languages is an attempt to exploit polymorphism and higher order functions to integrate query algebra capabilities into programming languages. This has proved to be difficult especially in strongly and statically typed languages, due to the high level of polymorphism and reflection in database query languages. For example, the natural join operation of relational algebra requires examination of the types of the input relations to determine the match predicate and output type, neither of which are easily expressed in current polymorphic programming languages. These aspects of natural join require quite sophisticated polymorphism and some kind of reflection. The reflection must be powerful enough to allow the examination of the input types to determine the match function and to synthesize the output type. It is the difficulty in achieving such power parsimoniously that we examine in this paper.

Abstract: The notion of the programming plan as a description of one of the main types of strategy employed in the comprehension of programs is now widely accepted to form an adequate basis for an account of programming knowledge. Such plans are thought to be used universally in all programming languages by expert programmers. Recent work, however, has questioned the psychological reality of such plans and has suggested that they may be artifacts of the particular programming language used and the structure that it imposes on the programmer via the constraints of certain features of its notation. This paper considers the results of two experimental studies that suggest that the development and use of programming plans is strongly tied to the particular learning experience of the programmer. It is argued that programming plans cannot be considered solely to be natural strategies that evolve independently of teaching nor as mere artifacts or static properties of a particular programming language. Rather, such plans can be seen to be related to the expression of design-related skills. This has a number of important implications for our understanding of the nature and development of programming plans, and in particular, it appears that the notion of the programming plan provides too limited a view to adequately and straightforwardly explain the differences between novice and the expert's programming performance.

Abstract: In this chapter we develop an interpreter of a higher-order constraint logic programming language in Standard ML (SML). The logic programming language is closely related to λProlog [25], though the type system supported by our implementation is more general, for example by allowing explicit abstraction over types. The implementation is closely modeled after eLP, an implementation of λProlog in the Ergo Support System [8, 20] and may be considered as a rational reconstruction and explanation of the eLP implementation.

Abstract: A proof system for a shared dataspace programming notation called Swarm (a programming logic similar in style to that of UNITY) is specified. Relevant aspects of the Swarm language and model are overviewed. To illustrate the proof system, the Swarm logic is used to verify the correctness of a program for labeling connected equal-intensity regions of a digital image. Like UNITY, the Swarm proof system uses an assertional programming logic which relies upon proof of programwide properties, e.g. global invariants and progress properties. The Swarm logic is defined in terms of the same logical relations as UNITY (unless, ensures, and leads-to), but several of the concepts are reformulated to accommodate Swarm's distinctive features. >

Abstract: We present an experimental programming language called ErIang which is suitable for programming telephony applications. We discuss some of the requirements for such a language and introduce the language by a series multiple examples which show how both sequential and concurrent activities can be programmed. We discuss the error recovery mechanism used in ErIang together with the performance characteristics of the current implementation,

Abstract: A programming language processing system for a computer language processing system wherein a program described in a high level programming language is translated into another program written in lower level programming language. In one embodiment of the invention, a specification of a programming language incorporates a concept of handling various basic words classified by parts-of-speech including nouns, adjectives, conjunctions, and various logic words. The program described by the programming language is converted into an internal expression form based on a sentence structure which can be converted to a binary tree. In accordance with a logic synthesis rule for term-rewriting based on a pattern collation, a logic expressed by the internal expression form is subject to conversion to a lower level program description wherein the parts-of-speech are deleted.

Abstract: We present a logic programming language that uses implications and universal quantifiers in goals and in the bodies of clauses to provide a simple scoping mechanism for program clauses and constants. Within this language it is possible to define a simple notion of parametric module and local constant. Given this ability to structure programs, we explore how object-oriented programming, where objects are viewed as abstractions with behaviors, state, and inheritance, might be accommodated. To capture the notion of mutable state, we depart from the pure logic setting by adding a declaration that certain local predicates are deterministic (they succeed at most once). This declaration, along with a goal-continuation passing style of programming is adequate to model the state of objects. We also examine a few aspects of how having objects embedded in logic programming can be used to enrich the notion of object: for example, objects may be partial (that is, may contain free variables) and non-deterministic, and it is possible not only to search for objects with certain properties but also to do hypothetical reasoning about them. Comments University of Pennsylvania Department of Computer and Information Science Technical Report No. MSCIS-90-31. This technical report is available at ScholarlyCommons: https://repository.upenn.edu/cis_reports/545 Representing Object In A Logic Programming Language With Scoping Constructs MS-CIS-90-31 LINC LAB 172 Joshua S. Hodas Dale Miller Department of Computer and Information Science School of Engineering and Applied Science University of Pennsylvania Philadelphia, PA 19104

Abstract: Sound type systems have existed for several years for languages with polymorphism, the ability for procedures. Successful systems also exist for languages with a non-trivial notion of subtyping, such as is provided in some modestly object-oriented languages. The work in this dissertation was motivated by the problem of providing a sound and flexible type system for languages with both of these properties. We have developed a new kind of type expression, which we call constrained quantification, given a semantics for these new expressions, and developed algorithms for soundly inferring such types for programs in a particular sample programming language. This language has all of the essential features of a polymorphic functional language along with the kernel functionality of object-oriented languages. In addition to solving the type system problem for this class of languages, constrained quantification outperforms the traditional polymorphic type analysis algorithms even in languages without subtyping. We claim that constrained quantification is a flexible, powerful, practical and formally comprehensible approach to polymorphic type analysis, especially when applied to languages with non-trivial subtyping. The dissertation demonstrates this claim in more than enough detail for constrained quantification to find immediate use in a practical programming environment.

Abstract: Saraswat recently introduced the framework of concurrent constraint programming [14]. The essence of the framework is that computations consist of concurrent agents interacting by communicating constraints. Several concurrent constraint programming languages have been defined. They differ in the kinds of constraints that can be used as well as the kinds of operations on constraints which are available. In this paper we introduce a very simple concurrent constraint language we call Lucy, designed to closely mimic the actor model of computation. Agents can communicate only by the posting of constraints upon bags (un-ordered collections possibly with duplicate elements). This very impoverished concurrent constraint language is a syntactic subset of Janus, a concurrent constraint language which closely resembles concurrent logic programming languages such as Guarded Horn Clauses [21], Strand [5], Parlog [2] and Flat Concurrent Prolog [13]. By identifying the subset of Janus which is an actor language, we elucidate the relationship between actors and concurrent logic programming (and its generalization as concurrent constraint programming). Lucy is best not thought of as a unification of logic and constraint programming with actor and object-oriented programming, but as the missing link between these programming language genera.

Abstract: A collection of original, never-before-published case studies on object-oriented programming languages and their applications, which include practical applications for popular OOP languages such as C++, Smalltalk, Objective-C, and Object Pascal.