By Topic

Technology of Object-Oriented Languages and Systems, 2000. TOOLS-Pacific 2000. Proceedings. 37th International Conference on

Date 20-23 Nov. 2000

Filter Results

Displaying Results 1 - 25 of 30
  • Proceedings 37th International Conference on Technology of Object-Oriented Languages and Systems. TOOLS-Pacific 2000

    Publication Year: 2000
    Save to Project icon | Request Permissions | PDF file iconPDF (145 KB)  
    Freely Available from IEEE
  • Author index

    Publication Year: 2000 , Page(s): 340
    Save to Project icon | Request Permissions | PDF file iconPDF (40 KB)  
    Freely Available from IEEE
  • Generic invariant-based static analysis tool for detection of runtime errors in Java programs

    Publication Year: 2000 , Page(s): 36 - 44
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (492 KB)  

    The paper presents an invariant-based generic tool to statically analyze Java programs in order to detect potential errors (bugs). We briefly discuss the supporting theoretical framework and highlight the results of the tool. It can automatically detect potential bugs such as illegal dereference and array bounds and report them before the program is executed. For a Java class, invariants related to the category of error under examination are automatically generated and used to assess the validity of variable usage in the implementation of this class. The tool provides a practical and extensible generic mechanism for error detection to help industry practitioners who work with an object oriented language such as Java. The presented mechanism is capable of addressing error detection for a variety of error categories that cannot be caught by flow-based static analysis tools View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A method for the design and development of distributed applications using UML

    Publication Year: 2000 , Page(s): 253 - 264
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (752 KB)  

    Presents a design and development method for distributed applications running on top of advanced object-oriented middleware platforms. We introduce the basic concept of the distinction between a set of concepts and their relations, the definition of a notation supporting such concepts and rules for automatic code generation that help to provide a smooth transition from the design step to the implementation stage. Although the set of concepts is based on RM-ODP (Reference Model for Open Distributed Processing), we refine a number of ODP definitions in order to reflect practical design tasks. The supporting notation we present rests upon the customization of the Unified Modeling Language (UML). Automatic code generation issues are presented briefly, taking a extended CORBA 2.3 object middleware as the target distributed infrastructure View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Generic components to foster reuse

    Publication Year: 2000 , Page(s): 266 - 277
    Cited by:  Papers (1)  |  Patents (5)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (644 KB)  

    Software reuse, and especially the paradigm of software components, is a promising approach to increase the efficiency of software development. One of the basic problems of software reuse, however, is the trade-off between the abstraction from project-specific aspects on the one side, and the actual contribution of a reusable component during the realization of a new system on the other side. Conventional components with fixed properties are trapped within the inherent tension between overly general and less efficient solutions satisfying a large number of niche requirements, and specifically optimized but less reusable designs for each point in the requirements space. Generic components which are designed and implemented to be mechanically adaptable to new application scenarios allow to overcome these limitations and help to drastically increase the efficiency of software development. This paper introduces the fundamental concepts of generic components and particularly discusses viable techniques to implement generic components. It furthermore shows how generic components may be instantiated automatically by tools and reports on our first experiences in using generic components for the construction of embedded operating systems View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Prioritising use cases and scenarios

    Publication Year: 2000 , Page(s): 108 - 119
    Cited by:  Papers (6)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (516 KB)  

    Use cases (J. Rumbaugh et al., 1997) are currently used in requirements elicitation and analysis. They describe in natural language the complete functionality of a proposed system. In most projects, the amount of detail put into eliciting and documenting a use case is usually dependent on the time and resources available. Seldom is there enough time to fully expand all the use cases. Thus, only a small number of the use cases are ever fully expanded. The paper delves into the structure and importance of use cases, the importance of prioritising requirements and use cases, and then describes a framework that can manage the multi-faceted issues that need to be considered when prioritising use cases. The various components of the tool that are used to prioritise use cases are described, and examples of how the various components assist in ranking use cases are presented View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An event-based framework for converged service provisioning

    Publication Year: 2000 , Page(s): 24 - 34
    Cited by:  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (728 KB)  

    The paper describes an object-oriented event-based framework for provisioning services for the converging telecommunications networks and the Internet. The DOORS (distributed object operations) framework attempts to address several issues in protocol development, interoperability and distributed computing in heterogenous networks and telecommunications systems. The framework highlights a generic service platform, called Network Intelligence Middleware, as a means to interface with the disparate networks and systems. In addition, the platform is a controlling environment for provisioning the services in the network, guaranteeing the runtime robustness and scalability View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Java Multi-Method Framework

    Publication Year: 2000 , Page(s): 45 - 56
    Cited by:  Papers (2)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (664 KB)  

    In Java, method resolution is done at runtime, by late-binding, with respect to the dynamic type of the target object. Some object-oriented languages such as CLOS propose, in addition, late-binding according to dynamic types of arguments. This feature is known as multi-polymorphism and usually achieved by multi-methods. We propose a pure Java framework that provides multi-methods, without extending the base Java language nor modifying its semantics but intensively using the reflection mechanism of the language. The paper focuses on the algorithms and data structures involved in the method resolution strategy we have implemented in an optional package called Java Multi-Method Framework View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Eliciting security requirements by misuse cases

    Publication Year: 2000 , Page(s): 120 - 131
    Cited by:  Papers (51)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (648 KB)  

    Use case diagrams (L. Jacobson et al., 1992) have proven quite helpful in requirements engineering, both for eliciting requirements and getting a better overview of requirements already stated. However, not all kinds of requirements are equally well supported by use case diagrams. They are good for functional requirements, but poorer at e.g., security requirements, which often concentrate on what should not happen in the system. With the advent of e- and m-commerce applications, security requirements are growing in importance, also for quite simple applications where a short lead time is important. Thus, it would be interesting to look into the possibility for applying use cases on this arena. The paper suggests how this can be done, extending the diagrams with misuse cases. This new construct makes it possible to represent actions that the system should prevent, together with those actions which it should support View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A model for the migration to object-oriented software development with special emphasis on improvement of acceptance

    Publication Year: 2000 , Page(s): 132 - 143
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (732 KB)  

    Object oriented technology has been established as an important new paradigm in software development. Thus, many organizations involved in any kind of software production plan to migrate to object oriented technology or have already started this process. Besides several successful migrations, many failures occur. In order to reduce the risk of failure during the migration process, we developed a migration model based on an empirical study. The application of this model leads to a better understanding of the migration process and supports its planning, designing and implementation, putting special emphasis on improvement of acceptance. The theoretical foundations of our migration model come from technology management, organizational research (i.e. change management, and organizational roles), as well as existing approaches and models for this kind of migration. Our migration model consists of three main parts: the migration process model, the definition of organizational roles, and the use of acceptance strategies such as information and communication, participation, and further education. The main results concerning the rise of acceptance strategies, based on the results of the empirical study, are presented View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An integrated approach for documenting, exploring, and building framework-based software

    Publication Year: 2000 , Page(s): 316 - 327
    Cited by:  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (808 KB)  

    The use of well-designed class libraries and frameworks is a key element of object oriented software development. However, while frameworks may significantly reduce development time and cost, they are difficult to understand and therefore hard to learn to use. We present an environment that supports documenting, browsing and editing of selected aspects of frameworks and framework based applications on an abstraction level that is not available through static or dynamic program analysis. The main ideas of this environment are a specialized desktop metaphor for visualizing and browsing software architectures, the support of framework based development by means of architecture templates, and an open tool architecture that supports the integration of any additional tools for visualizing and editing application and framework parts View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • More meaningful UML models

    Publication Year: 2000 , Page(s): 146 - 157
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (680 KB)  

    UML is widely used today for modelling complex systems. However, the tool support capabilities for UML is limited, partially due to its lack of precise semantics. There are some approaches that try to solve this by defining a formal semantics for UML, nonetheless it usually proves hard to implement the corresponding dynamic semantics. The paper presents an approach to define an executable semantics for UML that would enable tool vendors to build intelligent tools (symbolic execution, consistency checkers, etc.). We use Abstract State Machines (ASM) as an underlying formalism for our semantics definition, which is composed of static semantics and dynamic semantics. A part of the static semantics was done by expressing in ASM the UML meta-model and well formedness rules defined in the UML standard. The dynamic semantics is based on a set of behaviour primitives (time, communication, etc.). We define the ASM transition rules corresponding to UML actions. Using this semantic, we have been able to perform a symbolic execution of a UML model View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Understanding frameworks through visualisation

    Publication Year: 2000 , Page(s): 304 - 315
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1016 KB)  

    Object oriented frameworks can significantly improve productivity. However, learning how to use them effectively is a well-known, difficult problem. We discuss the issues related to this problem, and describe the design and development of a prototype framework visualisation system intended to help solve the problem View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Scalable visualisations with ownership trees

    Publication Year: 2000 , Page(s): 202 - 213
    Cited by:  Papers (3)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (752 KB)  

    Ownership trees are a simple yet powerful method of extracting an object-oriented program's implicit aggregation structure from its object graph. The topology of a program's ownership tree is independent of scale object-oriented programs are constructed from objects, and the relationship between a whole system and its top-level components is the same as the relationship between a low-level data structure and the objects that implement it. Because of this independence, a software visualisation tool based on ownership trees is applicable at all levels of abstraction within a program's design. Visualising ownership trees can support learning and teaching about object-oriented programs, as well as debugging and maintaining them View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Self-calibration of metrics of Java methods

    Publication Year: 2000 , Page(s): 94 - 106
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (768 KB)  

    Self-calibration is a new technique for the study of internal product metrics, sometimes called “observations” and calibrating these against their frequency, or probability of occurring in common programming practice (CPP). Data gathering and analysis of the distribution of observations is an important prerequisite for predicting external qualities, and in particular software complexity. The main virtue of our technique is that it eliminates the use of absolute values in decision-making, and allows gauging local values in comparison with a scale computed from a standard and global database. Method profiles are introduced as a visual means to compare individual projects or categories of methods against the CPP. Although the techniques are general and could in principle be applied to traditional programming languages, the focus of the paper is on object oriented languages using Java. The techniques are employed in a suite of 17 metrics in a body of circa thirty thousand Java methods View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Symbol table construction and name lookup in ISO C++

    Publication Year: 2000 , Page(s): 57 - 68
    Cited by:  Papers (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (612 KB)  

    The authors present an object oriented model of symbol table construction and name lookup for ISO C++ using the Unified Modeling Language (UML). Our use of UML class, activity and sequence diagrams serves to explicate our model and our use of patterns such as decorator and facade increase the understandability of the model. Clause three of the ISO C++ standard describes the procedures and rules for performing name lookup; our activity and sequence diagrams serve to simulate these procedures in graphical fashion. An advantage of our approach is that our model can increase C++ understandability for those practitioners with a working UML knowledge. An important contribution of our work is that our model forms the basis for construction of a parser front-end for ISO C++. Our explication of the name lookup problem represents a necessary first step in this construction and our component approach is independent of the compiler technology utilized. Our use of the UML in describing parser driven applications demonstrates how front-end development can be integrated into an object oriented framework. Construction of an ISO C++ front-end will help to increase the collection of tools for applications that use this popular language View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A case study of framework design for horizontal reuse

    Publication Year: 2000 , Page(s): 278 - 289
    Cited by:  Papers (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (644 KB)  

    In this experience report, we present a case study in designing, implementing and reusing an object-oriented framework for constructing and editing complex search expressions over arbitrary data domains. We present a framework design that achieves a large degree of business domain decoupling through the application of design patterns. We outline the reuse process and analyse and classify the problems encountered during the first-instance framework reuse. The major lessons learned are: (1) that, while design patterns are well-known for providing decoupling solutions at the code level, the lack of similar decoupling techniques at the non-code level may give rise to technical mismatch problems between the framework and the client systems; (2) that such technical mismatch problems can be costly; and (3) that a reusable framework may beneficially provide a solution template when it cannot provide actual functionality View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An asynchronous message exchange system on CORBA

    Publication Year: 2000 , Page(s): 14 - 23
    Cited by:  Papers (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (648 KB)  

    Data exchange by networks is becoming more important due to the growth of the Internet. One popular architectural style for distributed, loosely-coupled, heterogeneous network systems is a structure based on event generation, observation and notification. Based on the event service and naming service defined by OMG (Object Management Group), we build an efficient and Internet-scale event-driven data exchange architecture on CORBA. The asynchronous message exchange system (AMES) provides an asynchronous publish/subscriber communication model and can communicate with legacy systems easily. This system was developed based on the Java programming language and Inprise Visibroker for Java product families View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Problem frames and object-oriented software architecture

    Publication Year: 2000 , Page(s): 70 - 81
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (688 KB)  

    The paper attempts to marry object oriented software architecture with M. Jackson's (1995) “problem frames”. Jackson's problem frames follow from his perception that many systemic problems in modern software development can be addressed by a greater problem space orientation during system specification and analysis, and a clearer separation of problem and solution space concerns during design and implementation. The author attempts an experimental union of problem space and object oriented architecture by adopting Jackson's generic problem structural patterns, problem frames, as the principal structural driver of an object oriented architecture. Problem frames bring with them a detailed method for solving problems of the corresponding class; the paper extends one problem frame's method to include a basic object oriented framework to provide a reference software architecture. The problem frame's reference architecture is evaluated by applying it to the design of a typical business component. The characteristics of the resultant architecture are then evaluated View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Transforming UML static models into object-oriented code

    Publication Year: 2000 , Page(s): 170 - 181
    Cited by:  Papers (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (644 KB)  

    The authors propose a reuse based rigorous method using UML and algebraic specifications. Our contribution is towards an embedding of the object oriented code generation within a rigorous process that facilitates reuse, evolution and maintenance of the software. In previous work we described the GSBLOO language (L. Fevre and S. Clerici, 1999) to cope with the formalization of UML static models, and the SpReIm model for the definition of the structure of reusable components. Our current goal is to map design artifacts to object oriented code. We describe a rigorous process to forward engineer UML static models. The emphasis is given to the transformation of UML class diagrams into object oriented code. In particular, we describe how to transform OCL specifications into GSBL00 View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Dynamic team structures for supporting software design episodes

    Publication Year: 2000 , Page(s): 290 - 301
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (736 KB)  

    Much software design and development is still performed from inside hierarchically structured development organisations. Hierarchy permeates many traditional organisations - the line of military command, the relationship between a surgeon and the attending staff, and the interactions between workers and operations managers on an industrial assembly line are examples. The design of any piece of intellectual property, particularly the design of software, requires interactions and designer-driven flows of information for which hierarchy is considered harmful. This paper considers the nature of software design and addresses the reasons why the supporting organisational structures need to be both flexible and interaction-based. C. Alexander's (1988) analysis of the inappropriateness of hierarchical master-planning in cities and architectural design provides a metaphorical illustration and model. A proposed conceptual solution for dynamic team structuring to support design episodes is described that solves interaction and organisational structuring problems on increasing scales from the individual developer up to the software enterprise level View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Design and implementation of CORBA-based Subscription Server

    Publication Year: 2000 , Page(s): 2 - 13
    Cited by:  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (648 KB)  

    The standard CORBA operation invocation model supports synchronous, one-way, and deferred synchronous interactions between clients and servers. However, this model is too restrictive for real-time applications. In particular, the model lacks asynchronous message delivery, does not support timed invocations or group communication, and can lead to excessive polling by clients. We have designed and implemented a subscription server based on the OMG Notification Service specification for the structured push style communication. In order to alleviate some of the restrictions with the standard CORBA invocation model, the Subscription Server supports asynchronous message delivery and allows one or more suppliers to send structured messages to one or more consumers. Event data can be delivered from suppliers to consumers without requiring these participants to know about each other explicitly. In addition to implementing most of the interfaces defined in the specification, the Subscription Server implements an additional advertiser interface which lets one discover all event types offered by the channel and subscribed by the consumers. Event filtering as well as quality of service properties, such as connection reliability and event reliability, are also provided. An Auction Alert application was developed to test the functionality of the subscription server View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Match-O, a dialect of Eiffel with match-types

    Publication Year: 2000 , Page(s): 190 - 201
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (664 KB)  

    It is well-known that the Eiffel language allows covariant redefinition. Regardless of system-level validity rules, Eiffel is not type-safe. In this paper, we present a dialect of Eiffel, called Match-O, which prohibits covariant redefinition. We introduce a new kind of types, the match types, inspired by the papers of K. Bruce (1993-1998). The scope of this project is many-fold: allowing binary methods; keeping sound “mytype method specialization”, i.e. an anchored type using Current; and allowing subtyping in all other sound cases. We claim that match types can be added in the Eiffel type system to eliminate type unsoundness without blocking many interesting Eiffel programs (e.g. the ones with “binary methods”). We have implemented a compiler for Match-O and we have experimented with our dialect on a large system using the original source code of smallEiffel itself View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Tool support for systematic class identification in object-oriented software architectures

    Publication Year: 2000 , Page(s): 82 - 93
    Cited by:  Patents (1)
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (848 KB)  

    Software architectures have received considerable attention in both research and practice for representing system stakeholder concerns, and many researchers have leveraged object oriented models and methods for software architecture representation and evaluation. While the benefits associated with object oriented approaches are closely aligned with desirable qualities for software architectures (e.g., reusability, extensibility, comprehensibility, performance), these benefits are only realized through rational decision making by the analyst when identifying object oriented classes from a requirements specification. Traditionally, the class identification process has been somewhat subjective, with different analysts often arriving at completely different class models from the same requirements specification. Since this subjectivity does not lend itself to automation, little tool support is available for identifying object oriented classes and their relationships. The paper describes a tool under development, Reference Architecture Representation Environment (RARE), designed to systematically guide the analyst through class identification by applying heuristics associated with quality attributes and evaluating the resulting architecture based on relevant static metrics. RARE helps address a number of challenges typically faced during the class identification process, including: (1) developing an architecture that reflects the quality attributes prioritized by the analyst, (2) managing inherent conflicts between selected attributes, and (3) capturing analyst expertise and rationale for use by others View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Component based application framework for systems utilising the streaming data passing semantic

    Publication Year: 2000 , Page(s): 328 - 339
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (564 KB)  

    The paper describes the design of a component based application framework for systems utilising the streaming data passing semantic. Many advanced applications employ data streams to model continuous or semi-continuous flows of information. We describe an application framework, called iFlow, that can significantly ease the effort in developing such applications. This framework supports the dynamic construction of channels between the source and recipient of information that matches the requirements of the different systems involved in the information exchange. We conclude with a description of applying iFlow to a particular stream oriented application for the dissemination of imagery information View full abstract»

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