1,364 research outputs found
Implementing a window system for an all points addressable display
Thesis (B.S.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1982.MICROFICHE COPY AVAILABLE IN ARCHIVES AND ENGINEERINGBibliography: leaves 52-53.by John Cambell Gonzalez.B.S
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
Object Oriented Terrain Databases For Visual Simulators
Report on a project to develop methodologies and solutions to the problem of representation and utilization of dynamic terrain on a real-time simulator
Object Swapping Challenges: an Evaluation of ImageSegment
International audienceIn object-oriented systems, runtime memory is composed of an object graph in which objects refer to other objects. This graph of objects evolves while the system is running. Graph exporting and swapping are two important object graph operations. Exporting refers to copying the graph to some other memory so that it can be loaded by another system. Swapping refers to moving the graph to a secondary memory (for example, a hard disk) to temporary release part of the primary memory (for example, RAM). Exporting and swapping are achieved in different ways and the speed in presence of large object graphs is critical. Nevertheless, most of the existing solutions do not address well this issue. Another challenge is to deal with common situations where objects outside the exported/swapped graph point to objects inside the graph. To correctly load back an exported subgraph, it is necessary to compute and export extra information that is not explicit in the object subgraph. This extra information is needed because certain objects may require to be reinitialized or recreated, to run specific code before or after the loading, to be updated to a new class definition, etc. In this paper, we present all general problems to our knowledge about object exporting and swapping. As a case of study, we present an analysis of ImageSegment, a fast solution to export and swap object graphs, developed by Dan Ingalls. ImageSegment addresses the speed problems in an efficient way, as shown by the results of several benchmarks we have conducted using Pharo Smalltalk. However, ImageSegment is not a panacea since it still has other problems that hampers its general use
Experiments with a Fast Object Swapper
International audienceIn object-oriented systems, runtime memory is composed of an object graph in which objects refer to other objects. This graph of objects evolves while the system is running. Graph exporting and swapping are two important object graph operations. Exporting refers to copying the graph to some other memory so that it can be loaded by another system. Swapping refers to moving the graph to a secondary memory (e.g., a hard disk) to temporary release part of the primary memory. While exporting and swapping are achieved in different ways, each of them faces a common and central problem which is the speed of the approach in presence of large object graphs. Nevertheless, most of the existing solutions do not address well this issue. Another challenge is to deal with extremely common situations where objects outside the exported/swapped graph point to objects inside the graph. To correctly load back an exported subgraph, it is necessary to compute and export extra information that is not explicit in the object subgraph. This extra information is needed because certain objects may require to be reinitialized or recreated, to run specific code before or after the loading, to be updated to a new class definition, etc. In this paper, we present most of the general problems of object exporting and swapping. As a case of study, we present an analysis of ImageSegment, a fast solution to export and swap object graphs, developed by Dan Ingalls. ImageSegment addresses the speed problems in an efficient way, as shown by the results of several benchmarks we have conducted using Pharo Smalltalk. However, ImageSegment is not a panacea since it still has other problems that hampers its general use
An Object-oriented drawing package in smalltalk/v
Graphics creation applications tend to fall into two categories: bit-mapped paint packages, and object-oriented drawing packages. Although each interface has its own unique advantages, few vendors have attempted to integrate the two into a single package. Those who have tried have, in fact, poor integration both from the user\u27s perspective and in the underlying mathematical model. In this thesis, I have addressed the issue of integrating bit-mapped and object-oriented interfaces by creating an object-oriented graphics package which provides the user with a consistent interface for creating and manipulating both graphical objects and bit-mapped graphics. The consistency of the interface was facilitated by the consistency of the design, the underlying geometric model, and the implementation, all of which are themselves object-oriented. The thesis is written in Smalltalk/V for the Macintosh* . While the solution for this integration was not derived overnight, the use of object-oriented design principles sped the development of a complex graphical user interface, while providing fresh insight into the problem of representing bit-mapped objects. Because Smalltalk enforces the notion that every element in the system is an object, the Smalltalk developer is forced to begin designing his solution purely in terms of objects. This mind-set allowed me to view the point as no other graphics package has presented it: as a unique graphical entity (just as ll IS 1R formal geometry) available to the user as a graphical tool. As a result, users of my package are able to enjoy the benefits of both bit-mapped and object-oriented editors without ever abandoning an environment in which every graphical element is an object, in terms of both the interface and the underlying mathematical model
Automated recognition of design patterns for framework understanding
System design is one of the most important tasks in the software development cycles but it is also one of the most complex and time-consuming tasks. Thus, reuse of existing designs becomes very important. Object-oriented frameworks are generic designs for specific application domains that enable the reuse of designs and domain expert experience. In spite of this, frameworks are not simple to reuse because they are difficult to comprehend, mainly due to a lack of good documentation and supporting tools. In this work, an approach to framework comprehension based on the automated recognition and visualization of design patterns is presented. A tool was built to support this approach, by trying to automatically identify and explain the potentia~ patterns existing in a given designo Experimental results and conclusions of tool utilization are also presented
Graphical Manipulation in Programming Languages: Some Experiments
Abstract Not Provided
Recommended from our members
Exploiting Smalltalk Modules In A Customizable Programming Environment
This paper describes how we have extended a module structure of the Smalltalk LearningWorks to provide a programming environment deigned for very large scale technology transfer. The ‘module’ is what we have termed the LearningBook, a set of classes and persistent objects, including an HTML browser, programming and visualization tools, and microworlds. The context for this development is a distance learning university course in object technology which has enrolled over 5,100 mature students in its first year – making it the largest such course in the world. While promoting a systems building approach, we have successfully added support for programming in the small and the needs of the isolated novice. Two principles have applied: (i) the programming environment and its modules fit into a consistent framework for personal management of study and (ii) details of complex facilities, such as the class library, are progressively disclosed as knowledge and sophistication grow. The paper shows how these principles have guided the exploitation of LearningBook modules. To provide context, relevant academic background is given. Early informal feedback is reported and a project currently underway to observe in detail how thousands of learners use the Smalltalk programming environment is sketched
- …