bluuebunny/crossref_metadata_2025 huggingface dataset:
Sampling for zero-time hexazinone residues in forest soil dissipation study
Authors: Feng Joseph C. , Navratil Stan
Published: November 2007

A new soil sampling method using glass jars to measure zero-time herbicide residues was compared with a conventional method using a soil corer under forest conditions in northern Alberta. A liquid formulation of hexazinone was diluted 20 times with water and applied with a four-nozzle overhead backpack sprayer. Use of the glass jar method resulted in 5 times more efficient recovery of hexazinone residues from soils (3.8 kg/ha) than the conventional corer method (0.8 kg/ha) at zero time. The corer method should be used following soil penetration of residues. Subsurface (0–30 cm) hexazinone levels sampled by this method were determined to be 2.0 and 0.35 kg/ha, respectively, 210 and 360 days after application. The combined use of glass jars for zero time and the soil corer for subsequent samplings produced the best result in estimating the dissipation rate of hexazinone in forest soils. Because of the late application in the fall and frozen ground in winter, the dissipation time for 50% of hexazinone was 206 days.
Fire history on a desert mountain range: Rincon Mountain Wilderness, Arizona, U.S.A.
Authors: Baisan Christopher H. , Swetnam Thomas W.
Published: November 2007

Modern fire records and fire-scarred remnant material collected from logs, snags, and stumps were used to reconstruct and analyze fire history in the mixed-conifer and pine forest above 2300 m within the Rincon Mountain Wilderness of Saguaro National Monument, Arizona, United States. Cross-dating of the remnant material allowed dating of fire events to the calendar year. Estimates of seasonal occurrence were compiled for larger fires. It was determined that the fire regime was dominated by large scale (> 200 ha), early-season (May–July) surface fires. The mean fire interval over the Mica Mountain study area for the period 1657–1893 was 6.1 years with a range of 1–13 years for larger fires. The mean fire interval for the mixed-conifer forest type (1748–1886) was 9.9 years with a range of 3–19 years. Thirty-five major fire years between 1700 and 1900 were compared with a tree-ring reconstruction of the Palmer drought severity index (PDSI). Mean July PDSI for 2 years prior to fires was higher (wetter) than average, while mean fire year PDSI was near average. This 490-year record of fire occurrence demonstrates the value of high-resolution (annual and seasonal) tree-ring analyses for documenting and interpreting temporal and spatial patterns of past fire regimes.
Accelerated aging of Quercusnigra seed: biochemical changes and applicability as a vigor test
Authors: Blanche C. A. , Elam W. W. , Hodges J. D.
Published: November 2007

A decline in germination capacity (vigor) of Quercusnigra L. (water oak) seed lots within 108 h was observed when seeds were aged at 41 °C and 100% relative humidity. Aging for less than 108 h increased germination rate. Seed moisture and amino nitrogen contents increased with period of aging, whereas starch content gradually declined. There was no definitive pattern of change in the contents of reducing and nonreducing sugars. These changes reflected an overall elevated metabolism that resulted in an increased rate of utilization of seed energy reserve and a consequent decline in seed vigor.
An unusual case of winter bud damage in British Columbia interior conifers
Authors: Kamp Bart J. van der , Worrall John
Published: November 2007

A widespread and unusual form of damage was suffered by most buds above the putative 1988–1989 winter snow line on Douglas-fir (Pseudotsugamenziesii (Mirb.) Franco), Engelmann and white spruces (Piceaengelmannii Parry and P. glauca (Moench) Voss, respectively) and their hybrids, and subalpine and amabilis firs (Abieslasiocarpa (Hook.) Nutt. and A. amabilis (Dougl.) Forbes, respectively). By mid-June, on trees less than 30 years old, all tissues above the innermost bud scales, including the dome of the apical meristem, were dead, and a whorl of embryonic shoots arising from bud scale axils was developing. These shoots either produced a bud or developed into short stem segments during the 1989 growing season. The probable cause of the phenomenon was a warmer (1.0 to 3.6 °C above normal) October to December, and a very warm (2.9 to 4.7 °C above normal) January followed by a sudden cold snap with temperatures falling to −30 °C in early February.
Expected efficiencies of mating designs for advanced-generation selection
Authors: Buijtenen J. P. van , Burdon R. D.
Published: November 2007

Expected efficiencies of regular hierarchical, factorial, and diallel crossing designs were compared for selection of individual offspring within progeny plantings. Variations of the diallels and factorials included partial designs, use of disconnected subsets, and in factorials, unbalanced numbers between classes of parent. Calculations were done for a single trait, adapting the within- and between-family selection index of Osborne, with fixed numbers of parents (100) and total offspring (10 000). For each design type, variable numbers of crosses per parent and variable genetic parameters (heritability and level of specific combining ability) were considered. A combination of polycross and pair-cross designs was also evaluated, with alternative assumptions concerning nongenetic variance within pair-cross plantings and the number of trees that could be planted per pair cross with fixed resources. Estimated efficiencies of different designs are considered in relation to total crosses per parent, with an illustration of the contribution of different effects. Hierarchical crosses were generally inefficient, except near the limiting case of single-pair crosses; though with large specific combining ability effects, there was an efficiency optimum with several females (common parents) per male (rare parents). Polycrosses were always markedly suboptimal. Among other types of designs, efficiencies were almost identical, except with only a few crosses per parent. In that case, partial designs tended to be marginally less efficient than complete ones and diallels were marginally behind factorials. Disconnection had very little effect, provided sets could be cross-referenced. Moderate imbalance in factorials had little impact on the expected additive genetic gain. Single-pair crosses showed a slight but definite optimum, unless specific combining ability was appreciable. The combination of designs was favored by relatively large specific combining ability effects, high heritability, and cost reductions per tree in planting unreplicated pair-cross family blocks. It is potentially efficient.
Expected efficiencies of mating designs for reselection of parents
Authors: Burdon R. D. , Buijtenen J. P. van
Published: November 2007

Expected efficiencies, in terms of genetic gain from reselection of parents (backwards selection), were compared for hierarchical mating, factorial, partial factorial, modified half diallel, and partial diallel crossing designs and polycrosses; this was done in parallel with a separate study of expected efficiencies for advanced-generation (forwards) selection, assuming a fixed-resources model of 100 parents and 10 000 offspring. The present study considered a single-trait case, with variable numbers of crosses per parent, varying heritability (h2) levels (h2 = 0.1, 0.2, and 0.5), and varying ratios of specific combining ability to general combining ability variance (0, 0.5, and 1). Compared with the case of forwards selection, the relative efficiencies of the different designs were generally similar. Two notable exceptions were the comparative inefficiency of small, disconnected factorial sets for backwards selection and the generally high (but not always maximal) efficiency of polycrosses for this purpose.
Encapsulating objects with confined types
Authors: Grothoff Christian , Palsberg Jens , Vitek Jan
Published: November 2007

Object-oriented languages provide little support for encapsulating objects. Reference semantics allows objects to escape their defining scope, and the pervasive aliasing that ensues remains a major source of software defects. This paper presents Kacheck/J, a tool for inferring object encapsulation properties of large Java programs. Our goal is to develop practical tools to assist software engineers, thus we focus on simple and scalable techniques. Kacheck/J is able to infer
confinement
—the property that all instances of a given type are encapsulated in their defining package. This simple property can be used to identify accidental leaks of sensitive objects, as well as for compiler optimizations. We report on the analysis of a large body of code and discuss language support and refactoring for confinement.
The embedded machine
Authors: Henzinger Thomas A. , Kirsch Christoph M.
Published: November 2007

The Embedded Machine is a virtual machine that mediates in real time the interaction between software processes and physical processes. It separates the compilation of embedded programs into two phases. The first phase, the platform-independent compiler phase, generates E code (code executed by the Embedded Machine), which supervises the timing, not the scheduling of, application tasks relative to external events such as clock ticks and sensor interrupts. E code is portable and, given an input behavior, exhibits predictable (i.e., deterministic) timing and output behavior. The second phase, the platform-dependent compiler phase, checks the
time safety
of the E code, that is, whether platform performance (determined by the hardware) and platform utilization (determined by the scheduler of the operating system) enable its timely execution. We have used the Embedded Machine to compile and execute high-performance control applications written in Giotto, such as the flight control system of an autonomous model helicopter.
Goal-directed weakening of abstract interpretation results
Authors: Seo Sunae , Yang Hongseok , Yi Kwangkeun , Han Taisook
Published: November 2007

One proposal for automatic construction of proofs about programs is to combine Hoare logic and abstract interpretation. Constructing proofs is in Hoare logic. Discovering programs' invariants is done by abstract interpreters.

One problem of this approach is that abstract interpreters often compute invariants that are not needed for the proof goal. The reason is that the abstract interpreter does not know what the proof goal is, so it simply tries to find as strong invariants as possible. These unnecessary invariants increase the size of the constructed proofs. Unless the proof-construction phase is notified which invariants are not needed, it blindly proves all the computed invariants.

In this article, we present a framework for designing algorithms, called
abstract-value slicers
, that slice out unnecessary invariants from the results of forward abstract interpretation. The framework provides a generic abstract-value slicer that can be instantiated into a slicer for a particular abstract interpretation. Such an instantiated abstract-value slicer works as a post-processor to an abstract interpretation in the whole proof-construction process, and notifies to the next proof-construction phase which invariants it does not have to prove. Using the framework, we designed an abstract-value slicer for an existing relational analysis and applied it on programs. In this experiment, the slicer identified 62%--81% of the computed invariants as unnecessary, and resulted in 52%--84% reduction in the size of constructed proofs.
A five-year study of file-system metadata
Authors: Agrawal Nitin , Bolosky William J. , Douceur John R. , Lorch Jacob R.
Published: November 2007

For five years, we collected annual snapshots of file-system metadata from over 60,000 Windows PC file systems in a large corporation. In this article, we use these snapshots to study temporal changes in file size, file age, file-type frequency, directory size, namespace structure, file-system population, storage capacity and consumption, and degree of file modification. We present a generative model that explains the namespace structure and the distribution of directory sizes. We find significant temporal trends relating to the popularity of certain file types, the origin of file content, the way the namespace is used, and the degree of variation among file systems, as well as more pedestrian changes in size and capacities. We give examples of consequent lessons for designers of file systems and related software.
A framework for precomputed and captured light transport
Authors: Lehtinen Jaakko
Published: November 2007

Several types of methods precompute or capture light transport operators in either virtual or real scenes. Precomputed radiance transfer methods interactively render realistic images of static scenes under dynamic incident illumination, while reflectance field techniques capture an appearance model of a real scene for relighting purposes. In this article we present a unifying mathematical framework for methods that precompute or capture light transport operators, and characterize a large body of earlier work in its terms. The framework is given in the form of an operator equation that extends the rendering equation to account for a constrained space of emissions. The connections between traditional global illumination methods and precomputed transfer techniques become apparent through the explicit equation. Based on insight provided by the unifying view, we outline possibilities for new methods, particularly the wider adaptation of previous, hierarchical finite element techniques for efficient computation of the transport operators.
Out-of-core and compressed level set methods
Authors: Nielsen Michael B. , Nilsson Ola , Söderström Andreas , Museth Ken
Published: November 2007

This article presents a generic framework for the representation and deformation of level set surfaces at extreme resolutions. The framework is composed of two modules that each utilize optimized and application specific algorithms: 1) A fastout-of-coredata management scheme that allows for resolutions of the deforming geometry limited only by the available disk space as opposed to memory, and 2) compact and fastcompressionstrategies that reduce both offline storage requirements and online memory footprints during simulation. Out-of-core and compression techniques have been applied to a wide range of computer graphics problems in recent years, but this article is the first to apply it in the context of level set and fluidsimulations. Our framework is generic and flexible in the sense that the two modules can transparently be integrated, separately or in any combination, into existing level set and fluid simulation software based on recently proposed narrow band data structures like the DT-Grid of Nielsen and Museth [2006] and the H-RLE of Houston et al [2006]. The framework can be applied to narrow band signed distances, fluid velocities, scalar fields, particle properties as well as standard graphics attributes like colors, texture coordinates, normals, displacements etc. In fact, our framework is applicable to a large body of computer graphics problems that involve sequential or random access to very large co-dimension one (level set) and zero (e.g. fluid) data sets. We demonstrate this with several applications, including fluid simulations interacting with large boundaries (≈ 15003), surface deformations (≈ 20483), the solution of partial differential equations on large surfaces (≈ 40963) and mesh-to-level set scan conversions of resolutions up to ≈ 350003(7 billion voxels in the narrow band). Our out-of-core framework is shown to be several times faster than current state-of-the-art level set data structures relying on OS paging. In particular we show sustained throughput (grid points/sec) for gigabyte sized level sets as high as 65% of state-of-the-art throughput for in-core simulations. We also demonstrate that our compression techniques out-perform state-of-the-art compression algorithms for narrow bands.
Evaluating motion graphs for character animation
Authors: Reitsma Paul S. A. , Pollard Nancy S.
Published: November 2007

Realistic and directable humanlike characters are an ongoing goal in animation. Motion graph data structures hold much promise for achieving this goal; however, the quality of the results obtainable from a motion graph may not be easy to predict from its input motion clips. This article describes a method for using task-based metrics to evaluate the capability of a motion graph to create the set of animations required by a particular application. We examine this capability for typical motion graphs across a range of tasks and environments. We find that motion graph capability degrades rapidly with increases in the complexity of the target environment or required tasks, and that addressing deficiencies in a brute-force manner tends to lead to large, unwieldy motion graphs. The results of this method can be used to evaluate the extent to which a motion graph will fulfill the requirements of a particular application, lessening the risk of the data structure performing poorly at an inopportune moment. The method can also be used to characterize the deficiencies of motion graphs whose performance will not be sufficient, and to evaluate the relative effectiveness of different options for improving those motion graphs.
Knowledge and heuristic-based modeling of laser-scanned trees
Authors: Xu Hui , Gossett Nathan , Chen Baoquan
Published: November 2007

We present a semi-automatic and efficient method for producing full polygonal models of range scanned trees, which are initially represented as sparse point clouds. First, a skeleton of the trunk and main branches of the tree is produced based on the scanned point clouds. Due to the unavoidable incompleteness of the point clouds produced by range scans of trees, steps are taken to synthesize additional branches to produce plausible support for the tree crown. Appropriate dimensions for each branch section are estimated using allometric theory. Using this information, a mesh is produced around the full skeleton. Finally, leaves are positioned, oriented and connected to nearby branches. Our process requires only minimal user interaction, and the full process including scanning and modeling can be completed within minutes.
Probabilistic calling context
Authors: Bond Michael D. , McKinley Kathryn S.
Published: November 2007

Calling context
enhances program understanding and dynamic analyses by providing a rich representation of program location. Compared to imperative programs, object-oriented programs use more interprocedural and less intraprocedural control flow, increasing the importance of context sensitivity for analysis. However, prior online methods for computing calling context, such as stack-walking or maintaining the current location in a calling context tree, are expensive in time and space. This paper introduces a new online approach called
probabilistic calling context
(PCC) that continuously maintains a probabilistically unique value representing the current calling context. For millions of unique contexts, a 32-bit PCC value has few conflicts. Computing the PCC value adds 3% average overhead to a Java virtual machine. PCC is well-suited to clients that detect new or anomalous behavior since PCC values from training and production runs can be compared easily to detect new context-sensitive behavior; clients that query the PCC value at every system call, Java utility call, and Java API call add 0-9% overhead on average. PCC adds space overhead proportional to the distinct contexts stored by the client (one word per context). Our results indicate PCC is efficient and accurate enough to use in deployed software for residual testing, bug detection, and intrusion detection.
Variant path types for scalable extensibility
Authors: Igarashi Atsushi , Viroli Mirko
Published: November 2007

Much recent work in the design of object-oriented programming languages has been focusing on identifying suitable features to support so-called
scalable extensibility
, where the usual extension mechanism by inheritance works in different scales of software components-that is, classes, groups of classes, groups of groups and so on. Its typing issues has usually been addressed by means of dependent type systems, where nested types are seen as properties of objects. In this work, we seek instead for a different solution, which can bemore easily applied to Java-like languages, in which nested types are considered properties of classe.

We introduce the mechanism of
variant path types
, which provide a flexible means to express intra-group relationship (among classes) that has to be preserved through extension. In particular, improving and extending existing works on groups and exact types, we feature the new notions of
exact
and
inexact qualifications
, providing rich abstractions to express various kinds of set of objects, with a flexible subtyping scheme. We formalize a safe type system for variant path types on top of Feather weight Java. Our development results in a complete solution for scalable extensibility, similarly to previous attempts based on dependent type systems.
Transactions with isolation and cooperation
Authors: Smaragdakis Yannis , Kay Anthony , Behrends Reimer , Young Michal
Published: November 2007

We present the TIC (Transactions with Isolation and Cooperation) model for concurrent programming. TIC adds to standard transactional memory the ability for a transaction to observe the effects of other threads at selected points. This allows transactions to cooperate, as well as to invoke nonrepeatable or irreversible operations, such as I/O. Cooperating transactions run the danger of exposing intermediate state and of having other threads change the transaction's state. The TIC model protects against unanticipated interference by having the type system keep track of all operations that may (transitively) violate the atomicity of a transaction and require the programmer to establish consistency at appropriate points. The result is a programming model that is both general and simple. We have used the TIC model to re-engineer existing lock-based applications including a substantial multi-threaded web mail server and a memory allocator with coarse-grained locking. Our experience confirms the features of the TIC model: It is convenient for the programmer, while maintaining the benefits of transactional memory.
Can programming be liberated from the two-level style
Authors: Kühne Thomas , Schreiber Daniel
Published: November 2007

Since the introduction of object-oriented programming few programming languages have attempted to provide programmers with more than objects and classes, i.e., more than two levels. Those that did, almost exclusively aimed at describing language properties-i.e., their metaclasses exert linguistic control on language concepts and mechanisms-often in order to make the language extensible. In terms of supporting logical domain classification levels, however, they are still limited to two levels.

In this paper we conservatively extend the object-oriented programming paradigm to feature an unbounded number of domain classification levels. We can therefore avoid the introduction of accidental complexity into programs caused by accommodating multiple domain levels within only two programming levels. We present a corresponding language design featuring ``deep instantiation'' and demonstrate its features with a running example. Finally, we outline the implementation of our compiler prototype and discuss the potentials of further developing our language design.
Notation and representation in collaborative object-oriented design
Authors: Dekel Uri , Herbsleb James D.
Published: November 2007

Software designers in the object-oriented paradigm can make use of modeling tools and standard notations such as UML. Nevertheless, casual observations from collocated design collaborations suggest that teams tend to use physical mediums to sketch a plethora of informal diagrams in varied representations that often diverge from UML. To better understand such collaborations and support them with tools, we need to understand the origins, roles, uses, and implications of these alternate representations. To this end we conducted observational studies of collaborative design exercises, in which we focused on representation use.

Our primary finding is that teams intentionally improviserepresentations and organize design information in responseto ad-hoc needs, which arise from the evolution of the design, and which are difficult to meet with fixed standard notations. This behavior incurs orientation and grounding difficulties for which teams compensate by relying on memory, other communication mediums, and contextual cues. Without this additional information the artifacts are difficult to interpret and have limited documentation potential. Collaborative design tools and processes should therefore focus on preserving contextual information while permitting unconstrained mixing and improvising of notations.
Webrb
Authors: Leff Avraham , Rayfield James T.
Published: November 2007

Many web-applications can be characterized as "relational". In this paper we introduce and evaluate
WebRB
, a visualdomain-specific language for building such applications.
WebRB
addresses the limitations of the conventional "imperative-embedding" approach typically used to build relational web-applications. We describe the
WebRB
language, present extended examples of its use, and discuss the
WebRB
visual editor, libraries, and runtime. We then evaluate
WebRB
by comparing it to alternative approaches, and demonstrate its effectiveness in building relational web-applications.
Modular verification of higher-order methods with mandatory calls specified by model programs
Authors: Shaner Steve M. , Leavens Gary T. , Naumann David A.
Published: November 2007

What we call a''higher-order method" (HOM) is a method that makes mandatory calls to other dynamically-dispatched methods. Examples include template methods as in the Template method design pattern and notify methods in the Observer pattern. HOMs are particularly difficult to reason about, because standard pre- and postcondition specifications cannot describe the mandatory calls. For reasoning about such methods, existing approaches use either higher order logic or traces, but both are complex and verbose.

We describe a simple, concise, and modular approach to specifying HOMs We show how to verify calls to HOMs and their code using first-order verification conditions, in asound and modular way.

Verification of client code that calls HOMs can take advantage of the client's knowledge about the mandatory calls to make strong conclusions. Our verification technique validates and explains traditional documentation practice for HOMs, which typically shows their code. However, specifications do not have to expose all of the code to clients, but only enough to determine how the HOM makes its mandatory calls.
Using early phase termination to eliminate load imbalances at barrier synchronization points
Authors: Rinard Martin C.
Published: November 2007

We present a new technique,
early phase termination
, for eliminating idle processors in parallel computations that use barrier synchronization. This technique simply terminates each parallel phaseas soon as there are too few remaining tasks to keep all of the processors busy.

Although this technique completely eliminates the idling that would other wise occur at barrier synchronization points, it may also change the computation and therefore the result that the computation produces. We address this issue by providing
probabilistic distortion models
that characterize how the use of early phase termination distorts the result that the computation produces. Our experimental results show that for our set of benchmark applications, 1) early phase termination can improve the performance of the parallel computation, 2) the distortion is small (or can be made to be small with the use of an appropriate compensation technique) and 3) the distortion models provide accurate and tight distortion bounds. These bounds can enable users to evaluate the effect of early phase termination and confidently accept results from parallel computations that use this technique if they find the distortion bounds to be acceptable.

Finally, we identify a general computational pattern that works well with early phase termination and explain why computations that exhibit this pattern can tolerate the early termination of parallel tasks without producing unacceptable results.
Starc
Authors: Elkarablieh Bassem , Khurshid Sarfraz , Vu Duy , McKinley Kathryn S.
Published: November 2007

Data structure corruptions are insidious bugs that reduce the reliability of software systems. Constraint-based datastructure repair promises to help programs recover from potentially crippling corruption errors. Prior work repairs a variety of relatively small data structures, usually with hundreds of nodes.

We present STARC which uses static analysis to repair data structures with tens of thousands of nodes. Given a Java predicate method that describes the integrity constraints of a structure, STARC statically analyzes the method to identify: (1) the recurrent fields, i.e., fields that the predicate method uses to traverse the structure; and (2) local field constraints, i.e., how the value of an object field is related to the value of a neighboring object field. STARC executes the predicate method on the structure and monitors its execution to identify corrupt object fields, which STARC then repairs using a systematic search of a neighborhood of the given structure. Each repair action is guided by the result of the static analysis, which enables more efficient and effective repair compared to prior work. Experimental results showthat STARC can repair structures with tens of thousands of nodes, up to 100 times larger than prior work.

STARC efficiency is probably not practical for very large data structures in deployed systems, but opens a promising direction for future work.
Multiple ownership
Authors: Cameron Nicholas R. , Drossopoulou Sophia , Noble James , Smith Matthew J.
Published: November 2007

Existing ownership type systems require objects to have precisely one primary owner, organizing the heap into an ownership tree. Unfortunately, a tree structure is too restrictive for many programs, and prevents many common design patterns where multiple objects interact.

Multiple Ownership is an ownership type system where objects can have more than one owner, and the resulting ownership structure forms a DAG. We give a straightforward model for multiple ownership, focusing in particular on how multiple ownership can support a powerful effects system that determines when two computations interfere-in spite of the DAG structure.

We present a core programming language MOJO, Multiple ownership for Java-like Objects, including a type and effects system, and soundness proof. In comparison to other systems, MOJO imposes absolutely no restrictions on pointers, modifications or programs' structure, but in spite of this, MOJO's effects can be used to reason about or describe programs' behaviour.
Awesome
Authors: Kojarski Sergei , Lorenz David H.
Published: November 2007

Domain specific aspect-oriented language extensions offer unique capabilities to deal with a variety of cross cutting concerns. Ideally, one should be able to use several of these extensions together in a single program. Unfortunately, each extension generally implements its own specialized weaver and the different weavers are incompatible. Even if the weavers were compatible, combining them is a difficult problem to solve in general, because each extension definesits own language with new semantics. In this paper we present a practical composition framework, named Awesome, for constructing a multi-extension weaver by plugging together independently developed aspect mechanisms. The framework has a component-based and aspect-oriented architecture that facilitates the development and integration of aspect weavers. To be scalable, the framework provides a default resolution of feature interactions in the composition. To be general, the framework provides means for customizing the composition behavior. Furthermore, to be practically useful, there is no framework-associated overhead on the runtime performance of compiled aspect programs. To illustrate the Awesome framework concretely, we demonstrate the construction of a weaver for a multi-extension AOP language that combines Cool and AspectJ. However, the composition method is not exclusive to Cool and AspectJ-it can be applied to combine any comparable reactive aspect mechanisms.
Mop
Authors: Chen Feng , Roşu Grigore
Published: November 2007

Monitoring-Oriented Programming (MOP1) [21, 18, 22, 19] is a formal framework for software development and analysis, in which the developer specifies desired properties using definable specification formalisms, along with code to execute when properties are violated or validated. The MOP framework automatically generates monitors from the specified properties and then integrates them together with the user-defined code into the original system.

The previous design of MOP only allowed specifications without parameters, so it could not be used to state and monitor safety properties referring to two or more related objects. In this paper we propose a
parametric specification formalism-independent extension of MOP
, together with an implementation of JavaMOP that supports parameters. In our current implementation, parametric specifications are translated into AspectJ code and then weaved into the application using off-the-shelf AspectJ compilers; hence, MOP specifications can be seen as formal or logical aspects.

Our JavaMOP implementation was extensively evaluated on two benchmarks, Dacapo [14] and Tracematches [8], showing that runtime verification in general and MOP in particular are feasible. In some of the examples, millions of monitor instances are generated, each observing a set of related objects. To keep the runtime overhead of monitoring and event observation low, we devised and implemented a
decentralized indexing
optimization. Less than 8% of the experiments showed more than 10% runtime overhead; in most cases our tool generates monitoring code as efficient as the hand-optimized code. Despite its genericity, JavaMOP is empirically shown to be more efficient than runtime verification systems specialized and optimized for particular specification formalisms. Many property violations were detected during our experiments; some of them are benign, others indicate defects in programs. Many of these are subtle and hard to find by ordinary testing.
Making trace monitors feasible
Authors: Avgustinov Pavel , Tibble Julian , de Moor Oege
Published: November 2007

A
trace monitor
observes an execution trace at runtime; when it recognises a specified sequence of events, the monitor runs extra code. In the aspect-oriented programming community, the idea originatedas a generalisation of the advice-trigger mechanism: instead of matchingon single events (joinpoints), one matches on a sequence of events. The runtime verification community has been investigating similar mechanisms for a number of years, specifying the event patterns in terms of temporal logic, and applying the monitors to hardware and software.

In recent years trace monitors have been adapted for use with mainstream object-oriented languages. In this setting, a crucial feature is to allow the programmer to quantify over groups of related objects when expressing the sequence of events to match. While many language proposals exist for allowing such features, until now no implementation had scalable performance: execution on all but very simple examples was infeasible.

This paper rectifies that situation, by identifying two optimisations for
generating feasible
trace monitors from declarative specifications of the relevant event pattern. We restrict ourselves to optimisations that do not have a significant impact on compile-time: they only analyse the event pattern, and not the monitored code itself.

The first optimisation is an important improvement over an earlier proposal in [2] to avoid space leaks. The second optimisation is a form of indexing for partial matches. Such indexing needs to be very carefully designed to avoid introducing new space leaks, and the resulting data structure is highly non-trivial.
Epi-aspects
Authors: Fleissner Sebastian , Baniassad Elisa L. A.
Published: November 2007

Conscientious software is a recently proposed paradigm for developing reliable, self-sustaining software systems. Conscientious software systems consist of an allopoietic part, which encapsulates application functionality, and an autopoietic part that is responsible for keeping the system alive by monitoring the application and adapting it to environmental changes. Practical application of the conscientious software paradigm requires solutions to two open problems: The design of suitable autopoietic programming languages and the proposal of concrete architectures for combining the autopoietic and allopoietic parts. In this paper, we tackle the second challenge, and propose a concrete, aspect-oriented architecture for realizing conscientious software. Here, we introduce epi-aspects, a construct for upgrading new and existing applications into conscientious software. This paper provides the architectural design of epi-aspects, an autopoietic simulator, and a concrete framework for developing epi-aspects in Java. The framework and the simulator are used to conduct a case study in which we develop and test a conscientious Java application.
Drivers of price Premium in e-markets
Authors: Kim Hee-Woong , Xu Yunjie
Published: November 2007

How price sensitivity influences online customers' purchase decisions.
Introduction
Authors: Feitelson Dror G.
Published: November 2007

Only experimentation can confirm or refute the relevance of theory and established practices.
Experience-driven experimental systems research
Authors: Peterson Larry , Pai Vivek S.
Published: November 2007

The most direct way toward understanding whether PlanetLab and other such systems serve their purpose is to build, deploy, and use them.
TREC
Authors: Voorhees Ellen M.
Published: November 2007

Large-scale test collections drive improvement in search technology to help users find information in free text.
How DARPA structures its robotics programs to improve locomotion and navigation
Authors: Jackel L.D. , Hackett Douglas , Krotkov Eric , Perschbacher Michael , Pippine James , Sullivan Charles
Published: November 2007

Research teams use common robots and machine learning to teach the robots outdoor navigation and locomotion skills.
Five perspectives on computer game history
Authors: Pargman Daniel , Jakobsson Peter
Published: November 2007

This column on computer game history, from the perspective of the gaming industry, complements the column from the last issue on the history of virtual worlds. I met Daniel Pargman, then a graduate student studying multiplayer games, exactly ten years ago. He told me that one day there would be a research field dedicated to online games, and he planned to be there. The field is indeed emerging, with Daniel as a major contributor.---
Jonathan Grudin, column editor
From technology engineering to social engineering
Authors: Jäkälä Mikko , Pekkola Samuli
Published: November 2007

Virtual worlds have a long history, and it also includes various technologies. Yet research interest towards them has diverged over the years. It seems that nowadays they are on focus again with the evolution of socially oriented and community-supporting virtual worlds. Instead of technical factors, human factors and the motivation behind the use are highlighted. In this paper, we will briefly review the research efforts made in the 90's, and derive a set of themes that were of interest back then. Next, we will expand the set by arguing for newer themes, identified in the latest information systems literature. These two sets of themes form a basis of a research agenda for studying virtual worlds in the next five years. The sets also compose N-dimensional space for further theorizing and developing new virtual worlds or virtual places for work and pleasure. Hence, the paper presents and argues for a transition from technology engineering to social engineering.
Virtual worlds
Authors: Bray David A. , Konsynski Benn R.
Published: November 2007

Virtual worlds are now a reality, representing intriguing environments for researchers from multiple fields to pursue collaborative investigations. To provide a background, we first highlight the basic business and sociological phenomena occurring in virtual worlds. Real world institutions, ranging from business to governmental organizations, are already experiencing the effects of increased growth in the number of individuals participating in these virtual world environments. We consider research paths from four representative perspectives: (1) information systems, (2) neurobiology, (3) political science, and (4) organizational governance research. Virtual world environments offer significant opportunities for research in many fields for study, including demonstration and examination of intra-world and inter-world practice and behavior.
Sustainable virtual world ecosystems
Authors: Campbell John , Fletcher Gordon , Greenhill Anita
Published: November 2007

This paper outlines an agenda for research that contributes to the development of sustainable virtual world ecosystems. It provides direction for understanding the social aspects of both trust and conflict. Trust is often referred to in research to examine the social interactions observed in virtual communities. It is an important theoretical factor affecting user intention to give and receive information. However, trust is a problematic construct, as it is based on culturally and historically specific assumptions about human association and social organization. Conflict and disagreement are usually viewed as undesirable behaviors in virtual worlds. The management of these behaviors is a difficult task in virtual environments where physical social controls are not available. Consequently, the moderation of participant behavior is seen as a challenge for virtual world creators, particularly as virtual world governance is likely to have a significant influence on member retention rates. A conflict-oriented research agenda provides a useful vehicle for interpreting the simultaneous pressures for both collaboration and competition in virtual worlds. Conflict is an integral structural element of the social interrelations found in both physical and virtual worlds. In this context, both agreement and disagreement are necessary to maintain the intricate social networks necessary for sustainable virtual world ecosystems.
The virtual cathedral and the virtual bazaar
Authors: Arakji Reina Y. , Lang Karl R.
Published: November 2007

Applying economic analysis, we explore the potential benefits and risks associated with firm-based and social production models and derive conditions that determine when open or closed innovation models are more appropriate. We contrast the newly emerging "user-generated approach" to innovation in virtual worlds with the traditional "producer-controlled approach". Taking the cases of World of Warcraft and Second Life, we show how the two virtual world providers use very different strategies to organize the creation of game content. We conclude with presenting a roadmap that businesses can use to conceive effective innovation and development strategies for designing virtual world offerings.
Diffusion of virtual innovation
Authors: Fuller Mark A. , Hardin Andrew M. , Scott Christopher L.
Published: November 2007

Drawing on Rogers' diffusion of innovations theory, specifically his innovation decision process model, this paper develops a research framework that identifies the accelerators and inhibitors of virtual world technology adoption. Categorized by level of analysis, specific factors influencing the adoption of virtual world technology by organizations are identified. At the individual level of analysis, factors such as the technology's ease of use and usefulness, as well as the individual's computer self-efficacy, trust, and enjoyment are discussed in terms of their "bottom-up" influence on technology diffusion. At the group level of analysis, different forms of group efficacy (such as computer collective efficacy and virtual team efficacy) are suggested to play a role in virtual world technology adoption and diffusion. Further, group-level technology acceptance factors (including a priori beliefs and attitudes toward the technology, as well as psychosocial variables) are proposed to influence a group's overall valence toward the technology, driving the adoption of the technology Finally, at the organizational level of analysis, technical compatibility, technical complexity, and relative advantage are explored as major factors influencing an organization's willingness to adopt virtual world technology through "top-down" diffusion that follows specific isomorphic processes. Finally, the role of organizational culture is also discussed. Through the identification and discussion of innovation diffusion factors which occur at different levels of analysis and at different stages of the innovation decision process, this study provides a framework for studying the adoption, spread, and continual use of virtual world technology.
Virtual worlds as a medium for advertising
Authors: Barnes Stuart
Published: November 2007

Online virtual worlds, such as Second Life, are rapidly becoming recognized as a technology of substantial future importance for marketers and advertisers. Many of these virtual worlds provide the potential medium for very rich and varied new and enhanced modes of advertising--all in one online channel. Such varied advertising experiences can be immersive or absorptive, active or passive. Potential modes of advertising include product placement of 3-D objects (such as brand-name clothing), billboards, radio, musical performances, movies and videos, advergames (typically mini-worlds or mini-games) and cross-promotional offers and activities. Little is known about the effectiveness of advertising in virtual worlds on purchasing intention towards a product. The purpose of this paper is to introduce the concept of advertising in virtual worlds and to create an agenda for future experimental research in this exceptionally new domain. As a result, we hope to encourage others to begin to further engage in research on this topic over the period from 2007-2014.
Team collaboration in virtual worlds
Authors: Kahai Surinder S. , Carroll Elizabeth , Jestice Rebecca
Published: November 2007

Are virtual worlds more or less effective for virtual team collaboration? We suggest that the answer to this question is complicated and dependent upon a number of factors, and we propose a research agenda with theoretical bases to guide researchers in the area of virtual team collaboration for the next seven to ten years. While virtual teams are increasingly used by organizations, there has been little systematic research done to understand how collaboration in virtual worlds compares to collaboration supported by other media, or how characteristics of virtual teams influence the collaboration process and outcomes. The research agenda that we propose looks at basic differences between virtual worlds and other media, but also includes consideration of the specific contextual factors, and the influence that leadership might have on the collaboration process and outcomes.