bluuebunny/crossref_metadata_2025 huggingface dataset:
Data collection and analysis techniques for evaluating the perceptual qualities of auditory stimuli
Authors: Bonebright Terri L. , Miner Nadine E. , Goldsmith Timothy E. , Caudell Thomas P.
Published: February 2006

This paper describes a general methodological framework for evaluating the perceptual properties of auditory stimuli. The framework provides analysis techniques that can ensure the effective use of sound for a variety of applications, including virtual reality and data sonification systems. Specifically, we discuss data collection techniques for the perceptual qualities of single auditory stimuli including identification tasks, context-based ratings, and attribute ratings. In addition, we present methods for comparing auditory stimuli, such as discrimination tasks, similarity ratings, and sorting tasks. Finally, we discuss statistical techniques that focus on the perceptual relations among stimuli, such as Multidimensional Scaling (MDS) and Pathfinder Analysis. These methods are presented as a starting point for an organized and systematic approach for nonexperts in perceptual experimental methods, rather than as a complete manual for performing the statistical techniques and data collection methods. It is our hope that this paper will help foster further interdisciplinary collaboration among perceptual researchers, designers, engineers, and others in the development of effective auditory displays.
Authors' comments on Miner and Caudell, ICAD 1997
Authors: Miner Nadine E. , Vergara Victor M. , Panaioti  , Caudell Thomas Preston
Published: February 2006

Sound is a critical component of multimodal representations of information in virtual environments. Our research program continues to develop and evaluate sound software system architectures, localization techniques, sound synthesis, and musical sonification as tools to enhance human comprehension of complex data sets.
Physically based models for liquid sounds
Authors: Doel Kees van den
Published: February 2006

A physically based liquid sound synthesis methodology is developed. The fundamental mechanism for the production of liquid sounds is identified as the acoustic emission of bubbles. After reviewing the physics of vibrating bubbles as it is relevant to audio synthesis, a sound model for isolated single bubbles is developed and validated with a small user study. A stochastic model for the real-time interactive synthesis of complex liquid sounds such as produced by streams, pouring water, rivers, rain, and breaking waves is based on the synthesis of single bubble sounds. It is shown how realistic complex high dimensional sound spaces can be synthesized in this manner.
Crystallization sonification of high-dimensional datasets
Authors: Hermann Thomas , Ritter Helge
Published: February 2006

This paper introduces
Crystallization Sonification
, a sonification model for exploratory analysis of high-dimensional datasets. The model is designed to provide information about the intrinsic data dimensionality (which is a local feature) and the global data dimensionality, as well as the transitions between a local and global view on a dataset. Furthermore the sound allows to display the clustering in high-dimensional datasets. The model defines a crystal growth process in the high-dimensional data-space which starts at a user selected “condensation nucleus” and incrementally includes neighboring data according to some growth criterion. The sound summarizes the temporal evolution of this crystal growth process. For introducing the model, a simple growth law is used. Other growth laws which are used in the context of hierarchical clustering are also suited and their application in crystallization sonification offers new ways to inspect the results of data clustering as an alternative to dendrogram plots. In this paper, the sonification model is described and example sonifications are presented for some synthetic high-dimensional datasets.
Author's comments on Gröhn, Lokki, and Takala, ICAD 2003
Authors: Gröhn Matti , Lokki Tapio , Takala Tapio
Published: February 2006

Historical background and motivation for ICAD2003 paper is presented. In addition, the research results followed up is briefly overviewed and future work is elaborated.
Agile project management
Authors: Augustine Sanjiv , Payne Bob , Sencindiver Fred , Woodcock Susan
Published: February 2006

Agile project management lets software project managers and employees alike adapt to changing circumstances, rather than try to impose rigid formal controls, as in traditional linear development methods.
Does avatar email improve communication?
Authors: Lee Younghwa , Kozar Kenneth A. , Larsen Kai R.
Published: February 2006

Seeking to enhance communication systems by adding expressive cues.
Practical knowledge management tool use in a software consulting company
Authors: Dingsøyr Torgeir , Djarraya Hans Karim , Røyrvik Emil
Published: February 2006

Assessing the contribution of a technical skills management tool for supporting organizational learning.
Pernicious ports
Authors: Berghel Hal , Hoelzer David
Published: February 2006

Identifying and defending against port-related vulnerabilities.
Robots in the desert
Authors: Patterson David A.
Published: February 2006

DARPA's grand challenge spurred advances in the application of AI and, ironically, acted as a referendum on its de-emphasis on academic research.
Introduction
Authors: Singh Rahul , Iyer Lakshmi S. , Salam A. F.
Published: February 2006

Much work is required to understand how the conceptualizations that comprise business processes across the extended enterprise can be captured, represented, shared, and processed by both human and intelligent software agents. This effort will ultimately lead to transparent and secure information and knowledge flows in service and supply chains to increase economic efficiency in the digital economy.
Using the web service modeling ontology to enable semantic e-business
Authors: Bruijn Jos de , Fensel Dieter , Keller Uwe , Lara Rubén
Published: February 2006

The Web infrastructure offers businesses a way to partner and work together, integrating differing applications and communications in a seamless manner.
A semantic approach to monitor business process
Authors: Thomas Manoj , Redmond Richard , Yoon Victoria , Singh Rahul
Published: February 2006

Finding an effective method for managing and evaluating the performance of business processes is a key element for e-business success.
Toward an ontology-driven architectural framework for B2B
Authors: Kajan Ejub , Stoimenov Leonid
Published: February 2006

Moving online business processes and practices from a static collection of data to a distributed multiprocessing framework of interoperability.
Unified activity management
Authors: Moran Thomas P. , Cozzi Alex , Farrell Stephen P.
Published: February 2006

Meshing formal business processes with informal human collaborations is needed to support business activities.
Directions for security and privacy for semantic e-business applications
Authors: Thuraisingham Bhavani
Published: February 2006

Developing secure semantic e-business applications requires focusing first on securing the Semantic Web, knowledge management, and e-business processes.
Model-driven business transformation and the semantic web
Authors: Lee Juhnyoung
Published: February 2006

Coupling business and IT models provides a top-down business perspective.
Time-space lower bounds for satisfiability
Authors: Fortnow Lance , Lipton Richard , van Melkebeek Dieter , Viglas Anastasios
Published: February 2006

We establish the first polynomial time-space lower bounds for satisfiability on general models of computation. We show that for any constant
c
less than the golden ratio there exists a positive constant
d
such that no deterministic random-access Turing machine can solve satisfiability in time
n

c

and space
n

d

, where
d
approaches 1 when
c
does. On conondeterministic instead of deterministic machines, we prove the same for any constant
c
less than √2.Our lower bounds apply to nondeterministic linear time and almost all natural NP-complete problems known. In fact, they even apply to the class of languages that can be solved on a nondeterministic machine in linear time and space
n

1/c

.Our proofs follow the paradigm of indirect diagonalization. We also use that paradigm to prove time-space lower bounds for languages higher up in the polynomial-time hierarchy.
Subexponential parameterized algorithms on bounded-genus graphs and
H
-minor-free graphs
Authors: Demaine Erik D. , Fomin Fedor V. , Hajiaghayi Mohammadtaghi , Thilikos Dimitrios M.
Published: February 2006

We introduce a new framework for designing fixed-parameter algorithms with subexponential running time---2

O(√k)

n

O(1)

. Our results apply to a broad family of graph problems, called
bidimensional problems
, which includes many domination and problems such as vertex cover, feedback vertex set, minimum maximal matching, dominating set, edge dominating set, disk dimension, and many others restricted to bounded-genus graphs (phrased as
bipartite-graph problem
). Furthermore, it is fairly straightforward to prove that a problem is bidimensional. In particular, our framework includes, as special cases, all previously known problems to have such subexponential algorithms. Previously, these algorithms applied to planar graphs, single-crossing-minor-free graphs, and/or map graphs; we extend these results to apply to bounded-genus graphs as well. In a parallel development of combinatorial results, we establish an upper bound on the treewidth (or branchwidth) of a bounded-genus graph that excludes some planar graph
H
as a minor. This bound depends linearly on the size
|V(H)|
of the excluded graph
H
and the genus
g(G)
of the graph
G
, and applies and extends the graph-minors work of Robertson and Seymour.Building on these results, we develop subexponential fixed-parameter algorithms for dominating set, vertex cover, and set cover in any class of graphs excluding a fixed graph
H
as a minor. In particular, this general category of graphs includes planar graphs, bounded-genus graphs, single-crossing-minor-free graphs, and any class of graphs that is closed under taking minors. Specifically, the running time is 2

O(√k)

n

h

, where
h
is a constant depending only on
H
, which is polynomial for
k
=
O
(log
2
n
). We introduce a general approach for developing algorithms on
H
-minor-free graphs, based on structural results about
H
-minor-free graphs at the heart of Robertson and Seymour's graph-minors work. We believe this approach opens the way to further development on problems in
H
-minor-free graphs.
Guests editor's introduction
Authors: Bartolini S. , Foglia P. , Prete C. A.
Published: February 2006

In this issue of ACM SigArch Newsletter, we present eight papers from the MEDEA Workshop, held in conjunction with the International Conference on Parallel Architectures and Compilation Techniques (PACT-2004) [1], [2].
Energy aware memory architecture configuration
Authors: Fradj Hanene Ben , el Ouardighi Asmaa , Belleudy Cécile , Auguin Michel
Published: February 2006

In the context of battery-driven embedded systems, reducing energy while maintaining performance is one of today's challenges. The on-chip memory count for a great part of the whole system consumption, especially for images and video processing applications that make heavy use of large memory data size.In this paper, we present new technique for efficiently exploiting on-chip memory space (cache, scrathpad) for a specific application to reduce the energy consumption without loss of performance. We configure and compare the impact of three different memory architectures on the energy consumption. The first one is composed of main memory with cache, in the second architecture we find a main memory and scratchpad memory and in the last architecture we combine both cache and scratchpad with the main memory. We show the effectiveness of the last architecture and a saving about 35% in energy consumption.
DRACO
Authors: Suh Hyo-Joong , Chung Sung Woo
Published: February 2006

The performances of multiprocessor systems mainly rely on the processor clock speed and the memory latency. As the processors speed up rapidly, the memory latency becomes a major performance bottleneck in multiprocessor systems. In this paper, we propose a dual-link interconnection topology and its effective routing scheme to reduce the remote memory latency on the interconnection network. It can be applied at a same implementation cost as traditional bi-directional ring systems. We compare the performance of the proposed system to that of the traditional bi-directional ring-based system and toroidal mesh-based system. By simulations, it is shown that the proposed system outperforms the traditional bi-directional ring-based system by 42~101 % and excels the toroidal mesh-based system by 4~14%.
Load squared
Authors: Yehia Sami , Collard Jean-Francois , Temam Olivier
Published: February 2006

Indirect memory accesses, where a load is fed by another load, are ubiquitous because of rich data structures and sophisticated software conventions, such as the use of linkage tables and position independent code. Unfortunately, they can be costly: if both loads miss, two round trips to memory are required even though the role of the first load is often limited to fetching the address of the second load. To reduce the total latency of such indirect accesses, a new instruction called load squared is introduced. A load squared does two fetches, the first fetch reading the target address of the second. (An offset is optionally added to the result of the first fetch.) The load squared operation is performed by memory-side logic (typically, the memory controller if it isn't located on the main processor chip). In this study, load squared is not an architecturally visible instruction: the micro-architecture transparently decides which loads should be replaced by loads squared. We show that performance is sometimes improved significantly, and never degraded.
SH-X
Authors: Arakawa F. , Ishikawa M. , Kondo Y. , Kamei T. , Ozawa M. , Nishii O. , Hattori T.
Published: February 2006

A SuperH™ embedded processor core SH-X implemented in a 130-nm CMOS process running at 400 MHz achieved 720 MIPS and 2.8 GFLOPS at a power of 250 mW under worst-case conditions. It has a dual-issue seven-stage pipeline architecture, but reaches the 1.8 MIPS/MHz of the previous five-stage processor. The on-chip memory configuration is tuned for digital consumer appliances. A new resume-standby mode enables a standby current of less than 100, μA and a 3-ms recovery time. The processor meets the requirements of a wide range of applications, and is suitable for digital appliances aimed at the consumer market, such as cellular phones, digital still/video cameras, and car navigation systems.
Improving data cache performance with integrated use of split caches, victim cache and stream buffers
Authors: Naz Afrin , Rezaei Mehran , Kavi Krishna , Sweany Philip
Published: February 2006

In our prior work we explored a cache organization providing architectural support for distinguishing between memory references that exhibit spatial and temporal locality and mapping them to separate caches.That work showed that using separate (data) caches for indexed or stream data and scalar data items could lead to substantial improvements in terms of cache misses. In addition, such a separation allowed for the design of caches that could be tailored to meet the properties exhibited by different data items.In this paper, we investigate the interaction between three established methods: split cache, victim cache and stream buffer. Since significant amounts of compulsory and conflict misses are avoided, the size of each cache (i.e., array and scalar), as well as the combined cache capacity can be reduced. Our results show that on average 55% reduction in miss rates over the base configuration.
Exploiting the replication cache to improve performance for multiple-issue microprocessors
Authors: Allu Bramha , Zhang Wei
Published: February 2006

Performance and reliability are both of great importance for microprocessor design. Recently, the replication cache has been proposed to enhance data cache reliability against soft errors. The replication cache is a small fully associative cache to store the replica for every write to the L1 data cache. In addition to enhance data reliability, this paper proposes several cost-effective techniques to improve performance of multiple-issue microprocessors by exploiting the replication cache. The idea is to make use of the replication cache to increase cache bandwidth through dual load and to reduce the L1 data cache miss rate through partial victim caching. Built upon these two schemes, we also propose a hybrid approach to combine the benefits of both dual load and partial victim caching for improving performance further. Our experimental results show that exploiting a replication cache with only 8 entries can improve performance by 13.0% on average without compromising the enhanced data integrity.
Internet nuggets
Authors: Thorson Mark
Published: February 2006

This column consists of selected traffic from the
comp.arch
newsgroup, a forum for discussion of computer architecture on the Internet---an international computer network.
Globus security model for grid environment
Authors: Kanaskar Nitin V. , Topaloglu Umit , Bayrak Coskun
Published: February 2006

Grid technology is increasingly being looked upon as a natural extension of the internet for engaging in complex data processing tasks over resources which are distributed across the world. Architects and developers employing grid systems must take into consideration security implications. Dynamic generation of virtual organizations leads to a synergistic picture which has to address security requirements never encountered before. Globus toolkit has devised a framework for making secure use of grid resource components which has been proved to be a feasible solution by a number of academic and scientific organizations. This paper is an attempt to identify and discern mechanisms proposed by Globus security model with certain test scenarios.
Software engineering education (SEEd)
Authors: Henderson Peter B.
Published: February 2006

This is my first column using the electronic version only formatting. The
SEEd
column did not appear in the previous issue because I was still trying to figure out the new schedule of six issues per year instead of 4. Interesting how we become creatures of habit, especially as we grow older. So now I have the schedule figured out, but have to decide whether I am going to do six shorter columns a year or stick to 4 longer columns a year, missing one here and there.
Wholesale byte reversal of the outermost Ada record object to achieve endian independence for communicated data types
Authors: Andress Randal P.
Published: February 2006

For years computer engineers have dealt with the problems associated with transfer of binary data between systems of different bit and byte order. Big-Endian (most significant first) vs. Little-Endian (least significant first). In this article, existing techniques are extended to develop a new, systematic method for coding Ada record component representations so that the same declaration may be used to define an input/output object of a communications link (or "flat" file) to achieve complete endian independence. The uniqueness of this approach is that rather than dealing with byte swapping at the lowest level where the fields of the most nested record components are defined, a single, simple byte-swap is done at the outermost level of the multi-field object. This technique works for multi-layered, nested records as well as for records with fields that consume partial, contiguous bytes. It is especially well suited for implementation where endian independence has not been anticipated in the design. The only special case is that of array components which require a simple pre/post fix-up. Some potential pitfalls and compiler issues are discussed.
Dead live longer
Authors: Grein Christoph
Published: February 2006

A large and dark room. In the foreground a terminal, at the rear wall a huge screen showing everything that happens at the terminal. At first the screen is off, the room in twilight. Below the stage, but visible, Lady Ada in a coffin. Around the stage on a gallery, nearly invisible in the dark (also when the stage is lit), the chorus of Ada gurus.
Ada and the control of intrusion
Authors: Levine Gertrude
Published: February 2006

One of the strengths of the Ada Programming Language is its support of software engineering principles. In particular, many Ada constructs assist in the control of various anomalies of computer systems. This paper discusses two classes of anomalies that are shown to have similar characteristics. The first of these classes involves the mutual exclusion problem, for which there exists considerable literature within the Ada community. We compare this category of anomalies to intrusion, a security anomaly, and suggest that mechanisms for the control of the first should be considered for the second.
Reusable software components
Authors: Levine Trudy
Published: February 2006

This column consists of our yearly listing of sources for reusable software components. As always, no recommendation or guarantee by this column is implied.
Ladder queue
Authors: Tang Wai Teng , Goh Rick Siow Mong , Thng Ian Li-Jin
Published: February 2006

This article describes a new priority queue implementation for managing the pending event set in discrete event simulation. Extensive empirical results demonstrate that it consistently outperforms other current popular candidates. This new implementation, called Ladder Queue, is also theoretically justified to have
O
(1) amortized access time complexity, as long as the mean
jump
parameter of the priority increment distribution is finite and greater than zero, regardless of its variance. Many practical priority increment distributions satisfy this condition including unbounded variance distributions like the Pareto distribution. This renders the LadderQ the ideal discrete event queue structure for stable
O
(1) performance even under practical queue distributions with infinite variance. Numerical simulations ranging from 100 to 10 million events affirm the
O
(1) property of LadderQ and that it is a superior structure for large-scale discrete event simulation.
Estimation of internet file-access/modification rates from indirect data
Authors: Matloff Norman
Published: February 2006

Consider an Internet file for which data on last time of access/modification (A/M) of the file are collected at periodic intervals, but for which direct A/M data are not available. Methodology is developed here that enables estimation of the A/M rates, in spite of having only indirect data of this nature. Both parametric and nonparametric methods are developed. Theoretical and empirical analyses are presented that indicate that the problem is indeed statistically tractable, and that the methods developed are of practical value. Behavior of the parametric estimators is examined when these assumptions are violated, and these estimators are found to be robust against some such violations.
Model representation with aesthetic computing
Authors: Fishwick Paul , Davis Timothy , Douglas Jane
Published: February 2006

We define a new methodology,aesthetic computing, for customizing discrete structures found in mathematics, programming, and computer simulation. The methodology is presented as a procedure, defined within the context of the semantic web, involving a successive chain of model transformations from asource modelto atarget model, with the source model being the discrete structure torepresentand the target model being the geometric model. We also present an implementation based on this methodology, and a class where empirical studies were performed to assess student perceptions on how customized model structures affected their understanding and preferences regarding visual and interactive model representations. Students appear to prefer the methodology as a way to inject creativity into model building, and to allow them to explore alternative, analogical representations influenced by the fields of aesthetics and the arts.
Unstructured, but Not Really
Authors: O'Hanlon Charlene
Published: February 2006

Mention the term semi-structured data and chances are you’ll be met with strong opinions from one of two camps: those who believe semi-structured data is nothing more than a fancy term for a data structure left unfinished, and others who firmly believe semi-structured data is the best way to describe data that doesn’t easily fit into the traditional database structure.
Managing Semi-Structured Data
Authors: Florescu Daniela
Published: February 2006

In that class I learned how to build a schema for my information, and I learned that to obtain an accurate schema there must be a priori knowledge of the structure and properties of the information to be modeled. I also learned the ER (entity-relationship) model as a basic tool for all further data modeling, as well as the need for an a priori agreement on both the general structure of the information and the vocabularies used by all communities producing, processing, or consuming this information.
XML
Authors: Sperberg-McQueen C. M.
Published: February 2006

Vocabulary designers can require XML data to be perfectly regular, or they can allow a little variation, or a lot. In the extreme case, an XML vocabulary can effectively say that there are no rules at all beyond those required of all well-formed XML. Because XML syntax records only what is present, not everything that might be present, sparse data does not make the XML representation awkward; XML storage systems are typically built to handle sparse data gracefully.
Why Your Data Won’t Mix
Authors: Halevy Alon
Published: February 2006

When independent parties develop database schemas for the same domain, they will almost always be quite different from each other. These differences are referred to as semantic heterogeneity, which also appears in the presence of multiple XML documents, Web services, and ontologies—or more broadly, whenever there is more than one way to structure a body of data. The presence of semi-structured data exacerbates semantic heterogeneity, because semi-structured schemas are much more flexible to start with. For multiple data systems to cooperate with each other, they must understand each other’s schemas. Without such understanding, the multitude of data sources amounts to a digital version of the Tower of Babel.
The Cost of Data
Authors: Suver Chris
Published: February 2006

In the past few years people have convinced themselves that they have discovered an overlooked form of data. This new form of data is semi-structured. Bosh! There is no new form of data. What folks have discovered is really the effect of economics on data typing—but if you characterize the problem as one of economics, it isn’t nearly as exciting. It is, however, much more accurate and valuable. Seeing the reality of semi-structured data clearly can actually lead to improving data processing. As long as we look at this through the fogged vision of a “new type of data,” however, we will continue to misunderstand the problem and develop misguided solutions to address it. It’s time to change this.
Associated types and constraint propagation for mainstream object-oriented generics
Authors: Järvi Jaakko , Willcock Jeremiah , Lumsdaine Andrew
Published: February 2006

Support for object-oriented programming has become an integral part of mainstream languages, and more recently generic programming has gained widespread acceptance as well. A natural question is how these two paradigms, and their underlying language mechanisms, should interact. One particular design option, that of using subtyping to constrain the type parameters of generic functions, has been chosen in the generics of Java and those planned for a future revision of C#.Certain shortcomings have previously been identified in using subtyping for constraining parametric polymorphism in the context of generic programming.To address these, we propose extending object-oriented interfaces and subtyping to include associated types and constraint propagation.Associated types are type members of interfaces and classes. Constraint propagation allows certain constraints on type parameters to be inferred from other constraints on those parameters and their use in base class type expressions.The paper demonstrates these extensions in the context of C# (with generics), describes a translation of the extended features to C#, and presents a formalism proving their safety. The formalism is applicable to other mainstream object-oriented languages supporting F-bounded polymorphism, such as Java.
Generalized algebraic data types and object-oriented programming
Authors: Kennedy Andrew , Russo Claudio V.
Published: February 2006

Generalized algebraic data types (GADTs) have received much attention recently in the functional programming community. They generalize the (type) parameterized algebraic datatypes (PADTs) of ML and Haskell by permitting value constructors to return specific, rather than parametric, type-instantiations of their own datatype. GADTs have a number of applications, including strongly-typed evaluators, generic pretty-printing, generic traversals and queries, and typed LR parsing. We show that existing object-oriented programming languages such as Java and C# can express GADT definitions, and a large class of GADT-manipulating programs, through the use of generics, subclassing, and virtual dispatch. However, some programs can be written only through the use of redundant runtime casts. Moreover, instantiation-specific, yet safe, operations on ordinary PADTs only admit indirect cast-free implementations, via higher-order encodings. We propose a generalization of the type constraint mechanisms of C# and Java to both avoid the need for casts in GADT programs and higher-order contortions in PADT programs; we present a Visitor pattern for GADTs, and describe a refined switch construct as an alternative to virtual dispatch on datatypes. We formalize both extensions and prove type soundness.
Micro patterns in Java code
Authors: Gil Joseph (Yossi) , Maman Itay
Published: February 2006

Micro patterns are similar to
design patterns
, except that micro patterns are stand at a lower, closer to the implementation, level of abstraction. Micro patterns are also unique in that they are mechanically recognizable, since each such pattern can be expressed as a formal condition on the structure of a class.This paper presents a catalog of 27 micro-patterns defined on Java classes and interfaces. The catalog captures a wide spectrum of common programming practices, including a particular and (intentionally restricted) use of inheritance, immutability, data management and wrapping, restricted creation, and emulation of procedural-, modular-, and even functional- programming paradigms with object oriented constructs. Together, the patterns present a set of prototypes after which a large portion of all Java classes and interfaces are modeled. We provide empirical indication that this portion is as high as 75%.A statistical analysis of occurrences of micro patterns in a large software corpus, spanning some 70,000 Java classes drawn from a rich set of application domains, shows, with high confidence level that the use of these patterns is not random. These results indicate consciousness and discernible design decisions, which are sustained in the software evolution. With high confidence level, we can also show that the use of these patterns is tied to the specification, or the purpose, that the software realizes.The
traceability
,
abundance
and the
statistical significance
of micro pattern occurrence raise the hope of using the classification of software into these patterns for a more founded appreciation of its design and code quality.
Modeling architectural patterns using architectural primitives
Authors: Zdun Uwe , Avgeriou Paris
Published: February 2006

Architectural patterns are a key point in architectural documentation. Regrettably, there is poor support for modeling architectural patterns, because the pattern elements are not directly matched by elements in modeling languages, and, at the same time, patterns support an inherent variability that is hard to model using a single modeling solution. This paper proposes tackling this problem by finding and representing architectural primitives, as the participants in the solutions that patterns convey. In particular, we examine a number of architectural patterns to discover those primitive abstractions that are common among the patterns, and at the same time demonstrate a degree of variability in each pattern. These abstractions belong in the components and connectors architectural view, though more abstractions can be found in other views. We have selected UML 2 as the language for representing these primitive abstractions as extensions of the standard UML elements. The added value of this approach is twofold: it proposes a generic and extensible approach for modeling architectural patterns by means of architectural primitives; it demonstrates an initial set of primitives that participate in several well-known architectural patterns.
Parametric polymorphism for software component architectures
Authors: Oancea Cosmin E. , Watt Stephen M.
Published: February 2006

Parametric polymorphism has become a common feature of mainstream programming languages, but software component architectures have lagged behind and do not support it. We examine the problem of providing parametric polymorphism with components combined from different programming languages. We have investigated how to resolve different binding times and parametrization semantics in a range of representative languages and have identified a common ground that can be suitably mapped to different language bindings. We present a generic component architecture extension that provides support for parameterized components and that can be easily adapted to work on top of various software component architectures in use today (e.g.,
corba
,
dcom
,
jni
). We have implemented and tested this architecture on top of
corba
. We also present

Generic Interface Definition Language (
gidl
)

, an extension to
corba
-
idl
supporting generic types and we describe language bindings for C++, Java and Aldor. We explain our implementation of
gidl
, consisting of a
gidl
to
idl
compiler and tools for generating linkage code under the language bindings. We demonstrate how this architecture can be used to access C++'s
stl
and Aldor's BasicMath libraries in a multi-language environment and discuss our mappings in the context of automatic library interface generation.
Interaction-based programming with classages
Authors: Liu Yu David , Smith Scott F.
Published: February 2006

This paper presents
Classages
, a novel interaction-centric object-oriented language. Classes and objects in
Classages
are fully encapsulated, with explicit interfaces for all interactions they might be involved in. The design of
Classages
touches upon a wide range of language design topics, including encapsulation, object relationship representation, and object confinement. An encoding of Java's OO model in
Classages
is provided, showing how standard paradigms are supported. A prototype
Classages
compiler is described.
Javari
Authors: Tschantz Matthew S. , Ernst Michael D.
Published: February 2006

This paper describes a type system that is capable of expressing and enforcing immutability constraints. The specific constraint expressed is that the abstract state of the object to which an immutable reference refers cannot be modified using that reference. The abstract state is (part of) the transitively reachable state: that is, the state of the object and all state reachable from it by following references. The type system permits explicitly excluding fields from the abstract state of an object. For a statically type-safe language, the type system guarantees reference immutability. If the language is extended with immutability downcasts, then run-time checks enforce the reference immutability constraints.This research builds upon previous research in language support for reference immutability. Improvements that are new in this paper include distinguishing the notions of assignability and mutability; integration with Java 5's generic types and with multi-dimensional arrays; a mutability polymorphism approach to avoiding code duplication; type-safe support for reflection and serialization; and formal type rules and type soundness proof for a core calculus. Furthermore, it retains the valuable features of the previous dialect, including usability by humans (as evidenced by experience with 160,000 lines of Javari code) and interoperability with Java and existing JVMs.
Pluggable AOP
Authors: Kojarski Sergei , Lorenz David H.
Published: February 2006

Studies of Aspect-Oriented Programming (AOP) usually focus on a language in which a specific aspect extension is integrated with a base language. Languages specified in this manner have a fixed, non-extensible AOP functionality. This paper argues the need for AOP to support the integration and use of multiple domain-specific aspect extensions together. We study the more general case of integrating a base language with a set of third-party aspect extensions for that language. We present a general mixin-based semantic framework for implementing dynamic aspect extensions in such a way that multiple, independently developed aspect mechanisms can be subject to third-party composition and work collaboratively. Principles governing the design of a collaborative aspect mechanism are aspectual effect exposure and implementation hiding.
Refactoring support for class library migration
Authors: Balaban Ittai , Tip Frank , Fuhrer Robert
Published: February 2006

As object-oriented class libraries evolve, classes are occasionally deprecated in favor of others with roughly the same functionality. In Java's standard libraries, for example, class Hashtable has been superseded by HashMap, and Iterator is now preferred over Enumeration. Migrating client applications to use the new idioms is often desirable, but making the required changes to declarations and allocation sites can be quite labor-intensive. Moreover, migration becomes complicated---and sometimes impossible---if an application interacts with external components, if a legacy class is not completely equivalent to its replacement, or if multiple interdependent classes must be migrated simultaneously. We present an approach in which mappings between legacy classes and their replacements are specified by the programmer. Then, an analysis based on
type constraints
determines where declarations and allocation sites can be updated. The method was implemented in Eclipse, and evaluated on a number of Java applications. On average, our tool could migrate more than 90% of the references to legacy classes.
Automating vertical profiling
Authors: Hauswirth Matthias , Diwan Amer , Sweeney Peter F. , Mozer Michael C.
Published: February 2006

Last year at OOPSLA we presented a methodology,
vertical profiling
, for understanding the performance of object-oriented programs. The key insight behind this methodology is that modern programs run on top of many layers (virtual machine, middleware, etc) and thus we need to collect and combine information from all layers in order to understand system performance. Although our methodology was able to explain previously unexplained performance phenomena, it was extremely labor intensive. In this paper we describe and evaluate techniques for automating two significant activities of vertical profiling: trace alignment and correlation. Trace alignment aligns traces obtained from separate runs so that one can reason across the traces. We are not aware of any prior approach that effectively and automatically aligns traces. Correlation sifts through hundreds of metrics to find ones that have a bearing on a performance anomaly of interest. In prior work we found that statistical correlation was only sometimes effective. We have identified highly-effective approaches for both activities.For aligning traces we explore dynamic time warping, and for correlation we explore eight correlators based on statistical correlation, distance measures, and piecewise linear segmentation. Although we explore these activities in the context of vertical profiling, both activities are widely applicable in the performance analysis area.
Improving virtual machine performance using a cross-run profile repository
Authors: Arnold Matthew , Welc Adam , Rajan V. T.
Published: February 2006

Virtual machines for languages such as the Java programming language make extensive use of online profiling and dynamic optimization to improve program performance. But despite the important role that profiling plays in achieving high performance, current virtual machines discard a program's profile data at the end of execution, wasting the opportunity to use past knowledge to improve future performance. In this paper, we present a fully automated architecture for exploiting cross-run profile data in virtual machines. Our work addresses a number of challenges that previously limited the practicality of such an approach.We apply this architecture to address the problem of
selective optimization
, and describe our implementation in IBM's J9 Java virtual machine. Our results demonstrate substantial performance improvements on a broad suite of Java programs, with the average performance ranging from 8.8% -- 16.6% depending on the execution scenario.
Quantifying the performance of garbage collection vs. explicit memory management
Authors: Hertz Matthew , Berger Emery D.
Published: February 2006

Garbage collection yields numerous software engineering benefits, but its quantitative impact on performance remains elusive. One can compare the cost of
conservative
garbage collection to explicit memory management in C/C++ programs by linking in an appropriate collector. This kind of direct comparison is not possible for languages designed for garbage collection (e.g., Java), because programs in these languages naturally do not contain calls to free. Thus, the actual gap between the time and space performance of explicit memory management and
precise
, copying garbage collection remains unknown.We introduce a novel experimental methodology that lets us quantify the performance of precise garbage collection versus explicit memory management. Our system allows us to treat unaltered Java programs as if they used explicit memory management by relying on oracles to insert calls to free. These oracles are generated from profile information gathered in earlier application runs. By executing inside an architecturally-detailed simulator, this "oracular" memory manager eliminates the effects of consulting an oracle while measuring the costs of calling malloc and free. We evaluate two different oracles: a liveness-based oracle that aggressively frees objects immediately after their last use, and a reachability-based oracle that conservatively frees objects just after they are last reachable. These oracles span the range of possible placement of explicit deallocation calls.We compare explicit memory management to both copying and non-copying garbage collectors across a range of benchmarks using the oracular memory manager, and present real (non-simulated) runs that lend further validity to our results. These results quantify the time-space tradeoff of garbage collection: with five times as much memory, an Appel-style generational collector with a non-copying mature space matches the performance of reachability-based explicit memory management. With only three times as much memory, the collector runs on average 17% slower than explicit memory management. However, with only twice as much memory, garbage collection degrades performance by nearly 70%. When physical memory is scarce, paging causes garbage collection to run an order of magnitude slower than explicit memory management.
Runtime specialization with optimistic heap analysis
Authors: Shankar Ajeet , Sastry S. Subramanya , Bodík Rastislav , Smith James E.
Published: February 2006

We describe a highly practical program specializer for Java programs. The specializer is powerful, because it specializes optimistically, using (potentially transient) constants in the heap; it is precise, because it specializes using data structures that are only partially invariant; it is deployable, because it is hidden in a JIT compiler and does not require any user annotations or offline preprocessing; it is simple, because it uses existing JIT compiler ingredients; and it is fast, because it specializes programs in under 1s.These properties are the result of (1) a new algorithm for selecting specializable code fragments, based on a notion of influence; (2) a precise store profile for identifying constant heap locations; and (3) an efficient invalidation mechanism for monitoring optimistic assumptions about heap constants. Our implementation of the specializer in the Jikes RVM has low overhead, selects specialization points that would be chosen manually, and produces speedups ranging from a factor of 1.2 to 6.4, comparable with annotation-guided specializers.
Finding application errors and security flaws using PQL
Authors: Martin Michael , Livshits Benjamin , Lam Monica S.
Published: February 2006

A number of effective error detection tools have been built in recent years to check if a program conforms to certain design rules. An important class of design rules deals with sequences of events asso-ciated with a set of related objects. This paper presents a language called PQL (Program Query Language) that allows programmers to express such questions easily in an application-specific context. A query looks like a code excerpt corresponding to the shortest amount of code that would violate a design rule. Details of the tar-get application's precise implementation are abstracted away. The programmer may also specify actions to perform when a match is found, such as recording relevant information or even correcting an erroneous execution on the fly.We have developed both static and dynamic techniques to find solutions to PQL queries. Our static analyzer finds all potential matches conservatively using a context-sensitive, flow-insensitive, inclusion-based pointer alias analysis. Static results are also use-ful in reducing the number of instrumentation points for dynamic analysis. Our dynamic analyzer instruments the source program to catch all violations precisely as the program runs and to optionally perform user-specified actions.We have implemented the techniques described in this paper and found 206 errors in 6 large real-world open-source Java applica-tions containing a total of nearly 60,000 classes. These errors are important security flaws, resource leaks, and violations of consis-tency invariants. The combination of static and dynamic analysis proves effective at addressing a wide range of debugging and pro-gram comprehension queries. We have found that dynamic analysis is especially suitable for preventing errors such as security vulner-abilities at runtime.
Formalising Java RMI with explicit code mobility
Authors: Ahern Alexander , Yoshida Nobuko
Published: February 2006

This paper presents a Java-like core language with primitives for object-oriented distribution and explicit code mobility. We apply our formulation to prove the correctness of several optimisations for distributed programs. Our language captures crucial but often hidden aspects of distributed object-oriented programming, including object serialisation, dynamic class downloading and remote method invocation. It is defined in terms of an operational semantics that concisely models the behaviour of distributed programs using machinery from calculi of mobile processes. Type safety is established using invariant properties for distributed runtime configurations. We argue that primitives for explicit code mobility offer a programmer fine-grained control of type-safe code distribution, which is crucial for improving the performance and safety of distributed object-oriented applications.