Search

Interfaces -- the collection of procedures and data structures that define a library, a subsystem, a module -- are syntactically poor programming languages. They have state (defined both by the interface's data structures and internally), operations on this state (defined by the interface's procedures), and semantics associated with these operations! Given a way to incorporate interface semantics into compilation, interfaces can be compiled in the same manner as traditional languages such as ANSI C or FORTRAN. This paper makes two contributions. First, it proposes and explores the metaphor of interface compilation, and provides the beginnings of a programming methodology for exploiting it. Second, it presents MAGIK, a system built to support interface compilation. Using MAGIK, software developers can build optimizers and checkers for their interface languages, and have these extensions incorporated into compilation, with a corresponding gain in efficiency and safety. This organization contrasts with traditional compilation, which relegates programmers to the role of passive consumers, rather than active exploiters of a compilers transformational abilities. [ABSTRACT FROM AUTHOR]

This paper describes the application of an interactive theorem-proving assistant and specification support tool called mural in the specification and verification of a small VDM development. The paper's intention is to give a feel for how mural works and of mural's applicability as a tool in specifying and verifying software. [ABSTRACT FROM AUTHOR]

This paper examines the use of cluster analysis as a tool for system modularization. Several clustering techniques are discussed and used on two medium-size systems and a group of small projects. The small projects are presented because they provide examples (that will fit into a paper) of certain types of phenomena. Data bindings between the routines of the system provide the basis for the bindings. It appears that the clustering of data bindings provides a meaningful view of system modularization. [ABSTRACT FROM AUTHOR]

Programming languages have traditionally had more data types than database systems. The flexibility of abstract types could make a database system more useful in supporting application development. Abstract types allow users to think about and manipulate data in terms and structures that they are familiar with. This paper proposes that databases have a type system interface and describes a representation of a type system in terms of relations. The type system model supports a variety of programming language constructs, such as user-defined parameterized data types and user-defined generic operations. The efficiency of the type system is compared to the access time of the database system. [ABSTRACT FROM AUTHOR]

Formal grammatical description has not generally been applied in the human factors area, which traditionally draws on behavioral science for its methodology. This paper illustrates, by means of a detailed example, how formal grammatical description can be used as a predictive tool to compare alternative designs for ease of use and to identify design choices which could cause users to make mistakes. The paper describes the human interface for two versions of an interactive graphics system intended for use by nonprogrammers. It presents the "action languages" for the two versions, then shows how these user languages can be described in terms of a production rule notation. Particular emphasis is given, in the notation, to actions the user has to learn and remember (i.e., to "cognitive" factors). The paper then presents predictions about human performance based on the formal description, and exploratory results of testing some of the predictions. Since the predictions arc based on general properties of the formal description, the technique should also be applicable to other "action languages." [ABSTRACT FROM AUTHOR]

System testing of software applications with a graphical-user interface (GUI) front-end requires that sequences of GUI events, that sample the application’s input space, be generated and executed as test cases on the GUI. However, the context-sensitive behavior of the GUI of most of today’s non-trivial software applications makes it practically impossible to fully determine the software’s input space. Consequently, GUI testers—both automated and manual—working with undetermined input spaces are, in some sense, blindly navigating the GUI, unknowingly missing allowable event sequences, and failing to realize that the GUI implementation may allow the execution of some disallowed sequences. In this paper, we develop a new paradigm for GUI testing, one that we call Observe-Model-Exercise* (OME*) to tackle the challenges of testing context-sensitive GUIs with undetermined input spaces. Starting with an incomplete model of the GUI’s input space, a set of coverage elements to test, and test cases, OME* iteratively observes the existence of new events during execution of the test cases, expands the model of the GUI’s input space, computes new coverage elements, and obtains new test cases to exercise the new elements. Our experiment with 8 open-source software subjects, more than 500,000 test cases running for almost 1,100 machine-days, shows that OME* is able to expand the test space on average by 464.11 percent; it detected 34 faults that had never been detected before. [ABSTRACT FROM PUBLISHER]

Aspect Oriented Programming aims at addressing the problem of the crosscutting concerns, i.e., those functionalities that are scattered among several modules in a given system. Aspects can be defined to modularize such concerns. In this work, we focus on a specific kind of crosscutting concerns, the scattered implementation of methods declared by interfaces that do not belong to the principal decomposition. We call such interfaces aspectizable. All the aspectizable interfaces identified within a large number of classes from the Java Standard Library and from three Java applications have been automatically migrated to aspects. To assess the effects of the migration on the internal and external quality attributes of these systems, we collected a set of metrics and we conducted an empirical study, in which some maintenance tasks were executed on the two alternative versions (with and without aspects) of the same system. In this paper, we report the results of such a comparison. [ABSTRACT FROM AUTHOR]

The Möbius framework is an environment for supporting multiple modeling formalisms and solution techniques. Models expressed in formalisms that are compatible with the framework are translated into equivalent models using Möbius framework components. This translation preserves the structure of the models, allowing efficient solutions. The framework is implemented in the tool by a well-defined abstract functional interface. Models and solution techniques interact with one another through the use of the standard interface, allowing them to interact with Möbius framework components, not formalism components. This permits novel combinations of modeling techniques, and will be a catalyst for new research in modeling techniques. This paper describes our approach, focusing on the "atomic model." We describe the formal description of the Möbius components as well as their implementations in our software tool. [ABSTRACT FROM AUTHOR]

In order to develop a systematic approach for icon-oriented system design, two important issues must be addressed. First, there is a need to develop formal ways of talking about icons. Second, the notion of a visual language compiler, which is analogous th the compilers commonly employed for textual languages, should be explicated. In this paper, we attempt to address these issues, through the development of a theory of generalized icons and a visual language compiler. The SIL-ICON Compiler is a software system for the specification, interpretation, prototyping, and generation of icon-oriented systems. In this paper, the design of the SIL-ICON Compiler is described. An application example to design a text editor using the Heidelberg Icon Set is also presented in detail. [ABSTRACT FROM AUTHOR]

In this paper we deal with the performance of parallel computing in a network of Apollo workstations where the processes use the Remote Procedure Call (RPC) mechanism for communication. The speedup in such systems cannot be accurately estimated without taking into account the relatively large communication overheads. Moreover, it decreases by increasing parallelism when the latter exceeds some certain limit. The main aim of this work is to estimate the speedup and optimum degree of parallelism from the characteristics of applications. Hence the speedup can be maximized by the appropriate choice of the degree of parallelism, or the parallelization efforts can be economized when the estimated speedup reveals to be unsatisfactory. In order to estimate the speedup and determine the optimum degree of parallelism, first we characterize the parallelization and the communication overheads in the system considered. Then parallel applications are modeled and their execution times are expressed for the general case of nonidentical tasks and workstations. The general case study allows to take into account the structural constraints of the applications by permitting their partitioning into heterogenous tasks. A simple expression of the optimum degree of parallelism is obtained for identical tasks where the inherent constraints are neglected. The fact that the theoretical maximum speedup is bounded by half of the optimum degree of parallelism shows the importance of this measure. Our approach is valid for all systems which use RPC as a communication mechanism. [ABSTRACT FROM AUTHOR]

This paper discusses the Common APSE Interface Set (CAIS) and its relationship to issues in the development of environments. The CAIS concepts, and features are described, followed by a discussion of several ways in which the CAIS provides valuable capabilities for environment architectures and construction. [ABSTRACT FROM AUTHOR]

In the development of programs for novel applications, a series of design-implementation phases may be necessary in order to acquire a deeper understanding of the problem. This paper develops a feedback version development approach incorporating systematic knowledge integration techniques. Our experiences in applying these methods to various projects are also discussed. [ABSTRACT FROM AUTHOR]

Even though the number and variety of available configuration management systems has grown rapidly in the past few years, the need for new configuration management systems still remains. Driving this need are the emergence of situations requiring highly specialized solutions, the demand for management of artifacts other than traditional source code and the exploration of entirely new research questions in configuration management. Complicating the picture is the trend toward organizational structures that involve personnel working at physically separate sites. We have developed a testbed to support the rapid development of configuration management systems. The testbed separates configuration management repositories (i.e., the stores for versions of artifacts) from configuration management policies (i.e., the procedures, according to which the versions are manipulated) by providing a generic model of a distributed repository and an associated programmatic interface. Specific configuration management policies are programmed as unique extensions to the generic interface, while the underlying distributed repository is reused across different policies. In this paper, we describe the repository model and its interface and present our experience in using a prototype of the testbed, called NUCM, to implement a variety of configuration management systems. [ABSTRACT FROM AUTHOR]

The main goal of this work is to propose a method to evaluate user interfaces using task models and logs generated from a user test of an application: The method can be incorporated into an automatic tool which gives the designer information useful to evaluate and improve the user interface. These results include an analysis of the tasks which have been accomplished, those which failed and those never tried, user errors and their type, time-related information, task patterns among the accomplished tasks, and the available tasks from the current state of the user session. This information is also useful to an evaluator checking whether the specified usability goals have been accomplished. [ABSTRACT FROM AUTHOR]

While the benefits of modular software development are widely acknowledged, there is little agreement as to what constitutes a good module interface. Computational complexity techniques allow us to evaluate algorithm time and space costs but offer no guidance in the design of the interface to an implementation. Yet, interface design decisions often have a critical effect on the development and maintenance costs of large software systems. In this paper we present criteria that have led us to simple, elegant interfaces. These criteria have been developed and refined through repeated practical application. We present the criteria in detail and illustrate their use with concrete examples. [ABSTRACT FROM AUTHOR]

This paper presents a retrospective view of the Charlotte distributed operating system, a testbed for developing techniques and tools to solve computation-intensive problems with large-grain parallelism. The final version of Charlotte runs on the Crystal multicomputer, a collection of VAX-11/750 computers connected by a local-area network. The kernel/process interface is unique in its support for symmetric, bidirectional communication paths (called links), and synchronous nonblocking communication. Our experience indicates that the goals of simplicity and function are not easily achieved. Simplicity in particular has dimensions that conflict with one another. Although our design decisions produced a high-quality environment for research in distributed applications, they also led to unexpected implementation costs and required high-level language support. We learned several lessons from implementing Charlotte. Links have proven to be a useful abstraction, but our primitives do not seem to be at quite the right level of abstraction. Our implementation employed finite-state machines and a multitask kernel, both of which worked well. It also maintains absolute distributed information, which is more expensive than using hints. The development of high-level tools, particularly the Lynx distributed programming language, has simplified the use of kernel primitives and helps to manage concurrency at the process level. [ABSTRACT FROM AUTHOR]

Despite the importance of describing and analyzing the relationships among a software system's components, most languages and development environments do not provide suitable support for these activities. While Ada and the various existing Ada environments offer some assistance, the capabilities they offer are inadequate for use in truly large and complex software development projects. To address these shortcomings, we are developing the AdaPIC tool set, which we envision as an important component of an Ada software development environment. The AdaPIC tool set is one particular instantiation, specifically adapted for use with Ada, of the more general collection of language features and analysis capabilities that constitute the PlC approach to describing and analyzing relationships among software system components. This tool set is being tailored to support an incremental approach to the interface control aspects of the software development process. Following a discussion of the interface control and incremental development concepts, this paper describes the AdaPIC tool set, concentrating on its analysis tools and support for incremental development and demonstrating how it contributes to the technology for developing large Ada software systems. [ABSTRACT FROM AUTHOR]

RM is an experimental prototype that supports the use of distributed services by personal computers in a LAN. Using a service-request model, RM allows any PC on the LAN to offer and use services, which can be user-written or off-the-shelf applications. A user can start several activities that proceed concurrently and that use services offered by different machines. Program interfaces are provided for the development of distributed applications. Remote execution is supported within the service-request framework. The paper considers issues in resource sharing and discusses the choices that were made for RM. It provides an overview of RM concepts, design, and implementation, and reviews experience using the system. [ABSTRACT FROM AUTHOR]

Reuse and composition are increasingly advocated and put into practice in modern software engineering. However, the software entities that are to be reused to build an application, e.g., services, have seldom been developed to integrate and to cope with the application requirements. As a consequence, they present mismatch, which directly hampers their reusability and the possibility of composing them. Software Adaptation has become a hot topic as a nonintrusive solution to work mismatch out using corrective pieces named adaptors. However, adaptation is a complex issue, especially when behavioral interfaces, or conversations, are taken into account. In this paper, we present state-of-the-art techniques to generate adaptors given the description of reused entities' conversations and an abstract specification of the way mismatch can be solved. We use a process algebra to encode the adaptation problem, and propose on-the-fly exploration and reduction techniques to compute adaptor protocols. Our approach follows the model-driven engineering paradigm, applied to service-oriented computing as a representative field of composition-based software engineering. We take service description languages as inputs of the adaptation process and we implement adaptors as centralized service compositions, i.e., orchestrations. Our approach is completely tool supported. [ABSTRACT FROM AUTHOR]

Verification techniques that rely on state enumeration (such as model checking) face two important challenges: 1) state space explosion: exponential increase in the state space with the increasing number of components and 2) environment generation: modeling components that are either not available for analysis or that are outside the scope of the verification tool at hand. We propose a semiautomated approach for attacking these two problems. In our approach, interfaces for the components that are outside the scope of the current verification effort are specified using an interface specification language based on grammars. Specifically, an interface grammar for a component specifies the sequences of method invocations that are allowed by that component. Using interface grammars, one can specify nested call sequences that cannot be specified using interface specification formalisms that rely on finite state machines. Moreover, our interface grammars allow specification of semantic predicates and actions, which are Java code segments that can be used to express additional interface constraints. We have built an interface compiler that takes the interface grammar for a component as input and generates a stub for that component. The resulting stub is a table-driven parser. Invocation of a method within the component becomes the look-ahead symbol for the stub/parser. The stub/parser uses a parser stack, the look- ahead, and a parse table to guide the parsing. The semantic predicates and semantic actions that appear on the right-hand side of the production rules are executed when they appear at the top of the stack. The stub/parser generated from the interface grammar of a component can be used to replace that component during state space exploration, either to assuage the state space explosion or to provide an executable environment for the component that is being verified. We conducted a case study by writing an interface grammar for the Enterprise JavaBeans (EJB) persistence interface. Using our interface compiler, we automatically generated an EJB stub using the EJB interface grammar. We used the JPF model checker to check EJB clients using this automatically generated EJB stub. Our results show that EJB clients can be verified efficiently with JPF using our approach, whereas they cannot be verified with JPF directly since JPF cannot handle EJB components. [ABSTRACT FROM AUTHOR]

The trace assertion method is a formal state machine based method for specifying module interfaces. A module interface specification treats the module as a black-box, identifying all module's access programs (i.e., programs that can be invoked from outside of the module) and describing their externally visible effects. In the method, both the module states and the behaviors observed are fully described by traces built from access program invocations and their visible effects. A formal model for the trace assertion method is proposed. The concept of step-traces is introduced and applied. The stepwise refinement of trace assertion specifications is considered. The role of nondeterminism, normal and exceptional behavior, value functions, and multiobject modules are discussed. The relationship with algebraic specifications is analyzed. A tabular notation for writing trace specifications to ensure readability is adapted. [ABSTRACT FROM AUTHOR]

We propose a technique to help people organize and write complex specifications, exploiting the best features of several different specification languages. Z is supplemented, primarily with automata and grammars, to provide a rigorous and systematic mapping from input stimuli to convenient operations and arguments for the Z specification. Consistency analysis of the resulting specificaiton is based on the structural rules. The technique is illustrated by two examples, a graphical human-computer interface and a telecommunications system. [ABSTRACT FROM AUTHOR]

A major problem of software cost estimation is first obtaining an accurate size estimate of the software to be developed. A bottom-up approach to software size estimation is described, which first identifies factors affecting software size, thus obtaining size explanation equations, and then seeks suitable predictors based on those explanation factors which can be used for size estimation. The approach, or model, is bottom-up in that it sizes individual software components or modules first, and then obtains subsystem and system sizes by summing component sizes. Since components may have different purposes and characteristics—e.g., menu, computation, and reporting components—the model allows for the partitioning of system components into several different types, each component type having different size explanation and estimation equations. The approach is similar to function point analysis, which partitions components of business systems (transactions) into five types: inputs, outputs, inquiries, entities (or files), and external interfaces. The partitioning here, however, is not fixed, but depends on the particular software development technology. In this sense the approach can be regarded as a generalization of function point analysis. The model is applied to several different software systems, including both business applications and systems programs. [ABSTRACT FROM AUTHOR]

Recent programming languages have attempted to provide support for concurrency and for modular programming based on abstract interfaces. Building on our experience of adding monitors to CLU, a language oriented towards data abstraction, we explain how these two goals conflict. In particular we discuss the clash between conventional views on interface abstraction and the programming style required for avoiding monitor deadlock. We argue that the best compromise between these goals is a combination of a fine grain locking mechanism together with a method for explicitly defining concurrency properties for selected interfaces. [ABSTRACT FROM AUTHOR]

Users of a relational database must explicitly navigate between relations in order to establish a connection among a set of attributes spanning several relation schemes. While a universal scheme interface to a relational database provides users with automatic navigation, it usually imposes on the database a unique role assumption. This assumption requires every attribute name to represent a unique role in the database, so that connections among sets of attributes are unambiguous. A drawback to this requirement is that several attributes can represent the same underlying class of entities, but the relationship among these attributes is not captured in the database scheme. As the standard method for relating attributes uses natural joins, some semantically meaningful connections among attributes are lost. We take a step toward removing this drawback by explicitly storing role relationships between attributes. The connections lost due to the enforcement of the unique role assumption are recovered via equijoins based on these role relationships. We give conditions on such role connections to ensure that they are semantically consistent with other connections, and show how to extend PIQUE, an existing universal scheme interface, to use this role information. [ABSTRACT FROM AUTHOR]

Database management systems (DBMS's) today are usually built as subsystems on top of an operating system (OS). This design approach can lead to problems of unreliability and inefficient performance as well as forcing a duplication of functions between the DBMS and OS. A new design approach is proposed which eliminates much of this duplication by integrating the duplicated functions into independent subsystems used by both the DBMS and OS. Specifically, an I/O and file support subsystem and a security subsystem are defined. Both subsystems make use of a logical information model which models the stored information in secondary storage. The new database operating system organization and the logical information model are presented in detail. Design of the security subsystem is based on the access control model, and is extended with Boolean predicates to produce an access control model capable of enforcing content- dependent security policies. The access matrix is implemented using a combination of access lists and capabilities. Authorization models and multiple user processes are discussed in relation to the new system organization. The outline of a formal specification and proof of correctness of the security subsystem is also discussed. [ABSTRACT FROM AUTHOR]

A parallel program, Dijkstra's "on-the-fly" garbage collector, is proved correct using analysis along the lines suggested by Francez and Pnueli for cyclic programs. The method is briefly reviewed, and the proof is compared to another proof by D. Gries, based on a method by S. Owicki. The differences between the two approaches are discussed. [ABSTRACT FROM AUTHOR]