By Topic

Technology of Object-Oriented Languages and Systems, 1999. TOOLS 30 Proceedings

Date 5-5 Aug. 1999

Filter Results

Displaying Results 1 - 25 of 38
  • Proceedings of Technology of Object-Oriented Languages and Systems - TOOLS 30 (Cat. No.PR00278)

    Save to Project icon | Request Permissions | PDF file iconPDF (324 KB)  
    Freely Available from IEEE
  • Enhancing an event-based OO framework for distributed programming

    Page(s): 162 - 171
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (116 KB)  

    The paper discusses an asynchronous event based object oriented framework, OVOPS, employing the usage of design patterns to incorporate and interwork with a CORBA enabled environment. Distributed programming is constantly evolving into a very realistic technology which enhances systems integration through interoperability, adaptability and flexibility. However such advantages, coupled with performance, can only be gained by the proper analysis and design of the systems or frameworks in question. A critical examination would reveal that such a framework can be made realistically possible through the usage of object oriented methods combined with the elegance of design patterns and the advances made in CORBA technology. The described environment will ensure consistent creation of protocols and other such similar services through reusable object oriented components communicating over a heterogeneous network while addressing certain shortcomings, such as ensuring asynchronous communication remaining guaranteed and providing native event and message based features without resorting to CORBA based messaging and event services. It also attempts to shield the developer from network specific issues by providing a more generic but very consistent technique to interface to the underlying services. Two areas in which such a framework can be employed are described within the Intelligent Networks realm to illustrate the available methods and practices View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Use case modeling guidelines

    Page(s): 184 - 193
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (64 KB)  

    Use case modeling has become the most popular de facto standard technique for performing software requirements analysis and specification. However, use case modeling has its well known problems, and different requirements engineers typically perform use case modeling differently. The paper provides a hierarchically organized set of detailed guidelines for use case modeling View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Tool support for testing and documenting framework-based software

    Page(s): 237 - 246
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (96 KB)  

    Complex object oriented applications are these days built on the basis of frameworks. While it is clear that a framework and the applications built using the framework conform to some design, we experienced a mismatch between the “idealized” software architecture presented in the documentation and the architectural structures actually existing in the source code. This mismatch belongs either to the failures of the developer in implementing the proposed architecture or to the lack of tool support. By providing tool support for dynamic diagrams, applications can be animated for debug and optimization purposes and actual design documentation can be extracted from the implemented model. Framework inspection using a true object oriented approach enables the software engineer to access the source level using an object oriented map of the observed application instead of switching to a procedural way of working View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Recording user actions in a Smalltalk programming environment

    Page(s): 280 - 289
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1788 KB)  

    AESOP (An Electronic Student Observatory Project) is a system for recording, replaying and analysing user actions in LearningWorks, a Smalltalk programming environment. The project aims to: (i) inform educators how best to effect object technology transfer by improving their teaching; (ii) provide an apparatus for identifying problems neophytes experience while learning to program; and (iii) provide empirical evidence for improving the design of the programming environment. Initially AESOP is being targeted on a large scale distance learning course enrolling 5000 mature students per year. The paper describes the project and gives a flavour of the research questions of how neophytes learn programming concepts, in particular object concepts as exemplified by Smalltalk. The implementation of a selection of tools is described and sample data is also explained. Current project status is reviewed and many issues are raised concerning what sort of data to collect View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Cooperative software development: concepts, model and tools

    Page(s): 194 - 207
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (132 KB)  

    The development of large software systems demands intensive cooperation among multiple project team members with different responsibilities. The development process is often distributed across time and space and takes place within and between specialized workgroups. This necessitates finding appropriate answers to questions related to division of labor, to communication, and to coordination and cooperation in the planning, development and maintenance of software systems. Development environments that explicitly support group work are an important prerequisite for the production of high quality software systems. Most of the software development environments in use today support primarily technical aspects and have shortcomings in the area of organizational support. The paper describes a model for cooperative work processes in software projects and a corresponding development environment that provides balanced support for both organizational and technical aspects of software development. The work toward the conception of the model and the implementation of the development environment have been completed, and the evaluation of the proposed approach has begun. Experience to date with using the developed environment confirms the assumption that the cooperative, cluster oriented development improves both productivity and quality. The presented approach excels primarily in its easily understandable model, the intuitive usability of the tools and the comprehensible presentation of process- and product-related information View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Using Java to add “stored procedures” to databases

    Page(s): 322 - 331
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (192 KB)  

    The paper describes our approach to adding “stored procedure” capability to a semantic database system using Java byte codes and Java's ability to dynamically load and execute Java code. Several steps were necessary: first we added a Java application programmer interface to the database system; then we created a database schema to hold Java executable code; then we constructed a Java class loader to allow code to be loaded from the database; then we enabled the creation of Java objects and executed the Java code for them. Our approach is not specific to our semantic database system, rather it can serve as a recipe for adding “stored procedures” to any database system View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Benchmark metrics for enterprise object request brokers

    Page(s): 94 - 103
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (64 KB)  

    The growing interest in using Common Object Request Broker Architecture (CORBA) to distribute application objects over heterogeneous environments has led to an explosive growth in the number of Fortune 500 companies deploying major, mission-critical applications using such client/server (c/s) architectures. Unfortunately, there is little in terms of literature that describes the complexities and issues encountered in scaling these architectures. This is due, in large part, to the relative infancy of CORBA technology when compared to other client/server architectures. The paper attempts to address some of the potential issues involved in large scale deployments of CORBA technology in highly scaled configurations. The paper makes some empirical assessments of appropriate design-guiding parameters for scalability, and discusses how to arrive at these parameters through a traceable lifecycle process. The paper also provides some guidance on what measures are appropriate to use when estimating an ORB's performance envelope, so as to appropriately extrapolate its behavioral characteristics in fully scaled production deployments View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Entity-Relationship Software Development Environment

    Page(s): 354 - 363
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (192 KB)  

    We designed and implemented a prototype software development environment based on software component composition. Our software development environment, the Entity-Relationship Software Development Environment (ERSDE), uses extended entity-relationship diagrams (EERDs) as templates of executable programs. An EERD represents the component types and the relationship types among them within an application domain. The graphical editor of the ERSDE uses an EERD as a menu in constructing application software. An EERD used as a menu can enforce legitimate patterns of relationships among software components, in addition to providing an intuitive view of available components and possible relationships among them. Furthermore, as the ERSDE uses structural active objects as the components of a program, we can obtain an executable program if those components are instantiated and interconnected as dictated by an EERD. Two experiments conducted confirmed the effectiveness of our approach View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A concurrent object-based model and its use for coordinating Java components

    Page(s): 332 - 341
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (220 KB)  

    We present a canonic model expressing the behavior of a system of communicating objects through multiset rewriting. Then, we discuss the integration of the so-defined model into the Java language. The choices and the restrictions made to implement the model as well as the architecture of the system are presented. Finally, we propose to use the prototype that we carried out as a coordination tool for communicating Java components. We focus on applications built around InfoBus, a standard package providing an event based protocol for dynamic data sharing between components. We show how our model can be used to coordinate Java events flowing on a software bus View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • MysterX: a Scheme toolkit for building interactive applications with COM

    Page(s): 364 - 373
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (164 KB)  

    MysterX is an object oriented Scheme toolkit for building applications from off-the-shelf COM components. While the COM support in languages such as Haskell and Mercury requires the use of an interface compiler to generate stub code, MysterX uses the reflective capabilities of OLE Automation to make value marshalling decisions at run time. MysterX hosts COM components in windows that display Dynamic HTML, without requiring a separate browser. Scheme code can manipulate HTML elements and their style properties in such windows to create interesting visual effects. Event handlers written in Scheme can be associated with HTML elements and COM objects. By integrating these diverse technologies, MysterX can be used to write complete GUI applications View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Measuring the effectiveness of method test sequences derived from sequencing constraints

    Page(s): 74 - 83
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1472 KB)  

    Intra-class testing refers to the testing of the interaction among methods and data structures encapsulated within a single class. Our approach to intra-class testing is to execute sequences of instance methods that are derived from sequencing constraints and evaluate their results for correctness. These constraints impose restrictions on method behaviors and can be derived from a formal or informal specification of a class. We present an empirical evaluation of different method sequence generation approaches, and analyze their effectiveness in detecting software faults. In addition, we define a number of coverage criteria based on method sequencing constraints for a class and examine the differences between them View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Interaction schemata: compiling interactions to code

    Page(s): 268 - 277
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (72 KB)  

    Programming object interactions is at the heart of object oriented programming. To improve reusability of the interactions, it is important to program object interactions generically. We present two tools that facilitate programming of object interactions. StructureBuilder, a commercial tool, achieves genericity with respect to data structure implementations for collections, following ideas from generic programming, but focussing only on the four most important actions add, delete, iterate and find that are used to translate UML interaction diagrams into code. The focus of StructureBuilder is to generate efficient code from interaction schemata that are an improved form of interaction diagrams. DJ, a new research prototype intended for fast prototyping, achieves genericity with respect to the UML class diagram by dynamic creation of collections based on traversal specifications View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Specifying Java frameworks using abstract programs

    Page(s): 136 - 145
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (260 KB)  

    We propose a novel approach to specifying, documenting, and reasoning about object oriented frameworks. The novelty of our approach is in combining standard executable statements of a programming language (we choose Java as an example) with possibly nondeterministic specification constructs. A specification of the intended behavior given in this language can serve as a precise documentation for users of the framework and its extension developers. To illustrate the applicability of our method to specification of object oriented frameworks, we demonstrate how one can specify the Java Collections Framework which is a part of the standard Java Development Kit 2.0 View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Implementing a distributed garbage collector for OO databases

    Page(s): 42 - 52
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (204 KB)  

    We describe the implementation of a distributed garbage collector for a group of object oriented databases. We start by considering the issues that led to the choice of algorithm and why garbage collection in a database is more difficult than in memory. We describe the algorithm and how it was implemented in Eiffel, using PVM (Parallel Virtual Machine) and the Versant ODBMS View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Visualizing O-O testing in virtual communities-distributed teaching and learning

    Page(s): 300 - 310
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (212 KB)  

    The Internet has been recognised not only as a tool for communication in the 21st century but also as an environment for enabling changes in the paradigm of teaching and learning. The paper describes our research effort on the design and delivery of quality educational material on object oriented (OO) testing in an Internet environment. OO software testing has the advantage of being easily visualizable in terms of state changes and data flows. We present the inner workings of the complex processes involved in OO testing. The OO testing case studies considered contain visual images, animation, and interactive lessons, to assist active participation by learners to result in better understanding and knowledge retention. The distributed teaching and learning approach discussed in the paper employs appropriate UML diagrams, makes the diagrams test ready by including details of constraints as part of state/event transitions, and provides interactive lessons for learning OO software testing. Furthermore, the paper describes a development process in visualization and interactivity to achieve improved learning outcomes of OO software testing in an Internet based environment (see http://www.sd.monash.edu.au/sitar/se-educ-proj) View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Separable UI architectures in teaching object technology

    Page(s): 290 - 299
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (272 KB)  

    The paper concerns the critical role of separable user interface design in teaching object oriented systems. M206 “Computing: An Object-oriented Approach” is a large scale university level introduction to software development designed from scratch for distance learning, using an objects first approach with Smalltalk. The course is degree level, counting as one-sixth of a degree, and is being offered in the UK, Western Europe and Singapore. To address the needs of industry, we have developed a radical syllabus that adheres to the principle of designing complex systems by separating view and model, and have developed a programming and learning environment to support these ideas. We examine how separable user interface architectures have guided our teaching of object technology and the design of powerful microworlds that are both usable and extendible by neophytes. The course and relevant teaching with software is outlined and the technical design and pedagogic use of the microworlds and GUI builder tool are described View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Analysis techniques for testing polymorphic relationships

    Page(s): 104 - 114
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (312 KB)  

    As we move from developing procedure oriented to object oriented programs, the complexity traditionally found in functions and procedures is moving to the connections among components. More faults occur as components are integrated to form higher level aggregates of behavior and state. Consequently, we need to place more effort on testing the connections among components. Although object oriented technology provides abstraction mechanisms to build components to integrate, it also adds new compositional relations that can contain faults, which must be found during integration testing. The paper describes new techniques for analyzing and testing the polymorphic relationships that occur in object oriented software. The application of these techniques can result in an increased ability to find faults and overall higher quality software View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Detecting evolution incompatibilities by analyzing Java binaries

    Page(s): 126 - 135
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (316 KB)  

    Customizing component functionality to application needs generally involves inheritance, known to suffer from the fragile base class problem: changes in a base class may cause preexisting inheritor classes to malfunction, or even become undefined. We present a framework for binary detection of such incompatible changes at component (re)integration time. This avoids unexpected erroneous runtime behavior of the integrated components View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • View programming for decentralized development of OO programs

    Page(s): 210 - 221
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (104 KB)  

    There has been a lot of interest recently in the problem of building object oriented applications by somehow combining other application fragments that provide their own overlapping definitions or expectations of the same domain objects. We propose an approach based on the split objects model of prototype languages whereby an application object is represented by a varying set of instances-called views-that implement different parts of its domain behavior but that delegate its core functionalities to a core instance: an object's response to a message depends on the views currently attached to its core instance. Our approach is not purely prototype based in the sense that core instances and views are members of classes. Further, we recognize that the behavior inherent in views (classes) is often an adaptation of a generic behavior to the domain object at hand, and define viewpoints as parameterized class-like algebraic structures to embody such a generic behavior. We first describe view programming from the perspective of the developer. Next, we sketch a semi formal model of view programming, and describe the steps needed to implement it in a class based statically typed language, for instance, C++. Third, we look at the challenges and opportunities provided by view programming to support safe, robust, and efficient distributed applications View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • When to trust mobile objects: access control in the JiniTM Software System

    Page(s): 116 - 125
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (268 KB)  

    Future developments in computing, and in consumer electronics, will involve a considerable degree of convergence: applications will work together to locate and provide services. If this convergence is to be implemented successfully, then a shared model for reliable service provision is required. The recently released JiniTM Software System (1.0) is an attempt to meet this requirement through object orientation. Based entirely upon existing JavaTM 2 technology, Jini is a set of protocols and programming models for peer-to-peer service provision using downloaded code and remote method invocation. The paper examines the way in which the Jini Software System will be used. It shows that the existing mechanisms for access control and secure operation provided by Java may prove inadequate in a Jini environment: a Jini enabled device will be vulnerable to attack from its peers. Similar problems may be encountered in other related technologies, such as Enterprise Java Beans. An account of the Jini technology is followed by an exploration of the inadequacies and vulnerabilities; concrete examples are provided to illustrate the possible attacks. The paper ends by showing how the existing specification may be enhanced to produce a secure system without significantly reducing either functionality or flexibility View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Bounding component behavior via protocols

    Page(s): 387 - 398
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1396 KB)  

    We enhance the SOFA Component Description Language with a semantic description of a component's functionality. There are two key requirements this description aims to address: first, it should ensure correct composition of the nested architectural abstractions (for design purposes); second, it should be easy-to-read so that an average user can identify a component with the correct semantics for the purposes of component trading. The semantic description in SOFA expresses the behavior of the component in terms of behavior protocols using a notation similar to regular expressions which is easy to read and comprehend. The behavior protocols are used on three levels: interface, frame, and architecture. The key achievements of the paper include the definition of the protocol conformance relation. Using this relation, the designer can in most cases statically verify that the frame protocol adheres to the requirements of the interface protocols, and that the architecture protocol adheres to the requirements of the frame and interface protocols View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Storing Java objects in any database

    Page(s): 312 - 321
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (188 KB)  

    Typical Java applications involve access to a database system. Database systems store data according to their type system; even object oriented databases generally have their own storage structures. It is therefore necessary to convert Java objects as they are stored in a database, and to re-convert them when they are read. Ideally, this should be done behind the scenes by a support package. The paper presents an approach that automates the conversion process without involving pre- or post-processing of Java code: we use a reflection mechanism, where Java code is inspected at run time and changed to include the convert and re-convert effort. The result is a flexible and transparent Java database access View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Managing the software development by using the recursive multithreaded (RMT) tool

    Page(s): 344 - 353
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (140 KB)  

    A number of software life cycles for object oriented software development (Fountain Model, Recursive/Parallel Model, McGregor and Sykes Model, and Chaos Model Life-Cycle) exist today. However, these life cycles have little or no support for estimating and monitoring progress during the development of the software. The ability to measure progress during the development is significant because it allows both the managers and the developers to determine whether a project is on schedule or not. Identifying that a project is behind schedule allows managers and developers to notify appropriate individuals of any scheduling and/or budgetary impacts at an early stage during the development and to determine appropriate course of action. The paper presents the Recursive Multi-Threaded (RMT) software life cycle which supports the monitoring of progress during development, addresses the specific needs of the developing object oriented software, and attempts to resolve deficiencies found in many existing software life cycles. What makes RMT unique from existing software life cycles is its use of a “thread” for partitioning and organizing software development activities. Threads support iteration and recursion, which are critical concepts for the development of the software. To implement the concepts of the RMT software life cycle model, we develop the RMT Tool, which is Java based. The Tool was used in an actual software development project in our software engineering course to test its functionalities View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Component frameworks-a case study

    Page(s): 148 - 157
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (76 KB)  

    The paper reports on an effort to use both the system theoretic DEVS (discrete event simulation) formalism and the JavaBeans component model as a basis for a component based discrete event simulation framework. The result of the synergism of DEVS and JavaBeans is a powerful component based simulation framework together with a set of flexible bean components for building simulation systems. Component frameworks are dedicated and focused architectures with a set of policies for mechanisms at the component level. We describe the component framework we have developed for discrete event simulations. Simulation components are based on this framework and can be composed for the creation of various simulation scenarios View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.