A light-weight UIMS

We built a limited but successful user interface management system named HYPE which supports rapid interactive creation and organization of user interfaces for a large class of applications. HYPE is targeted at applications for which the user interface is only loosely coupled to the application. Examples of this class of application are ‘command line-driven’ programs. Many applications in this class can be quickly given satisfactory direct-manipulation interfaces with little or no reprogramming of the application. The programmer need only be familiar with HYPE, and not with the particular windowing system upon which it sits.

• 1 The appearance of the interface is specified interactively through the direct manipulation of interface components.
• 2 The behaviour of the interface is programmed with an interpreted procedural language which can send and receive messages and invoke system services. In particular, it can execute applications.
• 3 The structure of the interface is a tree of potentially-visible objects which communicate with the user, the system, and each other through message passing. The tree structure facilitates grouping interfaces for related applications, or families of applications, into a single master interface.

Visual layout, tree-building, behaviour assignment (programming) and execution of the interface all occur within HYPE, a conjunction that makes it a powerful prototyping tool.     

Component-based tailorability: Enabling highly flexible software applications

Component technologies are perceived as an important means to keep software architectures flexible. Flexibility offered by component technologies typically addresses software developers at design time. However, the design of software which should support social systems, such as work groups or communities, also demands ‘use-time’, or technically spoken, ‘run-time’ flexibility. In this paper, we summarize a decade of research efforts on component-based approaches to flexibilize groupware applications at run-time. We address the user as a ‘casual programmer’ who develops and individualizes software for his work context. To deal with the challenges of run-time flexibility, we developed a design approach which covers three levels: software architecture, user interface, and collaboration support. With regard to the software architecture, a component model, called FlexiBeans, has been developed. The FreEvolve platform serves as an environment in which component-based applications can be tailored at run-time. Additionally, we have developed three different types of graphical user interfaces, enabling users to tailor their applications by recomposing components. To enable collaborative tailoring activities, we have integrated functions that allow sharing component structures among users. We also present different types of support techniques which are integrated into the user interface in order to enable users’ individual and collaborative tailoring activities. We conclude by elaborating on the notion of ‘software infrastructure’ which offers a holistic approach to support design activities of professional and non-professional programmers.     

A unix tool for managing reusable software components

Sloth is a simple Unix-based tool for creating and maintaining large C programs built from reusable ‘modules’. Sloth is a collection of UNIX shell commands for creating and editing modules, and for producing executables by linking compiled code from the modules comprising a program. Sloth in a sense extends C by providing module facilities similar to those built in to newer languages such as Modula-II. The Sloth ‘extensions’, however, are at the shell level only. No changes are required in C itself; in fact, the Sloth commands invoke the standard Unix C compiler. A Sloth module contains a set of C procedures and local declarations, a set of global definitions and variable declarations, an initialization routine and an ‘import’ list of other modules containing declarations referred to, but not defined by, the module in question. The Sloth link command has one argument, the name of a ‘root’ directory. The link command automatically identifies all those modules imported directly or indirectly by the root module, checks that the object code for each module is up-to-date and recompiles where necessary. It then creates a main program in which the various initialization routines are executed in the correct order (most primitive first), compiles it and links it with all the object files and produces an executable program. Individual modules can be compiled without any knowledge of the application that uses, directly or indirectly, the module in question. Two applications that both use a collection of modules can therefore share the object code for these modules. The use and implementation of Sloth are presented, as are the experience in using it, programming techniques developed to take full advantage of its facilities, as well as several extensions, either completed or planned.     

基于ActiveX技术的通用网络检测控件

使用ActiveX技术设计并实现了通用的网络数据包检测控件,利用该控件可以在各种编程环境下,根据用户需求捕获及处理网络底层数据包,为各种需要进行数据包获取的网络应用程序的开发提供了统一的接口,极大地方便了应用程序的开发人员。     

Extensions to the C programming language for enhanced fault detection

The acceptance of the C programming language by academia and industry is partially responsible for the ‘software crisis’. The simple, trusting semantics of C mask many common faults, such as range violations, which would be detected and reported at run-time by programs coded in a robust language such as Ada.

1 Ada is a registered trademark of the U.S. Government (Ada Joint Program Office)

This needlessly complicates the debugging of C programs. Although the assert macro lets programmers add run-time consistency checks to their programs, the number of instantiations of this macro needed to make a C program robust makes it highly unlikely that any programmer could correctly perform the task. We make some unobtrusive extensions to the C language which support the efficient detection of faults at run-time without reducing the readability of the source code. Examples of the extensions are automatic checking of error codes returned by library routines, constrained subtypes and detection of references to uninitialized and/or non-existent array elements.     

P/CL: A flexible input processor

An interactive program inevitably has a need for a user interface which exceeds the simple combination of a write and a read statement. This is necessary to prevent a program abort due to an input error from the side of the user. Also it is desirable to allow for more advanced types of input than single characters or numbers. For these reasons a general-purpose input package has been developed which allows for sophisticated command-driven programs while offering the programmer as well as the user an easy-to-use interface. The structure of the package is described and examples of its use are given.     

G-plot: graphics in the geological computer

G-PLOT is a package of programs for graphic display of data. It has been designed as an integral part of the G-EXEC data-handling system, and adopts the principles of G-EXEC: it is generalized with respect to data, it is structured and modular, and it has a simple (near-English) user interface. In addition, a number of standards have been defined to allow the greatest possible flexibility of usage of the programs, as well as to provide a consistent and powerful set of modules for the applications programmer. The two most significant of these standards are the use of the ‘plot-frame’ concept and the definition of logical raster levels between the data and a ‘logical plotter’. By the use of these standards, it is possible not only to send generated plots to any available graphic device, but also to edit plots by selection and manipulation of logical ‘subframes’—units of plot data such as axes, titling, map frames, and grids. By the combination of G-PLOT facilities with planned enhancements to the G-EXEC system, it will be possible to generate sequences of plot frames from iterative simulation models, or from successively changing parameters (scaling or rotation for example) in normal application programs.     

Visual programming support for graph‐oriented parallel/distributed processing

GOP is a graph‐oriented programming model which aims at providing high‐level abstractions for configuring and programming cooperative parallel processes. With GOP, the programmer can configure the logical structure of a parallel/distributed program by constructing a logical graph to represent the communication and synchronization between the local programs in a distributed processing environment. This paper describes a visual programming environment, called VisualGOP, for the design, coding, and execution of GOP programs. VisualGOP applies visual techniques to provide the programmer with automated and intelligent assistance throughout the program design and construction process. It provides a graphical interface with support for interactive graph drawing and editing, visual programming functions and automation facilities for program mapping and execution. VisualGOP is a generic programming environment independent of programming languages and platforms. GOP programs constructed under VisualGOP can run in heterogeneous parallel/distributed systems. Copyright © 2005 John Wiley & Sons, Ltd.     

A distributed programming assistant

This paper describes an interactive programming environment within which proposed changes to a program are monitored to ensure that they do not introduce various common types of logical inconsistency. The environment, which is provided by a network of concurrent ‘experts’ dealing with various aspects of the program being developed, is designed to be convenient to work in and to impose few constraints on the programmer.     

Kernel for a responsive and graphical user interface

A kernel that facilitates building graphical and responsive user interfaces for application programs has been constructed. A display tree representing the structure of the 2-dimen-sional screen image is defined. Each node contains an input procedure, an output procedure and links to their arguments. This display tree is the only interface between the user and the application program. For viewing purposes, the display tree can be ‘painted’ onto any viewport. The output routines attached to the nodes are invoked to produce the image. The arguments found in the ancestor nodes can be thought of as shared graphical attributes. Upon each input event, the display tree is traversed to determine which node is touched by the cursor. The input procedure attached to that node is then invoked. The use of a library with standard attached procedures (e.g. for screen editing and error checking) leads to a system that behaves uniformly across applications. Some demonstration programs, based on this kernel, show the very dynamic screen communication that can be achieved.     

The design of an interactive program development system for Pascal

A program language can be defined as the language in which computer programs are written, and a programming language as the language used by the programmer to create programs. This paper presents the design of an interactive program development system which uses Pascal as both program and programming language. Principal properties of the system are a complete immediate syntax check, a program-structure oriented editor, incremental compiling techniques, and interactive interpretation and debugging of programs. The syntax check is split into three phases, and the user can change the degree of check wanted. After a change of the program only part of it is recompiled, and only necessary phases of the compiling process are performed.     

Integrating program analyses with programmer productivity tools

Because software continues to grow in size and complexity, programmers increasingly rely on productivity tools to understand, debug, and modify their programs. These tools typically use program analyses to produce information for the programmer. This is problematic because it is based on the assumption that the programmer and program analyses all use the same vocabulary. If the programmer and analyses did not use the same vocabulary then the results of the analyses will be meaningless to the programmer. For example, ‘v124 may be NULL’ does not mean much to the programmer but ‘myStack may be NULL’ is meaningful. Often, the programmer and analyses prefer different vocabularies. While the programmer prefers his programs' source code, an analysis will prefer a simplified representation. Unfortunately, writing an analysis that works on the source code is difficult because the analysis must deal with the idiosyncracies of the source language (e.g. nested classes). In comparison, writing an analysis on SSA form is easy but the output of the analysis is not meaningful to the programmer; it must somehow be translated into something the programmer understands. We present a system, RTalk, that makes it easy to support both the programmers' and the analysis' needs. RTalk generates a translator between the programmers' and the analysis' vocabulary. Thus both the programmer and the analysis can use the vocabulary most natural to them. We demonstrate the effectiveness of RTalk by describing program understanding and program optimization tools that we have already built using RTalk. Copyright © 2011 John Wiley & Sons, Ltd.     

KBE—Pascal:基于知识的程序编辑

KBE-Pascal是一种交互式的程序设计助手系统,其意图是程序员完成设计和实现的困难部分,由KBE-Pascal尽可能地帮助他。 KBE-Pascal的主要基础是格局,这是一种表示程序的方法,它抽去了程序的非基本特性,且明显地表示出算法的基本逻辑特性。 KBE-Pascal的设计目标是通过引用格局库中的断片,快速正确地构造程序。它的目标语言是Pascal。目前该系统由四部分组成:编码程序,用以产生对应于格局的程序正文;一个通用算法片断格局库;格局编辑程序,使得程序能通过修改格局而达到修改程序的目的;正文     

Two approaches to on-line graphics systems

This article describes two types of software systems which provide an interface to users who wish to apply the power of interactive graphics to their specific problem. The systems are based on an 8K IMLAC PDS-1 minicomputer CRT display which provides sufficient processor power to handle display generation, management, and dynamic manipulation. The minicomputer software was first designed as an independent operating system which not only provides the user with high-speed timesharing access to the host computer, but also the resources of the local processor and its associated input/output devices. In this configuration, host compiled FORTRAN IV programs are loaded into the minicomputer through the timesharing link and executed independently from the host processor. A higher degree of processing is provided by the master-slave relationship between a local DEC PDP $\text{11}\text{40}$ minicomputer and the IMLAC. The user's FORTRAN IV program, executing in the PDP $\text{11}\text{40}$, directs an IMLAC graphics subsystem through subroutine calls. These systems provide the programmer with a foundation for a broad range of high level applications involving computer graphics.     

Interweaving knowledge extracting,organizing and evaluating: A concrete design for preventing logic and structure bugs while interviewing experts

The process of constructing expert systems (ESs), programs that approximate how domain experts solve problems in their specialized fields, is not at all as systematic, efficient, and verifiable as it should be. A reason is that no rigorous error-prevention interviewing method exists for structuring and testing ESs while building them. Often domain experts do implicitly ask of themselves analytical questions such as ‘Is that claim of mine always true?’ Another kind of expert — one specializing in logic analysis — explicitates, collects, and systematizes the fund of generic questions, such as ‘Are these sub-goals sufficient steps to the pre-established goal-category?’ There is a great need to make a method of interviewing, interlaced with testing and organizing, available to all domain experts and ES programmers via an interactive program. This program, which can generically be called a LAP (Logic Aids Program), plays the role of a domain-independent logic-assistant.     

Assisting comprehension of animation programs through interactive code visualization

Visual languages have been widely used to help people create animation programs. However, current programming environments lack features supporting efficient code exploration and program comprehension, particularly for understanding relationships among parts of animation programs. In this paper, we present novel interactive visualizations aimed at helping people to understand animation programs. We conducted an empirical study to evaluate the impact of these visualizations on programmer comprehension of the code, showing that our approach enabled programmers to comprehend more information with less effort and in less time. This result is potentially significant because it demonstrates an approach for helping users to explore and understand animation code. We anticipate that this approach could be applied in a wide variety of animation programming tools, which could ease common animation programming tasks that require understanding code.     

PELAS-program error-locating assistant system

Error localization in program debugging is the process of identifying program statements which cause incorrect behavior. A prototype of the error localization assistant system which guides a programmer during debugging of Pascal programs is described. The system is interactive: it queries the programmer for the correctness of the program behavior and uses answers to focus the programmer's attention on an erroneous part of the program (in particular, it can localize a faulty statement). The system differs from previous approaches in that it makes use of the knowledge of program structure, which is derived automatically. The knowledge of program structure is represented by the dependence network which is used by the error-locating reasoning mechanism to guide the construction, evaluation, and modification of hypothesis of possible causes of the error. Backtracking reasoning has been implemented in the reasoning mechanism     

POTLIB 2001: A potential energy surface library for chemical systems

POTLIB 2001 is a computer program library of global chemical potential energy surface (PES) functions (91 functions in version 1.0) along with test data, a suite of utility programs, and a convenient user interface. The PES programs are written in ANSI standard FORTRAN77 and can be used to determine the Born-Oppenheimer potential energy of chemical systems as a function of the internal coordinates. The accompanying test data allow users to verify local implementations of this library. Finally, the utility programs permit use of this library in conjunction with a variety of chemical dynamics and chemical kinetics computer codes. Interface routines are provided for the POLYRATE and ABCRATE program packages of Truhlar and co-workers, the VENUS96 program package of Hase and co-workers, and the VARIFLEX program package of Klippenstein and co-workers; the routines in this library can also be used in conjunction with the DYNASOL program package of Zhang and co-workers. This article describes the library and the utility programs and outlines the systematic conventions used for interfaces in the computer programs contained in the library. Adherence to these conventions will allow future PESs to be compatible with this library.     

Macros by example in a graphical UIMS

A macro facility that allows end users to extend interactive graphical applications is presented as part of a user-interface management system (UIMS). Such macros are expressed by example; that is, the end user programs the macro in the application's generated user interface. Problems with macros-by-example in graphical applications are explored, and requirements to accommodate such a facility are defined for the UIMS dialogue model. Existing UIMS models are reviewed relative to these requirements, and the unique facilities of the MIKE (menu interaction kontrol environment) semantics-based model are presented. The implementation of the macro-by-example system is discussed, as well as the particular implementation of a multicommand UNDO facility, which is necessary when editing micros by example