A survey of systems programming languages: Concepts and facilities

In recent years, high-level programming languages have evolved specifically for systems programming. In this paper, systems programming languages are surveyed to find common characteristics and individual differences and limitations of a number of current languages, including Ada, Concurrent Pascal, CLU, Pascal-Plus, Modula-2, Mesa, Edison, PLZ/SYS and C. The survey is based on the following classification of systems programming concepts and facilities: types, sequential control, concurrency, encapsulation, environment specifications and programming support environments.     

A comparison of object-oriented programming in four modern languages

Object-oriented programming has become a widely used, important programming paradigm that is supported in many different languages. C++ has become the most widely used object-oriented language and many C++ programmers are unfamiliar with the different approaches taken by other languages in the paradigm. This paper is intended as an introduction to a broad range of ideas in object-oriented programming. Specifically, we introduce four modern programming languages that support object-oriented programming (Oberon-2, Modula-3, Sather and Self), and show how a simple application is coded in these languages. While each of these programming languages provide support for inheritance, dynamic dispatch, code reuse, and information hiding, they do so in very different ways and with varying levels of efficiency and simplicity. The use of a simple example, based on a common programming problem, facilitates our comparison. We have coded the application in all of these languages, including C++, and we compare the compile times, object code sizes, and run times of the available implementations. Implementations of all the languages compared and all of the programs we measure are available on the Internet. Ultimately, our goal is to encourage and facilitate programmers in understanding and exploring a variety of object-oriented programming languages.     

New mechanisms for invocation handling in concurrent programming languages

Invocation handling mechanism in many concurrent languages have significant limitations that make it difficult or costly to solve common programming situations encountered in program visualization, debugging, and scheduling scenarios. This paper discusses these limitations, introduces new language mechanisms aimed at remedying these limitations, and presents an implementation of the new mechanisms. The examples are given in SR; the new mechanisms and implementation are an extension of SR and its implementation. However, these new mechanisms are applicable to other concurrent languages. They can augment or replace current invocation handling mechanisms.     

S-semantics for logic programming: A retrospective look

The paper provides an overview of the s-semantic approach to the semantics of logic programs which had been developed about twenty years ago. The aim of such an approach was that of providing a suitable base for program analysis by means of a semantics which really captures the operational behavior of logic programs, and thus offers useful notions of observable program equivalences. The semantics is given in terms of extended interpretations, which are more expressive than Herbrand interpretations, extends the standard Herbrand semantics, and can be obtained as a result of both top-down and bottom-up constructions. The approach has been applied to several extensions of positive logic programs and used to develop semantic-based techniques for program analysis, verification and transformation.     

A new generic scheme for functional logic programming with constraints

In this paper we propose a new generic scheme CFLP풟, intended as a logical and semantic framework for lazy Constraint Functional Logic Programming over a parametrically given constraint domain 풟. As in the case of the well known CLP풟 scheme for Constraint Logic Programming, 풟 is assumed to provide domain specific data values and constraints. CFLP풟 programs are presented as sets of constrained rewrite rules that define the behavior of possibly higher order and/or non-deterministic lazy functions over 풟. As a main novelty w.r.t. previous related work, we present a Constraint Rewriting Logic CRWL풟 which provides a declarative semantics for CFLP풟 programs. This logic relies on a new formalization of constraint domains and program interpretations, which allows a flexible combination of domain specific data values and user defined data constructors, as well as a functional view of constraints. This research has been partially supported by the Spanish National Projects MELODIAS (TIC2002-01167), MERIT-FORMS (TIN2005-09207-C03-03) and PROMESAS-CAM (S-0505/TIC/0407).     

Concurrency in programming languages: A survey

This paper surveys concurrency issues of programming languages. The evolution of these issues is analyzed in the context of the evolution of other language concepts, such as data and control abstraction.Specific concurrency concepts discussed in the paper include: granularity of parallelism, degree of parallelism, synchronization and communication, and physical distribution. The review of the problems of synchronization and communication includes semaphores, messages and mailboxes, and monitors.Concurrency aspects of ADA are also presented as a case study of a state-of-the-art programming language.     

A comparison of programming languages for software engineering

Four programming languages (Fortran, Cobol, Jovial and the proposed DoD standard) are compared in the light of modern ideas of good software engineering practice. The comparison begins by identifying a core for each language that captures the essential properties of the language and the intent of the language designers. These core languages then serve as a basis for the discussion of the language philosophies and the impact of the language on gross program organization and on the use of individual statements.     

The definition of comments in programming languages

This paper examines the concept of comments in programming languages and answers the questions: Why are they needed? How are they defined and implemented in existing languages? What should be provided in future languages?     

Quantum programming languages: A tentative study

Starting with some simple representative quantum programming languages, this paper lays stress on quantum computation, language paradigm, program structure, input/output, exception facility, and especially the recent results of the quantum computation group at Nanjing University, namely the functional quantum programming language NDQFP. All primitive functions and combining forms in NDQFP are given in the appendix.     

Iconic languages: Towards end-user programming of mobile applications

After tracing the steps that led to the current generation of iconic languages starting from the original idea of S.K. Chang, we describe an iconic language, named MicroApp, for modeling pervasive mobile applications directly on the mobile device. MicroApp exploits generalized icons for composing mobile applications: services are represented by icons and are composed of adopting colors for representing data-flow. We also qualitatively evaluate the visual environment that implements this iconic language.     

Distributed programming languages: design and implementation

Considerable discussion has appeared in recent literature about ‘distributed programming’. One area of discussion concerns the design of programming languages which support distributed algorithms. This paper examines the important issues in programming language design for distributed computing, and presents an example of a language philosophy which supports program development for a distributed environment. It also discusses experiences with the STARMOD distributed programming language.     

Functional programming languages for verification tools: a comparison of Standard ML and Haskell

We compare Haskell with Standard ML as programming languages for verification tools based on our experience developing the verification platform Truth in Haskell and the Edinburgh Concurrency Workbench (CWB) in Standard ML. We review not only technical language features but also the worlds of the languages, for example, the availability of compilers, tools, and libraries. We also discuss the merits and difficulties of comparing programming languages in this wide sense and support our view that Truth and the CWB are similar enough to justify the conclusions drawn in this paper.     

LMNtal as a hierarchical logic programming language

LMNtal (pronounced “elemental”) is a simple language model based on hierarchical graph rewriting that uses logical variables to represent connectivity and membranes to represent hierarchy. LMNtal is an outcome of the attempt to unify constraint-based concurrency and Constraint Handling Rules (CHR), the two notable extensions to concurrent logic programming. LMNtal is intended to be a substrate language of various computational models, especially those addressing concurrency, mobility and multiset rewriting. Although the principal objective of LMNtal was to provide a unifying computational model, it is of interest to equip the formalism with a precise logical interpretation. In this paper, we show that it is possible to give LMNtal a simple logical interpretation based on intuitionistic linear logic and a flattening technique. This enables us to call LMNtal a hierarchical, concurrent linear logic language.     

Goals in conflict: semantic foundations of goals in agent programming

This paper addresses the notion of (declarative) goals as used in agent programming. Goals describe desirable states, and semantics of these goals in an agent programming context can be defined in various ways. We focus in this paper on the representation of conflicting goals. In particular, we define two semantics for goals, one for unconditional goals and one for conditional goals. The first is based on propositional logic, and the latter is based on default logic. We establish relations between and properties of these semantics. This title was inspired by the title of the PhD thesis of Harrenstein: Logic in conflict: logical explorations in strategic equilibrium [25].     

A model for the formal definition of programming languages

An operational model which allows the complete formal definition of the full syntax and, particularly, semantics of programming languages is described. Both its syntactic and semantic parts are based on so-called linked-forest manipulation systems which allow the definition of mappings on forests. The idea of “linking” is crucial for the given model, we represent not only abstract programs but also intermediate states of our system (abstract computer) by labelled forests with pointers.     

Iteration constructs in data-flow visual programming languages

Many visual programming languages (VPLs) rely on the data-flow paradigm, probably because of its simple and intuitive functioning mechanism. However, there are cases where more powerful programming constructs are needed to deal with complex problems. For example, iteration is undoubtedly an important aspect of programming, and should allow repetitive behaviors to be specified in compact and easy ways. Most existing data-flow VPLs provide special constructs to implement iterations, therefore infringing the pure data-flow paradigm in favor of program simplicity. This paper has three main purposes: (1) To provide a survey of the mechanisms used by some representative data-flow VPLs to carry out iterations; (2) To investigate, given a pure data-flow VPL, what should be the minimum set of characteristics which, after being added to the VPL, allow iterations to be implemented; and (3) To show real data-flow iteration implementations which rely on the characteristics pertaining to such a minimum set.     

Performance of an OR-parallel logic programming system

The research focus in parallel logic programming is shifting rapidly from theoretical considerations and simulation on uniprocessors to implementation on true multiprocessors. This report presents performance figures from such a system,Boplog, for OR-parallel Horn clause logic programs on the BBN Butterfly Parallel Processor. Boplog is designed expressly for a large scale shared memory multiprocessor with an Omega interconnect. The target machine and underlying execution model are described briefly. The primary focus of the paper is on detailed statistics taken from the execution of benchmark programs to assess the performance of the model and clarify the impact of design and architecture decisions. They show that while speedup of this implementation on highly OR-parallel problems is very good, overall performance is poor. Despite its speed drawback, many aspcts of the implementation and its performance can prove useful in designing future systems for similar machines. A binding model that prohibits constant time access to bindings, and the inability of the machine to support an ambitious use of machine memory appear to be most damaging factors.This work was carried out at the University of Utah, Salt Lake City, Utah. It was supported by a University of Utah Graduate Research Fellowship, the National Science Foundation under Grant DCR-856000, and by an unrestricted gift from L. M. Ericsson Telefon AB, Stockholm, Sweden, Production of the document was supported by the Rockwell International Science Center.     

Regulation management and logic programming

Regulations are pervasive in information systems. They manifest themselves as design rules, integrity constraints, deadlines, conventions, information disclosure requirements, policies, procedures, contracts, taxes, quotas and other statutes. Managing regulations is difficult. Regulations are complex, change frequently and rest on models of the real world that involve unusual vocabulary if not unusual concepts. Consequently, checking compliance with regulations is tedious and error-prone. Logic programming appears to provide a good framework for developing regulation management systems. Besides permitting arbitrary regulations to be modelled, it offers rapidity and ease of development, readability, incremental modifiability, extensibility and portability. These features are not provided by existing DP programming tools, database managers or conventional expert-system shells. This paper investigates the application of logic programming in a significant regulation management application: Workers' Compensation Insurance premium auditing. The insurance premium computation rules for the State of California were encoded as a large Prolog program. This application illustrates specific strengths and weaknesses of logic programming and Prolog in dealing with large-scale real-world regulations.