89 research outputs found

    Contents EATCS bulletin number 48, October 1992

    Get PDF

    Eutrophication problems, causes and potential solutions, and exchange of reusable model building components for the integrated simulation of coastal eutrophication. ISECA Final Report D3.2

    Get PDF
    This report summarizes the stages of coastal and offshore eutrophication, followed by a description of the European indicators and institutional framework for marine eutrophication assessment. A summary is given of a number of biogeochemical models available to describe the process of eutrophication in the North Sea, and the model for atmospheric inputs which was developed in the ISECA project (see the Action 3 Report – Atmospheric Modelling for more details on this work). Furthermore, the report compares different solutions aimed at reducing the nitrogen inputs from the Scheldt basin, using the nitrogen apportionment model which was developed in the EU-FP6 project SPICOSA (www.spicosa.eu). The report is concluded with a discussion on the principles of component-based modelling and model libraries, using examples for the Scheldt model, and a general discussion on some challenges of modelling marine eutrophication

    Objects and polymorphism in system programming languages: a new approach

    Get PDF
    A low-level data structure always has a predefined representation which does not fit into an object of traditional object-oriented languages, where explicit type tag denotes its dynamic type. This is the main reason why the advanced features of object-oriented programming cannot be fully used at the lowest level. On the other hand, the hierarchy of low-level data structures is very similar to class-trees, but instead of an explicit tag-field the value of the object determines its dynamic type. Another peculiar requirement in system programming is that some classes have to be polymorphic by-value with their ancestor: objects must fit into the space of a superclass instance. In our paper we show language constructs which enable the system programmer to handle all data structures as objects, and exploit the advantages of object-oriented programming even at the lowest level. Our solution is based on Predicate Dispatching, but adopted to the special needs of system programming. The techniques we show also allow fo r some classes to be polymorphic by-value with their super. We also describe how to implement these features without losing modularity

    Vers un profil UML pour la conception de composants multivues

    Get PDF
    International audienceThis paper aims to present an UML profile based on multiviews components. A multiviews component allows to encapsulate and deliver information according to the user's point of view and offers mechanisms to manage the dynamic evolution of viewpoints and consistency among views. In this paper, we first present the notion of multiviews component and its integration into a UML profile, and thus detail an object-oriented multiviews modelling applied to a concrete example. The transition to the coding stage is described through a generic implementation pattern.L' objectif de cet article est de présenter un profil UML permettant la construction de composants logiciels multivues. Un composant multivues est une extension de la notion de composant UML permettant de stocker et restituer de l' information en fonction du profil de l' utilisateur (point de vue), et offrant la possibilité de changement dynamique de point de vue. Dans cet article, nous présentons tout d' abord la notion de classe multivues, puis le composant multivues et son intégration dans un profil UML. Nous illustrons à l' aide d' un exemple concret la mise en oeuvre d' une modélisation objet multivues. La transition vers la phase de codage est présentée à travers un patron d'implémentation générique

    Roles,Subjects and Aspects: How Do They Relate?

    Full text link

    From AOP to UML - A Bottom-Up Approach

    Get PDF
    This position paper takes a bottom-up approach that analyzes the suitability of UML for modeling aspect-oriented software, and compares it with the UML support for modeling object-oriented software. We first introduce the basic concepts of AspectJ, a state-of-the-art aspect-oriented programming language, and then take a naĂŻve approach using standard UML, as it is, for modeling these concepts. As the limitations of current UML become apparent, we propose some extensions to UML to overcome these limitations

    From AOP to UML: Towards an Aspect-Oriented Architectural Modeling Approach

    Get PDF
    Capturing concerns that crosscut the boundaries of multiple components in software architecture descriptions is problematic. Standard description languages, such as UML, do not provide adequate means to understand and modularize such concerns, but aspect-oriented programming techniques do. This paper explores and analyzes the suitability of UML for aspect-oriented architectural modeling. It takes a bottom-up approach, starting from the code level to the level of software architecture description, via aspect-oriented design, using standard UML

    Integrating CBSE, SoC, MDA, and AOP in a Software Development Method

    Get PDF
    Component-Based Software Engineering, Separation of Concerns, Model-Driven Architecture, and Aspect-Oriented Programming are four active research areas that have been around for several years now. In this paper, we present how these four paradigms can be put together in the context of a new software development method and we show how they can complement each other at different stages in the development life-cycle of enterprise, middleware-mediated applications. Different software development methods, such as Fondue, Catalysis, KobrA, and the Rational Unified Process, are also analyzed, pointing out their differences and limitations. In the end, requirements for a dedicated tool infrastructure that would support the new development approach are discussed

    Program Analysis Scenarios in Rascal

    Get PDF
    Rascal is a meta programming language focused on the implementation of domain-specific languages and on the rapid construction of tools for software analysis and software transformation. In this paper we focus on the use of Rascal for software analysis. We illustrate a range of scenarios for building new software analysis tools through a number of examples, including one showing integration with an existing Maude-based analysis. We then focus on ongoing work on alias analysis and type inference for PHP, showing how Rascal is being used, and sketching a hypothetical solution in Maude. We conclude with a high-level discussion on the commonalities and differences between Rascal and Maude when applied to program analysis

    AOP: Does it Make Sense ? The Case of Concurrency and Failures

    Get PDF
    Concurrency and failures are fundamental problems in distributed computing. One likes to think that the mechanisms needed to address these problems can be separated from the rest of the distributed application: in modern words, these mechanisms could be aspectized. Does this however make sense? This paper relates an experience that conveys our initial and indeed biased intuition that the answer is in general no. Except for simple academic examples, it is hard and even potentially dangerous to separate concurrency control and failure management from the actual application. We point out the very facts that (1) an aspect-oriented language can, pretty much like a macro language, be beneficial for code factorization (but should be reserved to experienced programmers), and (2) concurrency and failures are particularly hard to aspectize because they are usually part of the phenomenon that objects should simulate. They are in this sense different than other concerns, like for instance tracing, which might be easier to aspectize
    • 

    corecore