No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
The Trellis Programming Environment
Abstract
The Trellis programming environment supports programming in Trellis/Owl, an object-based language with multiple inheritance and compile-time type-checking. Trellis is composed of a number of integrated tools that share a common programming environment database. It is a highly interactive, easy-to-use programming environment, providing various programming aids, incremental compilation, and good debugging support. Trellis is both integrated and open-ended.
Trellis was specifically designed to support the object-oriented programming methodology. Thus it provides tools to manage the use of types and inheritance. Trellis takes advantage of the strong-typing features of the Trellis/Owl language to provide more support for the programmer by keeping track of cross-references and inconsistencies in code.
... In comparison to traditional source code analyzers and cross-reference tools, such as CIA [7], or the framework of Canfora and colleagues [5], FEAT does not rely on a program database. Rather, it uses the compiled representation (bytecode) of the program directly, and is thus more similar to browsers for languages such as Smalltalk [13], or Trellis [19]. FEAT is implemented in Java. ...
... [7], or the framework of Canfora and colleagues [5], FEAT does not rely on a program database. Rather, it uses the compiled representation (bytecode) of the program directly, and is thus more similar to browsers for languages such as Smalltalk [13] , or Trel- lis [19]. FEAT is implemented in Java. ...
... An example of such a strategy is the system of rules proposed by Gallagher and Lyle [12]. Source code browsers, such as provided in Smalltalk [13] or Trellis [19], and program databases, such as CIA [7] , enable a developer to access cross-reference information for source code elements , such as methods. The context for collecting the information by such tools is limited: it is not possible to accumulate the results of cross-referencing queries in a network of program elements. ...
Many maintenance tasks address concerns, or features, that are not well modularized in the source code comprising a system. Existing approaches available to help software developers locate and manage scattered concerns use a representation based on lines of source code, complicating the analysis of the concerns. In this paper, we introduce the concern graph representation that abstracts the implementation details of a concern and makes explicit the relationships between different parts of the concern. The abstraction used in a Concern Graph has been designed to allow an obvious and inexpensive mapping back to the corresponding source code. To investigate the practical tradeoffs related to this approach, we have built the feature exploration and analysis tool (FEAT) that allows a developer to manipulate a concern representation extracted from a Java system, and to analyze the relationships of that concern to the code base. We have used this tool to find and describe concerns related to software change tasks. We have performed case studies to evaluate the feasibility, usability, and scalability of the approach. Our results indicate that concern graphs can be used to document a concern for change, that developers unfamiliar with concern graphs can use them effectively, and that the underlying technology scales to industrial-sized programs.
... In particular, cross-referencing tools, such as code browsers and program databases, allow developers to perform queries that elicit the structural relations between different elements in a program. The main purpose of cross-referencing tools is to provide developers with information that cannot be obtained easily through source code inspection [5] [8] [14] [16] [22]. Currently, support for performing cross-reference queries is a standard feature of most modern software development environments, such as the Eclipse platform [15]. ...
... In particular, cross-referencing tools, such as code browsers and program databases, allow developers to perform queries that elicit the structural relations between different elements in a program. The main purpose of cross-referencing tools is to provide developers with information that cannot be obtained easily through source code inspection [5, 8, 14, 16, 22]. Currently, support for performing cross-reference queries is a standard feature of most modern software development environments, such as the Eclipse platform [15]. ...
Performing a software modification requires a developer to investigate a program to find and understand the code relevant to the modification task. Although standard pro-gram investigation tools can help developers in this activ-ity, developers often get lost in the complex web of infor-mation available about a program. To address this problem we propose to use program nav-igation analysis, a technique to record and analyze the ac-tions of a developer using a software development envi-ronment in order to infer the current task and the subset of a program relevant to this task. Our hypothesis is that we can use the results of program navigation analysis to dynamically configure the interface of a software develop-ment environment in a way that alleviates the problems of disorientation experienced by developers. In this paper, we define program navigation analysis and present an overview of its underpinnings, summarize our experience with the technique, highlight important techni-cal challenges, and discuss the benefits that can be reaped from use of the technique.
... In many ways, CIA appears to be an improved version of OMEGA re-implemented for C instead of Model and with its performance increased by concentrating on only the higher-level source-code constructs. Trellis [127] is a programming environment designed to support program development in the object-based programming language Trellis/Owl. All tools in the environment share a common database for storing information about programs including source-code, object code, type information and cross-reference listings. ...
... Various other systems have provided graphical object browsers with which OCB shares some similarities in display style, for example Smalltalk-80 [GR83], Trellis/OWL [OHK87] and Cedar [Tei84]. ...
These proceedings record the Second International Workshop on Persistence and Java, that was held in Half Moon Bay in the San Francisco Bay Area, in August 1997. The focus of the workshop series is the relationship between the Java platform and longterm storage, such as databases and orthogonal persistence. If future application programmers building large and longlived systems are to be well supported, it is essential that the lessons of existing research into language and persistence combinations are utilized, and that the research community develops further results needed for the Java platform. The initial idea for the workshop series came from Malcolm Atkinson who leads the Persistence and Distribution Research Group at Glasgow University, and who is a Visiting Professor at SunLabs. The workshop series is one of the fruits of the collaboration between the Forest group at SunLabs, led by Mick Jordan, and the Glasgow group.
... The idea of keeping an automatically updated list of things that remain to do dates back at least as far as the "grass catcher" of Trellis [8], and has been adopted in some form or other in many IDEs; the "Tasks" window of Eclipse is another example. However, such lists are typically a by-product of a global re-compilation, rather than being constructed modularly as the consequence of a change to a single method, as in Trellis and in our virtual categories. ...
Much of the elegance and power of Smalltalk comes from its programming environment and tools. First introduced more than 20 years ago, the Smalltalk browser enables programmers to “home in” on particular methods using a hierarchy of manually-defined classifications. By its nature, this classification scheme says a lot about the desired state of the code, but little about the actual state of the code as it is being developed. We have extended the Smalltalk browser with dynamically computed virtual categories that dramatically improve the browser's support for incremental programming. We illustrate these improvements by example, and describe the algorithms used to compute the virtual categories efficiently.
... There has thus been a progression of attempts to encompass ever more of the disparate entities that comprise a Persistent Application System (PAS) within a unified framework. Visual interaction with persistent data, such as that provided by generic object browsing systems [13][14][15][16][17][18][19], has proved to be a convenient and natural way for database users to address informal queries over the contents of a database. The users of such tools can browse freely around the data structures and values of a database, avoiding the necessity to write down algebraic expressions to perform the equivalent accesses. ...
The traditional representation of a program is as a linear sequence of text. At some stage in the execution sequence the source text is checked for type correctness and its translated form is linked to values in the environment. When this is performed early in the execution process, confidence in the correctness of the program is raised. During program execution, tools such as debuggers are used to inspect the running state of programs. Relating this state to the linear text is often problematical. We have developed a technique, hyperprogramming, that allows the representations of source programs to include direct links (hyper-links) to values, including code, that already exist in the environment. Hyperprogramming achieves our two objectives of being able to link earlier than before, at program composition time, and to represent sharing and thus closure and through this the run-time state of a program. This paper reviews our work on hyper-programming and proposes some current research areas.
... There are a wide variety of systems that address this problem, including: distributed file systems, the network time protocol, replicated databases, and the domain name system. Historically , distributed applications that have scaled to support large numbers of concurrent clients have taken measures to locate shared data in manageable, typically central locations and to employ redundancy and replication to survive component failures [1], [2], [3], [4], [5]. One feature that these systems have in common is that they do not work well in the face of network partitions. ...
The emergence of wireless ad hoc networking has opened the way for a new style of distributed computing. Ad hoc networks operate without infrastructure such as routers or access points. Software designed for this environment faces new challenges. In traditional networks, partitioning is typically treated as an exceptional and transient condition. The situation in ad hoc wireless networks is completely reversed. Each ad hoc group is an isolated network, partitioned from all other ad hoc networks. As computers move from one ad hoc group to another, the set of partitions changes. This paper presents the design and implementation of a data synchronization service intended specifically for ad hoc wireless networks. It describes the underlying factors affecting the design, the protocol used to achieve synchronization, and some performance measurements from the actual implementation.
... Trellis is a programming environment which supports programming in Trellis/Owl [12,6]. The Trellis browser provides access to source code. ...
Object-oriented methods allow programmers to construct software
with a simple and uniform structure. Object-oriented programs should be
simple to maintain and extend. Source code browsers are not sufficient
for understanding object-oriented programs. The authors have combined a
strongly-typed object-oriented language with an integrated, interactive
development environment. For several reasons, they designed the compiler
as an integral component of the environment. Coupling the compiler and
the browser simplifies symbol table management in the compiler.
Conversely, the same coupling ensures that information is semantically
checked before the browser displays it. Also, programmers do not have to
understand the class hierarchy because the compiler creates class views
... In most cases, eliciting this information is relatively well supported by static analysis based tools such as have been available for many years (e.g., see [27,70]). For other cases debugging tools, overview tools or data-flow techniques provide some support. ...
Little is known about the specific kinds of questions programmers ask when evolving a code base and how well existing tools support those questions. To better support the activity of programming, answers are needed to three broad research questions: (1) what does a programmer need to know about a code base when evolving a software system? (2) how does a programmer go about finding that information? and (3) how well do existing tools support programmer's in answering those questions? We undertook two qualitative studies of programmers performing change tasks to provide answers to these questions. In this paper, we report on an analysis of the data from these two user studies. This paper makes three key contributions. The first contribution is a catalog of 44 types of questions programmers ask during software evolution tasks. The second contribution is a description of the observed behavior around answering those questions. The third contribution is a description of how existing deployed and proposed tools do, and do not, support answering programmers' questions.
... To help developers discover and understand the parts of a program 1 that may be related to a change task, software development environments (SDEs) provide features enabling users to perform lexical and structural searches on the source code of a program [4], [12], [15], [20], [30]. As an early example, the Interlisp-D environment provided crossreferencing support [25]. ...
Prior to performing a software change task, developers must discover and understand the subset of the system relevant to the task. Since the behavior exhibited by individual developers when investigating a software system is influenced by intuition, experience, and skill, there is often significant variability in developer effectiveness. To understand the factors that contribute to effective program investigation behavior, we conducted a study of five developers performing a change task on a medium-size open source system. We isolated the factors related to effective program investigation behavior by performing a detailed qualitative analysis of the program investigation behavior of successful and unsuccessful developers. We report on these factors as a set of detailed observations, such as evidence of the phenomenon of inattention blindness by developers skimming source code. In general, our results support the intuitive notion that a methodical and structured approach to program investigation is the most effective.
... There has thus been a progression of attempts to encompass ever more of the disparate entities that comprise a Persistent Application System (PAS) within a unified framework. Visual interaction with persistent data, such as that provided by generic object browsing systems [13][14][15][16][17][18][19], has proved to be a convenient and natural way for database users to address informal queries over the contents of a database. The users of such tools can browse freely around the data structures and values of a database, avoiding the necessity to write down algebraic expressions to perform the equivalent accesses. ...
. The traditional representation of a program is as a linear sequence of text. At some stage in the execution sequence the source text is checked for type correctness and its translated form is linked to values in the environment. When this is performed early in the execution process, confidence in the correctness of the program is raised. During program execution, tools such as debuggers are used to inspect the running state of programs. Relating this state to the linear text is often problematical. We have developed a technique, hyperprogramming, that allows the representations of source programs to include direct links (hyper-links) to values, including code, that already exist in the environment. Hyper-programming achieves our two objectives of being able to link earlier than before, at program composition time, and to represent sharing and thus closure and through this the run-time state of a program. This paper reviews our work on hyper-programming and proposes some c...
... Existing programming environments offer rich sets of tools to assist the programmer in the various phases of software development. Some examples of such environments are Unix[RT78]; Turbo Pascal[Bor89]; Think C ™[BM89]; the Cornell Program Synthesizer[TR81]; Interlisp[TM84]; Cedar[Tei84]; PECAN[Rei84]; Trellis[OHK87]; Mesa[Swe85] and GANDALF ...
In an orthogonally persistent programming system, data is treated in a manner independent of its persistence. This gives simpler semantics, allows the programmer to ignore details of long-term data storage and enables type checking protection mechanisms to operate over the entire lifetime of the data. The ultimate goal of persistent programming language research is to reduce the costs of producing software. The work presented in this thesis seeks to improve programmer productivity in the following ways: . by reducing the amount of code that has to be written to construct an application; . by increasing the reliability of the code written; and . by improving the programmer's understanding of the persistent environment in which applications are constructed. Two programming techniques that may be used to pursue these goals in a persistent environment are type-safe linguistic reflection and hyper-programming. The first provides a mechanism by which the programmer can write generators ...
... These tools provide views of the problem-domain objects, each tool showing some aspect of objects in the system. Examples are the Smalltalk-80 [3] and Trellis [7] environments. Smalltalk-80 uses different tools for different activities: browsers show classes and the methods defined in classes, inspectors show the instance variables of objects. ...
This paper describes the approach we have taken with the design of the user interface for SELF. Detailed description of the language and implementation can be found in [1, 2, 6, 11]. Our prototype user interface for SELF provides browsing and inspecting of SELF objects by combining an object-based model with an artificial reality. Emphasizing the problem-domain objects rather than views of those objects discards a layer of indirection found in conventional window-based user interfaces. Placing those objects in an artificial reality reduces the cognitive load on the programmer, by exploiting the programmer's already internalized knowledge of how objects in the physical world behave. Our goal is to make the user interface invisible, and thus make SELF objects and the SELF world real. *This work has been generously supported by a National Science Foundation Graduate Fellowship and National Science Foundation Presidential Young Investigator Grant #CCR-8657631, and by Sun Microsystems, IBM, Apple Computer, Cray Laboratories, Tandem Computers, NCR, Texas Instruments, and DEC.
... Here a programmer would normally rely on three things: his personal expertise, software documentation, and browsing tools. Smalltalk, Trellis [29] and Cedar [37] are examples of programming environments that provide tools for browsing the available software base. The real difficulty is that human expertise cannot realistically cope with a large, evolving software base. ...
Theobject-S6+6fi9+ paradigm has gained popularity in various guises not only in programming languages, but in user interfaces, operating systems, databases, and other areas. We argue that the fundamentalobject-tal+79+ concept isencapsula- tion, and that allobject-+S590fi9 mechanisms and approaches exploit this idea to various ends. We introduce the mostimportant of these mechanisms as they are manifested in existingobject-+37(+S5 systems, and we discuss their relevance in the context of modern application development.
... Intrinsic to object-oriented languages are facilities for data hiding and protection, extensibility and code sharing through inheritance, and flexibility through runtime binding of operations to objects. However, existing object-oriented programming environments [5,9] rely on immediate-mode graphics, and object-oriented user interface packages [2,11] do not support general-purpose structured graphics. Ida [15] uses an object-oriented framework that decomposes structured graphics into a set of building blocks that communicate via message passing. ...
Structured graphics is useful for building applications that use a direct manipulation metaphor. Objectoriented languages offer inheritance, encapsulation, and runtime binding of operations to objects. Unfortunately, standard structured graphics packages do not use an object-oriented model, and object-oriented systems do not provide general-purpose structured graphics, relying instead on low-level graphics primitives. An object-oriented approach to structured graphics can give application programmers the benefits of both paradigms. We have implemented a two-dimensional structured graphics library in C++ that presents an object-oriented model to the programmer. The graphic class defines a general graphical object from which all others are derived. The picture subclass supports hierarchical composition of graphics. Programmers can define new graphical objects either statically by subclassing or dynamically by composing instances of existing classes. We have used both this library and an...
... Various other systems have provided graphical object browsers with which OCB shares some similarities in display style, for example Smalltalk-80 [GR83], Trellis/OWL [OHK87] and Cedar [Tei84]. ...
This paper describes an interactive browser used for exploring the structure of Java objects and their classes. It is implemented in Java and uses JDK 1.1 core reflection classes to discover details of the objects passed to it. The initial motivation for development arose from the need to browse persistent Java stores; the browser may also be useful as part of a symbolic debugging or visualisation tool. 1 Introduction The provision of orthogonal persistence for Java, e.g. [ADJ+96, DHF96, GN96, MCK+96], allows the programmer to create potentially large persistent stores of Java objects. There are a number of ways of discovering the contents of these stores, including interactive browsing, writing programs which navigate inter-object references, and the use of a query language. All of these, and others, will probably be required in practice. This paper describes a visualisation tool called OCB (Object/Class Browser) which addresses the first requirement, supporting the interactive ...
... This paper focuses on one particular advantage, that of referential integrity. Although other integrated programming environments have been developed 30,33,[37][38][39] , either they do not support referential integrity or it is not used to gain the benefits described here. ...
Data Store. In Proceedings of the 1st International Workshop on Persistent Object Systems, pp. 139-160, Appin, Scotland (1985). 10 hyper-code target configuration documentation link back to documentation links to related hyper-code links to components another version Figure 11. System documentation with links hyper-code and configuration information ensure that all are kept in lock-step and consistent with one another. This does not ensure that documentation is accurate, since that requires semantic interpretation, but does avoid the possibility of accidental loss while promoting documents to first class entities. 5. CONCLUSIONS The provision of orthogonal persistence in a programming language simplifies the programming task by abstracting over the lifetime and physical location of data. Most persistent language implementations support the concept of persistence within a standard operating system environment, by adding commands to compile, link and execute programs which are represen...
... Other languages such as Trellis [82,91], Eiffel [75] and Smalltalk-80 [45] were designed as object-oriented languages from the outset. Of these, Smalltalk-80 is the most celebrated and something of an object-oriented reference standard for terminology. ...
Simon Monk B.Sc. A Model for Schema Evolution in Object-Oriented Database Systems. Submitted for the degree of Ph.D. February 1993 The schema of a database is often considered to be static. However, in the life-time of a system, the schema is likely to be altered to accommodate changes in the requirements for data storage of the system. Such alterations may be the result of changes in the real world that the database is to model. For example, a database that is used to model the life of a chemical plant will need to evolve as the plant moves through the phases of design, commissioning, running and decommissioning. Each stage will have different data storage requirements. Changing the schema of a database has an impact on both the existing data and external agents that act on the database assuming a schema that may have been changed. Existing databases provide very little support for schema evolution. Object-oriented databases with their inherently flexible architectures are begining ...
Object-oriented programming has come forth as an important programming paradigm in the 1980's. As more and more people practice object-oriented programming, the subject of how to design and develop a system towards an object-oriented implementation becomes important. There is, therefore, a general demand for a design method which is specially developed for object-oriented programming. The theme of this thesis is to develop such a design method. The thesis starts off with a comprehensive background on object-oriented programming and how it differs from traditional programming. It also gives a detailed analysis of why existing design methods are inadequate for object-oriented programming. The thesis then presents the design method which has been developed in this research. The different stages of the design method and the various tasks that have to be performed at each stage are discussed thoroughly. The design method also embeds a design description language which allows system designers to communicate with each other during the design phase and this is also talked about in the thesis. Inheritance is regarded as an important feature found in object-oriented programming. A design method without substantial support for inheritance is considered to be incomplete. Therefore, a mechanism which is called the inheritance factorisation process is developed to assist system designers to construct class hierarchies in object-oriented programming. The mechanism has a formal model which ensures its correctness. The details of the formal model and the issues concerning how to use the mechanism forms a crucial part of this thesis. To examine the performance of the inheritance factorisation process, a factorisation engine is implemented and experiments have been carried out. To illustrate how the design method is used in system designs, two case studies have been carried out and are presented in this thesis. The result of this thesis is a design method which guides system designers to organise the design activities towards an object-oriented implementation. It also forms the basis of future work which will lead to a computer-aided software engineering environment for object-oriented programming.
Many maintenance tasks address concerns, or features, that are not well modularized in the source code comprising a system. Existing approaches available to help software developers locate and manage scattered concerns use a representation based on lines of source code, complicating the analysis of the concerns. In this paper, we introduce the concern graph representation that abstracts the implementation details of a concern and makes explicit the relationships between different parts of the concern. The abstraction used in a Concern Graph has been designed to allow an obvious and inexpensive mapping back to the corresponding source code. To investigate the practical tradeoffs related to this approach, we have built the feature exploration and analysis tool (FEAT) that allows a developer to manipulate a concern representation extracted from a Java system, and to analyze the relationships of that concern to the code base. We have used this tool to find and describe concerns related to software change tasks. We have performed case studies to evaluate the feasibility, usability, and scalability of the approach. Our results indicate that concern graphs can be used to document a concern for change, that developers unfamiliar with concern graphs can use them effectively, and that the underlying technology scales to industrial-sized programs.
This effort was to explore data and knowledge based processing systems with particular attention to: (1) Adequacy of the Information Resource Dictionary Systems (IRDS) to support advanced systems development projects: (2) Conceptual architecture for an Active Data/Knowledge Dictionary System; (3) Exploring in detail intelligent query formulation and processing in heterogeneous database systems; coordinated problem solving with multiple heterogeneous knowledge sources; schema evolution in object-oriented database; Hypermedia requirements for active dictionaries, and providing a better understanding of the role of metadata in the management of knowledge-intensive object-oriented applications.
For many applications, traditional data base models and technologies have proven inadequate, and this has led to research and development of database technologies based on the object-oriented paradigm. In this report, some of the recent research and development in object-oriented databases are surveyed. The core concepts that are being considered in developing a unified object-oriented data model are discussed, followed by some of the architectural issues involved in developing object-oriented database management systems. Technical summaries of two prototype object-oriented database products, GEMSTONE AND ORION, are given. Also, some of the exciting future research directions are highlighted. (kr)
This paper considers the application of an object-oriented perspective in developing software for structural engineering applications. A basic introduction to object-oriented programming is given followed by an overview of how issues of concurrency and persistence can be addressed and exploited within an object-oriented framework. A more in-depth presentation is then given of a structural analysis program being developed using an object-oriented approach, which provides a further illustration of the usefulness and potential of the object-oriented perspective.
This paper presents the user interface to programs and their execution in the Mjølner Programming Environment. The key idea
is to present the programming language abstractions, such as classes and procedures, as individual windows which the user
can interact with directly. This approach is used consistently to visualize both a program and its execution. The windows
are arranged hierarchically reflecting the static nesting of blocks. The window hierarchy gives powerful support for interaction
and navigation in a program. Incremental compilation techniques are used to make a high level of interaction and integration
possible.
DOWL is an extension of the Trellis language supporting distribution. It allows programmers to transparently invoke operations
on remote objects and to move objects between the nodes of a distributed system. A few primitives permit the programmer to
take full advantage of distribution and to tune performance; most notably by restricting the mobility of objects and specifying
which objects should move together. This paper describes the implementation of these extensions: the object format, communication
system and the mechanism to invoke operations on remote objects. Performance figures are also presented.
Object-orientation and computer graphics from a natural, if occasionally uneasy alliance. Tenets of object-orientation, such as data abstraction, instantiation, inheritance, and concurrency, also appear in the design and implementation of graphics design. We explore the relationship between object-orientation and computer graphics, and consider the structuring of various kinds of graphics systems in an object-oriented manner.
Rufus is an information system that models user data with objects
taken from a class system. Due to the importance of coping with changes
to the schema, Rufus has adopted the conformity-based model of Melampus.
This model enables Rufus to cope with schema changes more easily than
traditional class- and inheritance-based data models. The paper reviews
the Melampus data model and describes how it was implemented in the
Rufus system. The authors show how changes to the schema can be
accommodated with minimum disruption. They also review design decisions
that contributed to streamlined schema evolution and compare this
approach with those proposed in the literature
The work presented in this thesis seeks to improve programmer productivity in the following ways: - by reducing the amount of code that has to be written to construct an application; - by increasing the reliability of the code written; and - by improving the programmer's understanding of the persistent environment in which applications are constructed. Two programming techniques that may be used to pursue these goals in a persistent environment are type-safe linguistic reflection and hyper-programming. The first provides a mechanism by which the programmer can write generators that, when executed, produce new program representations. This allows the specification of programs that are highly generic yet depend in non-trivial ways on the types of the data on which they operate. Genericity promotes software reuse which in turn reduces the amount of new code that has to be written. Hyper-programming allows a source program to contain links to data items in the persistent store. This improves program reliability by allowing certain program checking to be performed earlier than is otherwise possible. It also reduces the amount of code written by permitting direct links to data in the place of textual descriptions. Both techniques contribute to the understanding of the persistent environment through supporting the implementation of store browsing tools and allowing source representations to be associated with all executable programs in the persistent store. This thesis describes in detail the structure of type-safe linguistic reflection and hyper-programming, their benefits in the persistent context, and a suite of programming tools that support reflective programming and hyper-programming. These tools may be used in conjunction to allow reflection over hyper-program representations. The implementation of the tools is described. Comment: PhD Thesis, University of St Andrews. Supervisor: R. Morrison. (1992)
We are concerned with the design of integrated families of data types as opposed to individual data types. We propose a system that provides an unlimited number of uncoupled specification hierarchies and illustrate it with three: a subtype hierarchy, a specialization/generalization hierarchy, and a like hierarchy. We also resurrect a relatively unknown Smalltalk design methodology that we call programming-by-exemplars and argue that it is an important addition to a designer's grab bag of techniques. The methodology is used to show that the subtype hierarchy must be decoupled from the inheritance hierarchy. We do so in the context of exemplar-based systems to show that they can already support the extensions required without modification and that they lead to a better separation between users and implementers, since classes and exemplars can be related in more flexible ways. We also suggest that class-based systems need the notion of private types if they are to surmount their current limitations.
Thesis (M. Sc.--Computer science)--University of Auckland.
Thesis (Ph. D.)--University of Lancaster, 1993.
The object-oriented (OO) programming paradigm for developing
software systems has become more mainstream in the past several years.
Existing research into the use of the OO paradigm is heavily biased
toward front-end problems: design, programming languages, and
development environments. Lost in this has been support for maintenance
of OO system, yet maintenance is 80% of the effort for successful
software systems. This paper focuses on software tools that support and
enhance the software maintenance effort for OO systems. As the industry
matures in its use of OO concepts, systems will move along a spectrum of
object-oriented-ness, from non-OO systems at one end to fully OO systems
at the other. Each end of the spectrum has different maintenance and
tools needs
It is explained how inheritance and dynamic binding make object-oriented programs difficult to maintain, and a concrete example of the problems that arise is given. It is shown that the difficulty lies in the fact that conventional tools are poorly suited for work with object-oriented languages, and it is argued that semantics-based tools are essential for effective maintenance of object-oriented programs. A system developed for working with C++ programs is described. It comprises a relational database system for information about programs and an interactive database interface integrated with a text editor. The authors describe the system architecture, detail the database relations, provide informal evidence on the system's effectiveness, and compare it to other research with similar goals
p>Object-oriented programming languages are excellent for expressing abstractions in many application domains. The object-oriented programming methodology allows real-world concepts to modelled in an easy and direct fashion and it supports refinement of concepts. However, many object-oriented languages and their implementations fall short in two areas: dynamic extensibility and reflection.
Dynamic extensibility is the ability to incorporate new classes into an application at runtime. Reflection makes it possible for a language to extend its own domain, e.g., to build type-orthogonal functionality. MetaBETA is an extension of the BETA language that supports dynamic extensibility and reflection. MetaBETA has a metalevel interface that provides access to the state of a running application and to the default implementation of language primities.
This report presents the model behind MetaBETA. In particular, we discuss the execution model of a MetaBETA program and how type- orthogonal abstractions can be built. This includes precentation of dynamic slots, a mechanism that makes is possible ectend objects at runtime. The other main area covered in this report is the implementation of MetaBETA. The central component of the architecture is a runtime system, which is viewed as a virtual machine whose baselevel interface implements the functionality needed by the programming language.</p
they create, debug, enhance, and maintain? That is the fundamental question I address in this thesis.
In this paper, I explain how inheritance and dynamic binding make object-oriented programs difficult to work on in a traditional development environment, and I give a concrete example of the problems that arise. I describe the importance of the problems, and I demonstrate that it's often undesirable to modify a system's design to avoid these problems. I show that the difficulty lies in the fact that conventional program development tools are poorly suited for work with object-oriented languages, and I outline how research in semantics-based programming environments can be applied to the development of tools that will provide the support object-oriented programming demands. Introduction Everyone is aware of the benefits of object-oriented programming. Among the most frequently touted are better data abstraction, improved modularity, greater maintainability, a higher degree of code reuse, and enhanced robustness in the face of changing requirements. By and large, these claims r...
Distributed Smalltalk: Inheritance and Reactiveness in Distributed Systems by John K. Bennett Chairperson of the Supervisory Committee: Professor Edward Lazowska Department of Computer Science Smalltalk is an object-oriented programming language and highly interactive uniformly object-structured programming environment, originally developed for the Xerox family of personal workstations. The Smalltalk programming environment supports a single user on a single processor in a single object address space. This thesis describes the design and implementation of Distributed Smalltalk. Distributed Smalltalk extends the Smalltalk system to support the interaction of many users on many machines. It provides communication and interaction among geographically remote Smalltalk users, direct access to remote objects, the ability to construct distributed applications in the Smalltalk environment, and a degree of object sharing among users. Applications of Distributed Smalltalk include mail systems, remote computation servers, remote file servers, and collaborative software development. The distributed aspects of the system are largely user transparent and preserve the reactive quality of Smalltalk objects. A system is reactive to the degree that objects in the system can be easily presented for inspection or modification. Smalltalk is highly reactive in that all objects in the system can be so presented. Inheritance is a fundamental property of Smalltalk that allows objects to acquire behavior from other objects. In designing Distributed Smalltalk, we found that the interaction of inheritance and reactiveness was a major source of difficulty and that this interaction had significant impact on the design of a distributed system. Neither inheritance or reactiveness scaled well fro...
This work investigates the application of formal methods to object-oriented programming. The desirable features of such a synthesis are defined, and the problems of achieving it --- such as aliasing --- are investigated. Some solutions are proposed. The work focuses on the design of `Fresco', which is a development environment for the construction of object-oriented software with formally-specified and proven components. Software is developed interactively (after the style of Smalltalk) together with proofs of conformance to specification. Specifications may be attached to abstract and concrete classes, and a strict notion of subtyping is used to achieve polymorphism. Generic types are also supported. Types are interpreted as sets of possible histories of objects. Software components are generated and transmitted in `capsules'. A capsule may contain specifications and/or implementations of new software, or modifications of existing software. A system is composed of a seque...
Issues in the design and selection of concurrent object-oriented languages are discussed and some general principles outlined. The bulk of this paper is an extensive (although far from complete) enumeration of concurrent object-oriented languages, past and present. Salient features are discussed and unusual or novel aspects of each language pointed out. An attempt is made to draw some general conclusions from work in this area in terms of the features provided by the languages and the hardware they are targetted on. 1 Motivation We are currently engaged in a project to exploit functional programming as a means of developing and maintaining parallel programmes. To date we have developed a number of hand-built applications in the area of computer vision [118, 88, 99] and have developed a prototype automatic parallelising compiler based on Standard ML [24]. We now wish to investigate the role of a higher-level abstraction mechanism in our methodology and would like to base our research i...
The concept of reusability is defined and a model is provided. The model is based on the fact that to reuse a software component, you first have to find it. A faceted scheme is described that is a partial solution to this classification and retrieval problem. The scheme assumes that the collections of reusable components are very large and growing and that there are large groups of similar components. The scheme proposes a component description format based on a standard vocabulary of terms, imposes a citation order for the facets, and provides a metric for conceptual distance between terms in each facet that helps select closely related components. A mechanism has been added to evaluate the similarity of items, helping the user to select the best. The integration of the faceted classification scheme, the conceptual distance model, and the evaluation mechanism into a prototype library system is discussed.
Trellis ObjectBased Environment: Language Tutorial. Digital Equipment Corporation technical report DEC-TR-373
- O Patrick
- Brien
Based Environment: Language Tutorial. Digital Equipment Corporation technical report
- O'brien. Trellis Patrick
- Object