Mkscan—An interactive scanner generator

Mkscan is a tool for generating and editing scanners. It has been designed with ease of use in mind. The tol is interactive and uses a full screen interface. No attempt is made to provide an all-purpose tool that can generate a recognizer for any regular language. Instead, mkscan has been tailored to suit the lexical structure of common programming languages and command languages. Using mkscan, a scanner for Pascal can be created in under ten minutes–including the time taken to type the list of keywords.     

型构兼容的继承及其语义

本文揭示了在面向对象程序设计语言中,若劲旅子类重定义其继承的分类方法以发迹这些方法的规约,并且采用类似于Ｓｍａｌｔａｌｋ－８０中的继承机制的语义,将导致封将与继承之间的一个新总是为此,本文提出了一种新的继承机制－型构兼容的继承,以代替传统的增量继承。型构兼容的继承是一种灵活的代码复用机制,并且能够充分支持封装。     

An agile approach to language modelling and development

We have developed novel techniques for component-based specification of programming languages. In our approach, the semantics of each fundamental programming construct is specified independently, using an inherently modular framework such that no reformulation is needed when constructs are combined. A language specification consists of an unrestricted context-free grammar for the syntax of programs, together with an analysis of each language construct in terms of fundamental constructs. An open-ended collection of fundamental constructs is currently being developed. When supported by appropriate tools, our techniques allow a more agile approach to the design, modelling, and implementation of programming and domain-specific languages. In particular, our approach encourages language designers to proceed incrementally, using prototype implementations generated from specifications to test tentative designs. The components of our specifications are independent and highly reusable, so initial language specifications can be rapidly produced, and can easily evolve in response to changing design decisions. In this paper, we outline our approach, and relate it to the practices and principles of agile modelling.     

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.     

Performance of multi-tasking and synchronization mechanisms in the programming language SR

High-level language primitives for concurrent programming exist in languages such as Ada and Modula-2. However, each of these languages provides only a single means for specifying multitasking and synchronization, essential in the implementation of concurrent systems. The SR language provides several mechanisms for specifying multi-tasking and synchronization, so it can be used to explore the performance of various communication techniques. This paper presents performance results for SR's multi-tasking and synchronization mechanisms and discusses the effects of the generated code, the run-time support and the hardware on these results. These results are compared with those for similar mechanisms in other languages, leading to some general conclusions about the performance of process communication primitives. These performance results can be used by programmers to make design choices that allow systems programs written in high-level languages to meet real-time performance specifications.     

Semantic feedback in the Higgens UIMS

Almost all applications using interactive graphics contain important structures and concepts which are deeper than the geometres used to display them to the user. One of the major tasks of the system implementer is to cause the user interface to reflect this deeper structure accurately so that it may be directly manipulated by the user. The authors describe a tool, the Higgens user interface management system (UIMS), which can automate much of this task for a wide class of systems using interactive graphics. It is able to generate graphical user interfaces automatically from a high-level interface specification. These specifications are primarily nonprocedural in nature. They describe how graphical images can be automatically derived and updated based on applications entities, and how graphical inputs can be translated back into terms which are appropriate to the application     

GNU Emacs as a dynamically extensible programming environment

GNU Emacs is usually used only as an extensible editor. However, the ability to integrate inferior processes into GNU Emacs makes it an attractive programming environment. Like Interlisp and Smalltalk-80, GNU Emacs can be extended dynamically by its user. Unlike these programming environments, it can be used easily as a programming environment for an arbitrary programming language, and not just for its extension language. This paper discusses the methods of extending GNU Emacs and how we have applied them in creating a programming environment for a high-level specification language called AGENT.     

Polaris: a system for query, analysis, and visualization ofmultidimensional relational databases

In the last several years, large multidimensional databases have become common in a variety of applications, such as data warehousing and scientific computing. Analysis and exploration tasks place significant demands on the interfaces to these databases. Because of the size of the data sets, dense graphical representations are more effective for exploration than spreadsheets and charts. Furthermore, because of the exploratory nature of the analysis, it must be possible for the analysts to change visualizations rapidly as they pursue a cycle involving first hypothesis and then experimentation. In this paper, we present Polaris, an interface for exploring large multidimensional databases that extends the well-known pivot table interface. The novel features of Polaris include an interface for constructing visual specifications of table-based graphical displays and the ability to generate a precise set of relational queries from the visual specifications. The visual specifications can be rapidly and incrementally developed, giving the analyst visual feedback as he constructs complex queries and visualizations     

Fast recognition of context-sensitive structures

This paper is concerned with an extension of context-free LL(k) grammars, called RLL(k) grammars. RLL(k) grammars are powerful enough to generate non-context-free languages. In particular context-sensitive constructs of programming languages can be formalized conveniently. RLL(k) grammars have the pleasant property that fast syntactical check procedures exist. An algorithm for syntactical analysis with linear average cost is developed in this paper. A worst case quadratic upper bound is derived.     

Impact on retail checkout ergonomics of scanner technology evolution and package design

The design of bar code scanners has steadily improved scanning performances over the past 20 years. Changes in scan patterns, improvements in decode algorithms, and design features of the hardware user interface have resulted in scanners that are ergonomically superior both in biomechanics and overall performance. This study reviewed scanner performance and technological developments, and compare these to changes in checkstand use and the mix of merchandise packages scanned. The results indicate that the impact of future innovations in scanner design to improve throughput and the accuracy of data captured will be minimal. The greatest challenge to improve overall checkout performance is for merchandise suppliers to consider the ergonomics of scanning merchandise based on package design and placement of the bar code.

Relevance to industry

This work shows the impact of scanner design on cashier productivity in the retail checkout environment. Improvements in the user interface of scanners and the scanner optical recognition logic has shown a dramatic impact on the total percentage of scanned items. Package design and bar code placement is the next area to enhance the ergonomics of scanning.     

EXSHOF: An artificial intelligence approach to high-order filter synthesis

A two-tier expert-system-based synthesis of high-order filters is developed. Expert-system techniques have been used for choosing a particular biquad structure and for selection of the high-order filter structure as well. The data inputs will be either filter specifications or transfer functions and the output will be a detailed filter circuit with all its element values. EXSHOF ( pert System based ynthesis of igh rder ilter) is totally menu-driven and highly interactive. It assumes little knowledge of computers or filters from the user. The complete package is implemented in Turbo PASCAL and Turbo PROLOG languages.     

Super TEX-SIM: Interactive textile design and simulation

This paper presents an interactive tool for designing and simulating textile images. It comprises a yarn editor, a textile editor and a texture mapper. These subsystems share a colour editor that can modify the colours of yarn and textile images interactively. We describe how yarn and textile images are generated, and how they are mapped to a target picture read from an image scanner. The user interface in the tool has many useful functions so that users can design textile images without knowledge of computer graphics and programming languages. Several examples of texture mapping are included.     

Data abstraction in Modula-2

Data abstraction is one of the most fundamental principles of software engineering. The increasing realization of this is reflected in the design of programming languages, from the tentative user-defined data types of Pascal through to the more extensive facilities provided today by languages such as Ada and Modula-2.This tutorial paper examines how the data abstraction facilities provided by Modula-2 can be used in a sophisticated application. We demonstrate that data abstraction facilitates the production of code which is highly modularized, is easy to write and easy to read. The application, garbage collection, is an important part of system software, and is particularly interesting because it highlights the conflict between efficiency and expressive power. We show the extent to which a functional style of programming can be utilized in solving a problem which is inherently concerned with ‘state’, and we also show how formal semantics can be provided for the abstract data types.     

A technique for subclassing and its implementation exploiting polymorphic procedures

Since the introduction of Smalltalk, the object-oriented approach towards the organization of data and programs has become popular. In this paper the possibilities of exploiting procedure-oriented languages to allow an object-oriented style of programming are analysed. Although the two approaches are apparently dissimilar, a family of procedure-oriented languages is described which allows a high degree of freedom in programming and does not appear to restrain the programmer within the procedure-oriented scheme. Popular languages of this family are ML and PS-Algol. For such languages, a technique is developed which enables an efficient implementation of object-oriented features, such as the subclassing form of inheritance provided by Smalltalk-80 and Simula.     

On regular tree languages and deterministic pushdown automata

The theory of formal string languages and of formal tree languages are both important parts of the theory of formal languages. Regular tree languages are recognized by finite tree automata. Trees in their postfix notation can be seen as strings. This paper presents a simple transformation from any given (bottom-up) finite tree automaton recognizing a regular tree language to a deterministic pushdown automaton accepting the same tree language in postfix notation. The resulting deterministic pushdown automaton can be implemented easily by an existing parser generator because it is constructed for an LR(0) grammar, and its size directly corresponds to the size of the deterministic finite tree automaton. The class of regular tree languages in postfix notation is a proper subclass of deterministic context-free string languages. Moreover, the class of tree languages which are in their postfix notation deterministic context-free string languages is a proper superclass of the class of regular tree languages.