The abstract data type one-sided flexible array, also called random-access list, supports look-up and update of elements and can grow and shrink at one end. We describe a purely functional implementation based on weig...
详细信息
ISBN:
(纸本)9781581134872
The abstract data type one-sided flexible array, also called random-access list, supports look-up and update of elements and can grow and shrink at one end. We describe a purely functional implementation based on weight-balanced multiway trees that is both simple and versatile. A novel feature of the representation is that the running time of the operations can be tailored to one's needs-even dynamically at array-creation time. In particular, one can trade the running time of look-up operations for the running time of update operations. For instance, if the multiway trees have a fixed degree, the operations take Theta(log n) time, where n is the size of the flexible array. If the degree doubles levelwise, look-up speeds up to Theta(rootlog n) while update slows down to Theta(2(rootlog n)). We show that different tree shapes can be conveniently modelled after mixed-radix number systems.
Keeping the code of a Java(TM) application consistent (code is consistent if all of the project classes can be recompiled together without errors) prevents late linking errors, and thus may significantly improve devel...
详细信息
Keeping the code of a Java(TM) application consistent (code is consistent if all of the project classes can be recompiled together without errors) prevents late linking errors, and thus may significantly improve development turnaround time. In this paper we describe a make technology for the Java programminglanguage, that is based on smart dependency checking, guarantees consistency of the project code, and at the same time reduces the number of source code recompilations to the minimum. After project code consistency is initially assured by complete recompilation, the information extracted from the binary classes is stored in a so-called project database. Whenever the source code for some class C is changed, its recompiled binary is compared to the old version of C preserved in the project database. As a, result, we find a minimum subset of classes that depend on C and may be affected by the particular change made to it. These are recompiled in turn, and absence of compilation errors at this phase guarantees the consistency of the new project code. To determine which dependent classes to recompile, we categorize all source incompatible changes, and for each category establish a criterion for finding the smallest possible subset of dependent classes.
We introduce in this paper a typed calculus intended to capture the execution model of COM. The innovation of this calculus is to model very low-level aspects of the COM framework, specifically the notion of interface...
详细信息
ISBN:
(纸本)9781581134711
We introduce in this paper a typed calculus intended to capture the execution model of COM. The innovation of this calculus is to model very low-level aspects of the COM framework, specifically the notion of interface pointers. This is handled by specifying an allocation semantics for the calculus, thereby modeling heap allocation of interfaces explicitly. Having an explicit way of talking about interface pointers allows us to model in a reasonable way the notions of interface sharing and object identity. We introduce a type system that can be used to disambiguate between specification and implementation of interfaces. The type system moreover can capture a notion of COM conformance, that is, the legality of COM components. We discuss extensions of the calculus to handle subtyping of interfaces, dynamic interface negotiation and aggregation.
The proceedings contain 20 papers. The special focus in this conference is on Generative programming and Component Engineering. The topics include: Program generation, termination, and binding-time analysis;generative...
ISBN:
(纸本)3540442847
The proceedings contain 20 papers. The special focus in this conference is on Generative programming and Component Engineering. The topics include: Program generation, termination, and binding-time analysis;generative programming for embedded systems;a specification and scripting language for binary data;memoization in type-directed partial evaluation;a protocol stack development tool using generative programming;building composable aspect-specific languages with logic metaprogramming;architectural refactoring in framework evolution;towards a modular program derivation via fusion and tupling;generative programming for embedded software;a framework for the detection and resolution of aspect interactions;bridging the gap between implementation and design;program termination analysis in polynomial time;generators for synthesis of qos adaptation in distributed real-time embedded systems;optimizing content management system pipelines;component-based programming for higher-order attribute grammars;altering java semantics via bytecode manipulation;meta-programming with concrete object syntax and managing dynamic changes in multi-stage program generation systems.
This one-day tutorial is aimed at software engineering practitioners and researchers, who axe familiar with object-oriented analysis, design and programming and want to obtain an overview of the technologies that are ...
详细信息
ISBN:
(纸本)158113472X
This one-day tutorial is aimed at software engineering practitioners and researchers, who axe familiar with object-oriented analysis, design and programming and want to obtain an overview of the technologies that are enabling component-based development. We introduce the idea of component-based development by defining the concept and providing its economic rationale. We describe how object-oriented programming evolved into local component models, such as Java Beans and distributed object technologies, such as the Common Object Request Broker Architecture (CORBA), Java Remote Method Invocation (RMI) and the Component Object Model (CONI). We then address how these technologies matured into distributed component models, in partiuclar Enterprise Java Beans (EJB) and the CORBA Component Model (CCM). We give an assessment of the maturity of each of these technologies and sketch how they are used to build distributed architectures.
Aspect-Oriented programming (AOP) promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is an important problem. Currently there is almost no su...
详细信息
ISBN:
(纸本)3540442847
Aspect-Oriented programming (AOP) promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is an important problem. Currently there is almost no support for the detection and resolution of such interactions. The programmer is responsible for identifying interactions between conflicting aspects and implementing conflict resolution code. In this paper, we propose a solution to this problem based on a generic framework for AOP. The contributions are threefold: we present a formal and expressive crosscut language, two static conflict analyses and some linguistic support for conflict resolution.
Message passing based on libraries such as MPI is typically used to program parallel machines with distributed memory. This is efficient but error prone. Algorithmic skeletons intend to simplify parallel programming b...
详细信息
ISBN:
(纸本)9781581135992
Message passing based on libraries such as MPI is typically used to program parallel machines with distributed memory. This is efficient but error prone. Algorithmic skeletons intend to simplify parallel programming by increasing the expressive power. The idea is to offer typical parallel programming patterns as polymorphic higher-order functions which are efficiently implemented in parallel. The present paper describes, how C++ templates and operator overloading can be used in order to provide the main features needed for algorithmic skeletons, namely higher-order functions, partial applications, and parametric polymorphism. Experimental results based on a draft implementation of our C++ skeleton library show that the higher expressive power can be gained without a significant performance penalty.
GCspy is an architectural framework for the collection, transmission, storage and replay of memory management behaviour. It makes new contributions to the understanding of the dynamic memory behaviour of programming l...
详细信息
ISBN:
(纸本)9781581134711
GCspy is an architectural framework for the collection, transmission, storage and replay of memory management behaviour. It makes new contributions to the understanding of the dynamic memory behaviour of programminglanguages (and especially object-oriented languages that make heavy demands on the performance of memory managers). GCspy's architecture allows easy incorporation into any memory management system: it is not limited to garbage-collected languages. It requires only small changes to the system in which it is incorporated but provides a simple to use yet powerful data-gathering API. GCspy scales to allow very large heaps to be visualised effectively and efficiently. It allows already-running, local or remote systems to be visualised and those systems to run at full speed outside the points at which data is gathered. GCspy's visualisation tool presents this information in a number of novel ways. Deep understanding of program behaviour is essential to the design of the next generation of garbage collectors and explicit allocators. Until now, no satisfactory tools have been available to assist the implementer in gaining an understanding of heap behaviour. GCspy has been demonstrated to be a practical solution to this dilemma. It has been used to analyse production Java virtual machines running applications of realistic sizes. Its use has revealed important insights into the interaction between application program and JVM and has led to the development of better garbage collectors.
Today's typical computational environment consists of a large numbers of commodity workstations interconnected by high bandwidth networks. However, only a small portion of workstation's capacity is utilized si...
详细信息
Today's typical computational environment consists of a large numbers of commodity workstations interconnected by high bandwidth networks. However, only a small portion of workstation's capacity is utilized since a large share of workstations may idle at any given moment. This paper proposes the general design of a runtime that executes a standard Java application on available idle workstations. This runtime transparently distributes the application's threads and objects among the currently idle nodes.
Separation of Concerns is one of the software engineering design principles that is getting more attention from practitioners and researchers in order to promote design and code reuse. Separation of Concerns (SoC) sep...
详细信息
ISBN:
(纸本)3540442847
Separation of Concerns is one of the software engineering design principles that is getting more attention from practitioners and researchers in order to promote design and code reuse. Separation of Concerns (SoC) separates requirements such as synchronization and scheduling from the core functionality. These requirements are often referred to as crosscutting-concerns. The implementation of such requirements is scattered throughout the system, which results in the code-tangling problem. Aspect Oriented programming provides the user with the ability to modularize, and weave crosscutting-concerns in order to maximize code reusability and solves the code-tangling problem. Weaving is the process of combining crosscutting concerns with the core functionality. Using the UML to model and inter-weave these concerns is a craft that is hard to master due to the lack of formal modeling techniques based on SoC. In this paper we present a formal design methodology to model the system's concerns based on aspect-orientation.
暂无评论