Abstract Data Types Research Articles

From static to dynamic abstract data-types: an institution transformation

We show how to extend in a canonical way a given formalism for specifying (static) data types (like usual algebraic specification frameworks) with dynamic features. What we obtain in this way is a corresponding formalism for specifying dynamic data-types based on the “state-as-algebra” approach: a dynamic data-type models a dynamically evolving system in which any state can be viewed as a static data type in the underlying formalism, and the dynamic evolution is given by operations handling configurations. Formally, our construction is a functor between two appropriate categories of (specialized) institutions.

A Relation Between Unambiguous Regular Expressions and Abstract Data Types

Using a categorical model of abstract data types [2, 3, 13, 15], we show, following the Kozen's technique [10] and Tarjan's constructions for a deterministic automaton [16], that if two unambiguous regular expressions define the same regular language, then they represent two isomorphic abstract data types.

A metric-based approach to detect abstract data types and state encapsulations

This article presents an approach to identify abstract data types (ADT) and abstract state encapsulations (ASE, also called abstract objects) in source code. This approach groups together functions, types, and variables into ADT and ASE candidates according to the proportion of features they share. The set of features considered includes the context of these elements, the relationships to their environment, and informal information. A prototype tool has been implemented to support this approach. It has been applied to three C systems (each between 30-38 Kloc). The ADTs and ASEs identified by the approach are compared to those identified by software engineers who did not know the proposed approach. In a case study, this approach has been shown to identify, in most cases, more ADTs and ASEs than five published techniques applied on the same systems. This is important when trying to identify as many ADTs and ASEs as possible.

Abstract data types as a project development organiser

Abstract Data Types (ADTs) has been introduced recently to Israeli high-school students as tools for problem solving and knowledge representation in Prolog environment. This paper reviews a research that was conducted in order to assess the influence of students' use of ADTs on the development process of knowledge-based Prolog programs.

Enhanced abstract data types in object-relational databases

The explosion in complex multimedia content makes it crucial for database systems to support such data efficiently. This paper argues that the “blackbox” ADTs used in current object-relational systems inhibit their performance, thereby limiting their use in emerging applications. Instead, the next generation of object-relational database systems should be based on enhanced abstract data type (E-ADT) technology. An (E-ADT) can expose the semantics of its methods to the database system, thereby permitting advanced query optimizations. Fundamental architectural changes are required to build a database system with E-ADTs; the added functionality should not compromise the modularity of data types and the extensibility of the type system. The implementation issues have been explored through the development of E-ADTs in Predator. Initial performance results demonstrate an order of magnitude in performance improvements.

Testing Algebraic Data Types and Processes: A Unifying Theory

Abstract. There is now a lot of interest in program testing based on formal specifications. However, most the works in this area focus on one formalized aspect of the software under test. For instance, some previous works of the first author consider abstract data type specifications. Other works are based on behavioural descriptions, such as finite state machines or finite labelled transition systems. This paper begins by brie y recalling the principles of test data selection from algebraic data types specifications. Then, it transposes them to basic and full LOTOS. Finally it exploits this uniform framework and suggests a new integrated approach to test derivation from full LOTOS specifications, where both behavioural properties and data types properties are taken into account when dealing with processes.

Formal specification of CSCW applications with concurrent abstract data types

This paper proposes a new formal method for specification of distributed applications. The method is based on enhancement and combination of abstract data types and temporal logic. Besides preserving the ability to formally specify structure and general properties of distributed systems, the method allows to express Computer Supported Cooperative Work (CSCW) aspects. We suggest its use for specification of CSCW applications, particularly for specification of multi-user interfaces. Its definition and use is presented in detail by an example of a multi-user interface for a distributed group editor.

Software agents and intelligent object fusion

Techniques for modular software design are presented applying software agents. The conceptual designs are domain independent and make use of specific domain aspects applying Multiagent AI. The stages of conceptualization, design and implementation are defined by new techniques coordinated by objects. Software systems are designed by knowledge acquisition, specification, and multiagent implementations. Multiagent implementations are defined for the modular designs, applying our recent projects which have lead to fault tolerant AI systems. A novel multi-kernel design technique is presented.Communicating pairs of kernels, each defining a part of the system, are specified by object-coobject super-modules. Treating objects as abstract data types and a two level programming approach to OOP allows us to define Pull-up abstractions to treat incompatible objects. Keywords Abstract Objects, Intelligent syntax, MJOOP, Multi Agent Object Level Programming, Multi Kernel Design With OOP, Software Agents, Intelligent Objects. Academic UCSB when at University

On the practical need for abstraction relations to verify abstract data type representations

The typical correspondence between a concrete representation and an abstract conceptual value of an abstract data type (ADT) variable (object) is a many-to-one function. For example, many different pointer aggregates give rise to exactly the same binary tree. The theoretical possibility that this correspondence generally should be relational has long been recognized. By using a nontrivial ADT for handling an optimization problem, the authors show why the need for generalizing from functions to relations arises naturally in practice. Making this generalization is among the steps essential for enhancing the practical applicability of formal reasoning methods to industrial-strength software systems.

Transition Specifications for Dynamic Abstract Data Types

Transition specifications extend algebraic specifications by a notion of states and state transitions, introducing a second dynamic layer on abstract data types. This makes possible a reduction of complex specifications by the introduction of an explicit system state, a formal comparison of algebraic specifications and imperative algorithms, and the specification of input/output and other communication features. States are modelled as partial algebras that extend a given algebra by an environment, that is, a partial function that assigns contents to references. State transitions are specified by conditional parallel assignments, analoguous to the conditional existence equations of partial equational specifications. A framework of transition specifications is developed, including initial model semantics, parameterization and general composition mechanisms, and a notion of model correctness. Examples from programming languages show the applicability of the approach.

Implementation of abstract data types with arrays of unbounded dimensions

Implementation of abstract data types with arrays of unbounded dimensions

Tool support for planning the restructuring of data abstractions in large systems

Restructuring software to improve its design can lower software maintenance costs. One problem in carrying out such a restructuring is planning the new detailed design. The star diagram manipulable visualization can help a programmer redesign a program based on abstract data types. However, our measurements revealed that the view can be too large for a programmer to effectively assimilate. Also, design plans can be expressed only by restructuring, although our studies revealed that it is beneficial to preplan a restructuring. Finally, the tool user can build a star diagram for only a single data structure, although an abstract data type might actually have several components or have multiple instantiations.Exploiting basic properties of the star diagram can mitigate these problems. First, programmer-controlled elision can remove clutter from the star diagram view. Second, elision and annotation of star diagram components can mimic restructuring, thereby supporting the planning of a restructuring. Such support also allows for the planning of a non-restructuring maintenance task. Finally, to dynamically control what data structures are visualized, the tool user can union star diagrams.We built a star diagram planning tool for C programs, measured its elision capabilities, and performed a programmer study for the encapsulation of a widely-used data structure in a 28,000 line program. We found that the amount of elision can be substantial, but is not always adequate. In the study we found that each programming team successfully planned their restructuring in rather different, unanticipated ways.

The formal specification of abstract data types and their implementation in Fortran 90: implementation issues concerning the use of pointers

In this paper we continue our investigation into the development of computational-science software based on the identification and formal specification of Abstract Data Types (ADTs) and their implementation in Fortran 90. In particular, we consider the consequences of using pointers when implementing a formally specified ADT in Fortran 90. Our aim is to highlight the resulting conflict between the goal of information hiding, which is central to the ADT methodology, and the space efficiency of the implementation. We show that the issue of storage recovery cannot be avoided by the ADT user, and present a range of implementations of a simple ADT to illustrate various approaches towards satisfactory storage management. Finally, we propose a set of guidelines for implementing ADTs using pointers in Fortran 90. These guidelines offer a way gracefully to provide disposal operations in Fortran 90. Such an approach is desirable since Fortran 90 does not provide automatic garbage collection which is offered by many object-oriented languages including Eiffel, Java, Smalltalk, and Simula.

Computation on abstract data types. The extensional approach, with an application to streams

In this paper we specialize the notion of abstract computational procedure previously introduced for intensionally presented structures to those which are extensionally given. This is provided by a form of generalized recursion theory which uses schemata for explicit definition, conditional definition and least fixed point (LFP) recursion in functional of type level ⩽ 2 over any appropriate structure. It is applied here to the case of potentially infinite (and more general partial) streams as an abstract data type.

Abstract data types in Fortran 90

Progress in programming languages has been marked by successive waves of new techniques, each accompanied by miraculous claims from its proponents. Only after a certain time lag do these techniques become standardized. The functionality required to support one of these techniques, abstract data types (ADTs), is now part of the latest Fortran standard, but the newest wave is object orientation (OO). This paper describes the implementation of ADTs in Fortran and speculates on whether the language will withstand the OO onslaught.

A new look at pattern matching in abstract data types

In this paper we present a construction smoothly integrating pattern matching with abstract data types. We review some previous proposals [19, 23, 20, 6, 1] and their drawbacks, and show how our proposal can solve them. In particular we pay attention to equational reasoning about programs containing this new facility. We also give its formal syntax and semantics, as well as some guidelines in order to compile the construction efficiently.

Algebraic implementation of abstract data types: a survey of concepts and new compositionality results

In this paper we try to shed some light on the similarities and differences in the different approaches denning the notions of implementation and implementation correctness. For obvious reasons, we do not discuss all existing approaches individually. Instead, a formal framework is introduced in order to discuss the most important ones. Additionally, we discuss some issues, which in our opinion are often misunderstood, concerning transitivity of implementation correctness and its role in the software development process. In particular, on the one hand, we show that for reasonable notions of implementation, it is almost impossible to prove transitivity of implementation correctness at the specification level. On the other hand, we show that this is not really important if the programming language satisfies the properties of horizontal and vertical composition.

A methodology for a unified ADT course

"From an instructor's perspective (and also from the student's perspective) a course is rarely satisfying unless there is some 'big idea' that seems to hold the disparate elements together." [3,Pg.78]. This big idea is often lacking in a traditional introductory abstract data type (ADT) course, as students frequently perceive it to be a study of disjoint topics - a collection of ADTs. This paper proposes a context, indeed a methodology, for providing a unifying view of the topics and their significance, while suggesting an emphasis on the abstract nature, and design , of ADT's. Simultaneously, it supports a set of broad themes and recurring concepts which offer a unifying perspective on the pair of courses CS1 and CS2, and which establish fundamental ideas and skills pervasive throughout further studies in computing science.

Integrative assignments for CS1 and CS2 through libraries of abstract data types

As a way to avoid quick student concentration on implementation and computer language issues we have elaborated an integrative set of programming assignments for CS1 and CS2 courses.Our strategy relies on a top-down methodology to develop programming skills and problem-solving capabilities through the use of libraries with high-level Abstract Data Types (ADT). In a first medium-size assignment the novice programmer experiences high-level modular programming, and at a later stage the student is addressed to lower-level programming and data structure concerns.Ada has been used as the programming language, mainly because of its built-in capabilities to use and define reusable libraries of ADTs.Results indicate that this arrangement of assignments successfully reinforces the learning of fundamental concepts such as program design, modularity, testing techniques and increases student satisfaction.

Chiron-1

The Chiron-1 user interface system demonstrates key techniques that enable a strict separation of an application from its user interface. These techniques include separating the control-flow aspects of the application and user interface: they are concurrent and may contain many threads. Chiron also separates windowing and look-and-feel issues from dialogue and abstract presentation decisions via mechanisms employing a client-server architecture. To separate application code from user interface code, user interface agents called artists are attached to instances of application abstract data types (ADTs). Operations on ADTs within the application implicitly trigger user interface activities within the artists. Multiple artists can be attached to ADTs, providing multiple views and alternative forms of access and manipulation by either a single user or by multiple users. Each artist and the application run in separate threads of control. Artists maintain the user interface by making remote calls to an abstract depiction hierarchy in the Chiron server, insulting the user interface code from the specifics of particular windowing systems and toolkits. The Chiron server and clients execute in separate processes. The client-server architecture also supports multilingual systems: mechanisms are demonstrated that support clients written in programming languages other than that of the server while nevertheless supporting object-oriented server concepts. The system has been used in several universities and research and development projects. It is available by anonymous ftp.