A Programming Environment Evaluation Methodology for Object-Oriented Systems

The object-oriented design strategy as both a problem decomposition and system development paradigm has made impressive inroads into the various areas of the computing sciences. Substantial development productivity improvements have been demonstrated in areas ranging from artificial intelligence to user interface design. However, there has been very little progress in the formal characterization of these productivity improvements and in the identification of the underlying cognitive mechanisms. The development and validation of models and metrics of this sort require large amounts of systematically-gathered structural and productivity data. There has, however, been a notable lack of systematically-gathered information on these development environments. A large part of this problem is attributable to the lack of a systematic programming environment evaluation methodology that is appropriate to the evaluation of object-oriented systems

An overview of very high level software design methods

Very High Level design methods emphasize automatic transfer of requirements to formal design specifications, and/or may concentrate on automatic transformation of formal design specifications that include some semantic information of the system into machine executable form. Very high level design methods range from general domain independent methods to approaches implementable for specific applications or domains. Applying AI techniques, abstract programming methods, domain heuristics, software engineering tools, library-based programming and other methods different approaches for higher level software design are being developed. Though one finds that a given approach does not always fall exactly in any specific class, this paper provides a classification for very high level design methods including examples for each class. These methods are analyzed and compared based on their basic approaches, strengths and feasibility for future expansion toward automatic development of software systems

Reusability in software engineering

This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included

Making navigation easier in object-oriented programming systems

It has been reported that non-expert users have difficulties in finding reusable software components in large object-oriented programming systems and there is a need for help tools. The research reported in this thesis addresses this issue. Described in this thesis is the design of a tool called BRRR, which aims to help non-expert users overcome such difficulties. It is developed for Smalltalk-80, the target system of this research.BRRR is a query tool with a browsing capacity. It allows users to find necessary components by query. Its design is based on the 'retrieval by reformulation' paradigm (Williams, 1984) which was originally used in the domain of information retrieval. This paradigm allows users to incrementally specify a query by reformulation. When users specify an initial query, BRRR presents the users with an example component which satisfies the query. The users can then construct further queries by using the information presented by the system. In this way, users who are not familiar with the system or who do not know exactly what they want can be guided towards the appropriate information.During this research, two versions of BRRR were developed: BRRRl and BRRR2. BRRRl was developed initially, based on the 'retrieval by reformulation' principle. After its implementation, a formative, empirical evaluation was conducted on it with a group of users. Based on the findings of the evaluation, BRRR2, an improved version of BRRR1 was developed. BRRR2 incorporates enhanced classification methods and explanation facilities. This new version of the tool was then evaluated empirically with a group of ten users.The empirical evaluation of BRRR2 showed encouraging results. It demonstrates that the 'retrieval by reformulation' approach used in this research could be used successfully in helping users find reusable software components in object-oriented programming systems

A Graphical Environment Supporting the Algebraic Specification of Abstract Data Types

Abstract Data Types (ADTs) are a powerful conceptual and practical device for building high-quality software because of the way they can describe objects whilst hiding the details of how they are represented within a computer. In order to implement ADTs correctly, it is first necessary to precisely describe their properties and behaviour, typically within a mathematical framework such as algebraic specification. These techniques are no longer merely research topics but are now tools used by software practitioners. Unfortunately, the high level of mathematical sophistication required to exploit these methods has made them unattractive to a large portion of their intended audience. This thesis investigates the use of computer graphics as a way of making the formal specification of ADTs more palatable. Computer graphics technology has recently been explored as a way of making computer programs more understandable by revealing aspects of their structure and run-time behaviour that are usually hidden in textual representations. These graphical techniques can also be used to create and edit programs. Although such visualisation techniques have been incorporated into tools supporting several phases of software development, a survey presented in this thesis of existing systems reveals that their application to supporting the formal specification of ADTs has so far been ignored. This thesis describes the development of a prototype tool (called VISAGE) for visualising and visually programming formally-specified ADTs. VISAGE uses a synchronised combination of textual and graphical views to illustrate the various facets of an ADT's structure and behaviour. The graphical views use both static and dynamic representations developed specifically for this domain. VISAGE's visual programming facility has powerful mechanisms for creating and manipulating entire structures (as well as their components) that make it at least comparable with textual methods. In recognition of the importance of examples as a way of illustrating abstract concepts, VISAGE provides a dedicated tool (called the PLAYPEN) that allows the creation of example data by the user. These data can then be transformed by the operations belonging to the ADT with the result shown by means of a dynamic, graphical display. An evaluation of VISAGE was conducted in order to detect any improvement in subjects' performance, confidence and understanding of ADT specifications. The subjects were asked to perform a set of simple specification tasks with some using VISAGE and the others using manual techniques to act as a control. An analysis of the results shows a distinct positive reaction from the VISAGE group that was completely absent in the control group thereby supporting the thesis that the algebraic specification of ADTs can be made more accessible and palatable though the use of computer graphic techniques

Interaction-aware development environments: recording, mining, and leveraging IDE interactions to analyze and support the development flow

Nowadays, software development is largely carried out using Integrated Development Environments, or IDEs. An IDE is a collection of tools and facilities to support the most diverse software engineering activities, such as writing code, debugging, and program understanding. The fact that they are integrated enables developers to find all the tools needed for the development in the same place. Each activity is composed of many basic events, such as clicking on a menu item in the IDE, opening a new user interface to browse the source code of a method, or adding a new statement in the body of a method. While working, developers generate thousands of these interactions, that we call fine-grained IDE interaction data. We believe this data is a valuable source of information that can be leveraged to enable better analyses and to offer novel support to developers. However, this data is largely neglected by modern IDEs. In this dissertation we propose the concept of "Interaction-Aware Development Environments": IDEs that collect, mine, and leverage the interactions of developers to support and simplify their workflow. We formulate our thesis as follows: Interaction-Aware Development Environments enable novel and in- depth analyses of the behavior of software developers and set the ground to provide developers with effective and actionable support for their activities inside the IDE. For example, by monitoring how developers navigate source code, the IDE could suggest the program entities that are potentially relevant for a particular task. Our research focuses on three main directions: 1. Modeling and Persisting Interaction Data. The first step to make IDEs aware of interaction data is to overcome its ephemeral nature. To do so we have to model this new source of data and to persist it, making it available for further use. 2. Interpreting Interaction Data. One of the biggest challenges of our research is making sense of the millions of interactions generated by developers. We propose several models to interpret this data, for example, by reconstructing high-level development activities from interaction histories or measure the navigation efficiency of developers. 3. Supporting Developers with Interaction Data. Novel IDEs can use the potential of interaction data to support software development. For example, they can identify the UI components that are potentially unnecessary for the future and suggest developers to close them, reducing the visual cluttering of the IDE

Making object-oriented databases more knowledgeable (From ADAM to ABEL)

Tesis leida en la Universidad de Aberdeen. 178 p.The salient points of this thesis are as follows: • Object-Oriented Databases can help in solving the impedance mismatch problem by introducing methods. However, methods have sometimes been overused in the sense th at the code encapsulated refers not only to how the operation is implemented but also to other kinds of knowledge that are implicit in the code. The disadvantages of this approach for modelling integrity constraints, user-defined relationships and active behaviour are pointed out. • The ADAM Object-Oriented Database has been extended to allow the designer to specify integrity constraints declaratively. A constraint equation approach is implemented th at supports the inheritance of constraints. • A need for semantic-rich user-defined relationships has been identified. In this thesis, relationships are represented as objects. An approach to enhance the semantics of relationships in both its structural and behavioural aspects is presented. The most novel idea of the approach presented is the support of the inferred properties and the operational semantics of relationships. • Active Databases have recently become an im portant area of research. This thesis shows how to extend an Object-Oriented Database with active capabilities. The principal contribution lies in representing as ‘first-class’ objects not only the active rules but also the rule manager itself. Hence, besides handling active rules as any other object in the system, future requirements can be supported just by specialising the current rule manager. • Active rules have been proposed for several purposes. Several examples, are given of the direct use of rules. However, higher level tools can be provided of which rule