Abstract When graphics input/output capabilities are added to a programming language originally designed with a text stream input/output model, various design decisions affect the ease with which the graphics facilities are learned and used by applications programmers. In adding window system facilities to the Icon programming language, some design decisions were made very differently from the conventional wisdom, resulting in substantial benefits for programmers. In addition, some pre‐existing Icon language features have proved to be useful in graphics programming.

Nova is a simple technique for animating a data sequence whose elements include a primary numeric component and possibly one or more secondary dimensions. We use nova to visualize program behavior such as individual memory allocations, where the number of bytes in each allocation is a natural primary numeric dimension.

Abstract Execution monitors are widely used during software development for tasks that require an understanding of program behavior, such as debugging and profiling. The Icon programming language has been enhanced with a framework that supports execution monitoring. Under the enhanced translator and interpreter, neither source modification nor any special compiler command‐line option is required in order to monitor an Icon program. Execution monitors are written in the source language, instead of the implementation language. Performance, portability, and detailed access to the monitored program's state are achieved using a coroutine model and dynamic loading rather than the separate‐process model employed by many conventional monitoring systems.

Abstract Compiling code for the Icon programming language presents several challenges, particularly in dealing with types and goal‐directed expression evaluation. In order to produce optimized code, it is necessary for the compiler to know much more about operations than is necessary for the compilation of most programming languages. This paper describes the organization of the Icon compiler and the way it acquires and maintains information about operations. The Icon compiler generates C code, which makes it portable to a wide variety of platforms and also allows the use of existing C compilers for performing routine optimizations on the final code. A specially designed implementation language, which is a superset of C, is used for writing Icon's run‐time system. This language allows the inclusion of information about the abstract semantics of Icon operations and their type‐checking and conversion requirements. A translator converts code written in the run‐time language to C code to provide an object library for linking with the code produced by the Icon compiler. The translation process also automatically produces a database that contains the information the Icon compiler needs to generate and optimize code. This approach allows easy extension of Icon's computational repertoire, alternate computational extensions, and cross compilation.

As a consequence of the primary historical role of computers as a tool for numerical computation, most programming languages have minimal facilities for string manipulation. This paper discusses some of the language design and implementation issues involved in incorporating string scanning, analysis and synthesis facilities into a general-purpose programming language and describes how they have been introduced in the Icon programming language.

The facilities that a programming language provides effectively both specify and limit how programs in the language can be written. Programming languages with unusual facilities often lead to program formulations that would be difficult or unnatural in other programming languages. This paper describes the characteristics and use of such a facility: expressions that are capable of producing a sequence of results, not just a single result. Such expressions are called generators. Generators are described here in the context of the Icon programming language, in which they are a general feature, instead of being confined to specific data structures or particular contexts as they are in other programming languages. In Icon, generators arise naturally from computations in which there is more than one possible solution. Coupled with goal-directed evaluation, this leads to concise and natural formulations of many types of computation. In turn, control structures are needed for generators that have no counterpart in more conventional programming languages. Numerous examples of generators are given, together with some general paradigms for their use. From a more formal point of view, the capability of generators to produce results is characterized in terms of result sequences. Finally, the relationship between generators and logic programming is mentioned.

The implementation of the Icon programming language is more interesting and difficult than the implementation of many other programming languages because an expression in Icon can generate a sequence of results. The implementation therefore must support control backtracking in expression evaluation. There also are several novel control structures related to generators. Because expression evaluation is limited lexically, a full coroutine mechanism is not needed and expression evaluation can be handled in a stack-like fashion.The implementation of Icon consists of a virtual machine with a stack-based architecture and an interpreter that executes the virtual machine instructions. There have been several different interpreters for Icon's virtual machine. This paper describes a new approach in which the interpreter is called recursively whenever the context for expression evaluation changes. This recursive interpreter has the advantage of being conceptually clear and flexible without sacrificing efficiency.

Although most programming languages have facilities that allow programmers to define procedures that augment the repertoire of built-in functions, comparatively few programming languages have facilities for defining control operations. This is not surprising, since the number of different control operations that can be comfortably accommodated in most programming languages is relatively small. Expressions in Icon can generate a sequence of results. This adds a dimension to control operations that is lacking in most programming languages and makes programmer-defined control operations interesting and useful. This paper describes such a facility and gives a number of examples of its use, including the definition of argument evaluation regimes.

The Icon programming language has generators that are capable of producing sequences of results and a goal-directed evaluation mechanism that allows concise formulation of many kinds of computations. The evaluation of generators is restricted to their lexical site in a program, however. This paper describes co-expressions, an extension to Icon that allows generators to be used at any time or place in a program. Examples of co-expression usage are given and the relationship of co-expressions to coroutines is discussed.

Abstract Two features of the Icon programming language strongly influence its implementation: generators and goal‐directed evaluation. A generator is an expression that is capable of producing a sequence of results. In goal‐directed evaluation, the results of generators are produced automatically in an attempt to complete computations successfully. This paper describes the generated code and run‐time support for generators, goal‐directed evaluation, and related control structures.

The importance of the ability to measure the performance of programs written in high-level languages is well known. Performance measurement enables users to locate and correct program inefficiencies where automatic optimizations fail and provides a tool for understanding program behavior. This paper describes performance measurement facilities for the Icon programming language, and shows not only how these facilities provided insight into program behavior, but also how they were used to improve the implementation.

Abstract This paper describes a programming language, SIDL, in which various aspects of software installation can be modeled. SIDL supports hierarchical file systems, computers, and processes for executing programs to produce new programs and data. An example, illustrating the installation of Ratfor, and experience with the use of SIDL for describing the installation of a large software system are included.

of Expressions in IconExpressions in the Icon programming language may be conditional, possibly producing no result, or they may be generators, possibly producing a sequence of results.Generators, coupled with a goaldirected evaluation mechanism, provide a concise method for expressing many complex computations.This paper describes the evaluation of expressions in Icon and presents an Icon program that explicates the semantics of expression evaluation.This program also provides an executable "formalism" that can be used as a tool to design and test changes and additions to the language.

Icon is a new programming language that includes a goal-directed expression evaluation mechanism.This mechanism is based on generators--expressions that are capable of producing more than one value.If the value produced by a generator does not lead to a successful result, the generator is automatically activated for an alternate value.Generators form an integral part of Icon and can be used anywhere.In addition, they form the basis for the string scanning facility and subsume some of the control expressions found in other languages.Several examples are given.

This paper describes the properties and use of character sets and character mappings in the Icon programming language. Examples of programming techniques based on these features are given to illustrate paradigms for solving a variety of nonnumerical problems. Such solutions are characterised by efficiency and compact data representations.

Abstract The traditional use of abstract machine models is to provide a conceptual framework for software design and to aid portability and machine independence. Access to the abstract machine model from the higher‐level system on which it is based provides a powerful tool for software development. This paper describes a technique in which the higher‐level system is interfaced to the underlying abstract machine, thus allowing use of the higher‐level system to analyse and debug its own implementation. The application of this technique in the implementation of SL5 is given as an example. Experience with the use of the facility and a discussion of basic design considerations are included.

SNOBOL4 is best known for its string processing facilities, which are based on patterns as data objects. Despite the demonstrated success of patterns, there are many shortcomings associated with their use. The concept of patterns in SNOBOL4 is examined and problem areas are discussed. An alternative method for high-level string processing is described. This method, implemented in the programming language Icon, employs generators , which are capable of producing alternative values. Generators, coupled with a goal-driven method of expression evaluation, provide the string processing facilities of SNOBOL4 without the disadvantages associated with patterns. Comparisons between SNOBOL4 and Icon are included and the broader implications of the new approach are discussed.

Results of measuring the performance of the storage management subsystem in an implementation of SNOBOL4 are described. By instrumenting the storage management system, data concerning the size, lifetime, and use of storage blocks were collected. These data, like those obtained from conventional time measurement techniques, were used to locate program inefficiencies. In addition, these measurements uncovered some deficiencies in the storage management system, and provided the basis upon which to judge the heuristics used in the garbage collector.

SL5 is a programming language developed for experimental work in generalized pattern matching and high-level data structuring and access mechanisms. This paper describes the procedure mechanism and the conventions for the interpretation of identifiers in SL5. Procedure invocation in SL5 is decomposed into the separate source-language operations of context creation, argument binding and procedure activation, and allows SL5 procedures to be used as recursive functions or coroutines. This decomposition has led to rules for scoping and for the interpretation of identifiers that are different from those found in other programming languages. Several examples of SL5 procedures are given, including a scanner based on the coroutine model of pattern matching.

Abstract In programming systems based on abstract machine modelling concepts, the underlying structure of the abstract machine can be made available to the software implemented on it. The result is an unusual facility for diagnosis and exploration of software structure. Such a facility has been added to the macro implemention of SNOBOL4. This paper describes the nature of the facility, illustrates its use, and presents some results of using it for language implementation and development.

The preoccupation with structured programming is so great these days that it is difficult to find a paper in the current literature on programming that does not make at least a token reference to well-structured programming. While much benefit may be derived by focusing attention on good programming techniques, many of the principles of structured programming have been known and practiced for years. Unfortunately, the recent focus of attention has produced a substantial amount of verbiage of little value and in the resulting hubbub the fundamental ideas have often been obscured. It is therefore refreshing to find a book concerned with the basic issues of good programming that treats the subject as a matter of practice and style, not theory.

SNOBOL is a programming language for the manipulation of strings of symbols. A statement in the SNOBOL language consists of a rule that operates on symbolically named strings. The basic operations are string formation, pattern matching and replacement. Facilities for integer arithmetic, indirect referencing, and input-output are included. In the design of the language, emphasis has been placed on a format that is simple and intuitive. SNOBOL has been implemented for the IBM 7090.