Using roles in Java

Using roles in object‐oriented design leads to a more natural representation of a given problem domain. Despite a lot of research into role–based systems, there is still a gap between conceptual representations of roles and the usage of roles in strongly typed object‐oriented programming languages such as C++ or Java. Since these languages associate classes and their instances exclusively and permanently, representing evolving objects that may take on different roles over time is difficult without special support: (i) entities must be reclassified any time they evolve and (ii) class hierarchies may grow exponentially if entities may take on several independent roles. This article shows how role hierarchies can be easily implemented in Java. It introduces the Java Role Package, which provides a set of classes to support handling of evolving objects without modifying the semantics of Java itself. Copyright © 2004 John Wiley & Sons, Ltd.     

Nearest and reverse nearest neighbor queries for moving objects

With the continued proliferation of wireless communications and advances in positioning technologies, algorithms for efficiently answering queries about large populations of moving objects are gaining interest. This paper proposes algorithms for k nearest and reverse k nearest neighbor queries on the current and anticipated future positions of points moving continuously in the plane. The former type of query returns k objects nearest to a query object for each time point during a time interval, while the latter returns the objects that have a specified query object as one of their k closest neighbors, again for each time point during a time interval. In addition, algorithms for so-called persistent and continuous variants of these queries are provided. The algorithms are based on the indexing of object positions represented as linear functions of time. The results of empirical performance experiments are reported.     

Experiences in database system implementation using a persistent programming language

The EXODUS database toolkit, and in particular the E persistent programming language, have been used in two substantial database system implementation efforts by the authors, the Ariel database rule system and the Triton nested relation DBMS. An important advantage of using a persistent programming language for database system implementation is that it is easy to implement special-purpose persistent objects used by the DBMS such as catalogs, rule indexes, and nested relational structures. Support for transactions built into a persistent programming language greatly reduces the effort required to implement a database system. A disadvantage observed is that it is not possible to map the type system of the DBMS to the type system of the underlying programming language while still retaining good performance for ad hoc queries. Also, software engineering difficulties arise when a persistent language makes a distinction between database types and main-memory types.     

DOLAR: virtualizing heterogeneous information spaces to support their expansion

Users expect applications to successfully cope with the expansion of information as necessitated by the continuous inclusion of novel types of content. Given that such content may originate from ‘not‐seen thus far’ data collections and/or data sources, the challenging issue is to achieve the return of investment on existing services, adapting to new information without changing existing business‐logic implementation. To address this need, we introduce DOLAR (Data Object Language And Runtime), a service‐neutral framework which virtualizes the information space to avoid invasive, time‐consuming, and expensive source‐code extensions that frequently break applications. Specifically, DOLAR automates the introduction of new business‐logic objects in terms of the proposed virtual ‘content objects’. Such user‐specified virtual objects align to storage artifacts and help realize uniform ‘store‐to‐user’ data flows atop heterogeneous sources, while offering the reverse ‘user‐to‐store’ flows with identical effectiveness and ease of use. In addition, the suggested virtual object composition schemes help decouple business logic from any content origin, storage and/or structural details, allowing applications to support novel types of items without modifying their service provisions. We expect that content‐rich applications will benefit from our approach and demonstrate how DOLAR has assisted in the cost‐effective development and gradual expansion of a production‐quality digital library. Experimentation shows that our approach imposes minimal overheads and DOLAR‐based applications scale as well as any underlying datastore(s). Copyright © 2011 John Wiley & Sons, Ltd.     

移动对象数据库模型、查询语言及实时交通流分析

提出一种移动对象数据库模型——Dynamic Transportation Network Based Moving Objects Database(简称DTNMOD),并给出了DTNMOD中基于移动对象时空轨迹的网络实时动态交通流分析方法.在DTNMOD中,交通网络被表示成动态的时空网络,可以描述交通状态、拓扑结构以及交通参数随时间的变化过程;网络受限的移动对象则用网络移动点表示.DTNMOD 模型包含了完整的数据类型和查询操作的定义,因此可以在任何可扩充数据库(如PostgreSQL 或SECONDO)中实现,从而得到完整的数据库模型和查询语言.为了对相关模型的性能进行比较与分析,基于PostgreSQL 实现了一个原型系统并进行了一系列的实验.实验结果表明,DTNMOD 提供了良好的区域查询及连接查询性能.     

Genericity in Java: persistent and database systems implications

Lack of parametric polymorphism has been a major obstacle for making Java a viable database programming language. Regrettably, a recently accepted solution for genericity in Java 5.0 has far-reaching negative implications for persistent and database systems because of static and dynamic type violations. Severe implications occur in typical database transactions when processing a variety of database collections. Well-known approaches to persistence in Java, including Java’s own persistence mechanism, do not perform correctly due to incorrect dynamic type information that gets promoted to persistence along with objects. Dynamic checking of types of objects fetched from the persistent store may now lead to unexpected type violations. Further problems occur in reflective transactions as Java Core Reflection now allows dynamic type violations without detecting them or throwing standard exceptions. All of this shows that extending Java with parametric polymorphism has not made Java a more viable database programming language. Both legacy systems, such as those based on the Java binding of the ODMG or JDO, and future Java-related persistent and database technologies will be affected. The source of these problems is in an implementation idiom called type erasure. This paper provides formal proofs of the above implications of type erasure along with specific samples of code in Java 5.0 illustrating these violations. The limitations of the virtual platform and extensions required for persistent systems to solve this problem are also elaborated.     

Filter objects for Java

Filtering is an emerging abstraction in object‐oriented systems. Filtering can be characterized by an ability to filter messages in transit and perform intermediate actions. Filters can be used for carrying out intermediate tasks such as encryption, load balancing, caching, security checks and add‐on computations. A few filtering approaches have been proposed earlier and some commercial implementations with specialized filtering capabilities are available. This paper discusses a model for transparent and dynamically pluggable first class filter objects for object‐oriented systems based on the Java programming language. The filter object model is based on an interclass filter relationship. The model is realized through extensions to the Java programming language. Filter objects can be injected into message paths during execution time and they are transparent to both clients and servers. The properties of filter objects enable them to be employed as a mechanism for evolution promoting reuse of existing code. A method of evolution through filter objects is discussed. A translator for Java filters (TJF) has been designed and implemented. TJF translates an extended Java program involving filter constructs into an equivalent Java code. The translation scheme is presented and the performance of the translated code is analyzed. A brief survey of existing approaches related to filtering in object‐oriented systems has also been presented. Copyright © 2003 John Wiley & Sons, Ltd.     

Round-Eye: A system for tracking nearest surrounders in moving object environments

This paper presents “Round-Eye”, a system for tracking nearest surrounding objects (or nearest surrounders) in moving object environments. This system provides a platform for surveillance applications. The core part of this system is continuous nearest surrounder (NS) query that maintains views of the nearest objects at distinct angles from query points. This query differs from conventional spatial queries such as range queries and nearest neighbor queries as NS query considers both distance and angular aspects of objects with respect to a query point at the same time. In our system framework, a centralized server is dedicated (1) to collect location updates of both objects and queries, (2) to determine which NS queries are invalidated in presence of object/query location changes and corresponding result changes if any, and (3) to refresh the affected query answers. To enhance the system performance in terms of processing time and network bandwidth consumption, we propose various techniques, namely, safe region, partial query reevaluation, and incremental query result update. Through simulations, we evaluate our system with the proposed techniques over a wide range of settings.     

Modeling Moving Objects over Multiple Granularities

This paper introduces a framework for modeling the movement of objects or individuals over multiple granularities. Granularity refers to selecting the appropriate level of detail for a task. At fine granularities, spatio-temporal information is revealed that was not previously known, such as additional locations that an individual visited or multiple visits to the same location. Conversely, moving to a coarser granularity or simpler view generalizes spatial and temporal aspects of movement allowing for an improved understanding of movement. Movement is modeled as geospatial lifelines, time-stamped records of the locations that an individual has occupied over a period of time. Depending on the desired granularity, lifelines are modeled as lifeline beads, necklaces, or more general approximations of these structures and this paper examines how different aspects of lifelines become relevant at refined or coarse granularities.     

Programming persistence in chi

The ways in which a persistent programming language allows the reuse of data and code objects by preserving them as persistent objects is discussed. The programming language chi , which supports persistent programming, is described. The language is innovative in that it elevates capabilities to the programming level and gives the programmer a convenient way to express which objects are persistent independently of the type of object. Thus, it provides orthogonal persistence. A further advantage that follows from such use of capabilities is that chi provides an implementation path for persistence, even upon architectures that do not support capabilities directly.<>     

Exact and Heuristic Algorithms for Risk‐Aware Stochastic Physical Search

We consider an intelligent agent seeking to obtain an item from one of several physical locations, where the cost to obtain the item at each location is stochastic. We study risk‐aware stochastic physical search (RA‐SPS), where both the cost to travel and the cost to obtain the item are taken from the same budget and where the objective is to maximize the probability of success while minimizing the required budget. This type of problem models many task‐planning scenarios, such as space exploration, shopping, or surveillance. In these types of scenarios, the actual cost of completing an objective at a location may only be revealed when an agent physically arrives at the location, and the agent may need to use a single resource to both search for and acquire the item of interest. We present exact and heuristic algorithms for solving RA‐SPS problems on complete metric graphs. We first formulate the problem as mixed integer linear programming problem. We then develop custom branch and bound algorithms that result in a dramatic reduction in computation time. Using these algorithms, we generate empirical insights into the hardness landscape of the RA‐SPS problem and compare the performance of several heuristics.     

Cold object identification in the Java virtual machine

Many Java applications instantiate objects within the Java heap that are persistent but seldom if ever referenced by the application. Examples include strings, such as error messages, and collections of value objects that are preloaded for fast access. This paper describes a stack‐based framework for detecting these ‘cold’ objects at runtime, with a view to marshaling and sequestering them in designated regions of the heap where they may be preferentially paged out to a backing store, thereby freeing physical memory pages for occupation by more active objects. Furthermore, we evaluate the correctness and efficiency of stack‐based approach with an access barrier. The experimental results from a series of SPECjvm2008 benchmarks are presented. Copyright © 2016 John Wiley & Sons, Ltd.     

Active objects made easy

A widely useful technique for implementing complex programs is to use multiple threads of execution. Unfortunately, when we multithread a program we introduce the potential for bugs caused by unprotected critical sections. A widely useful technique for reducing the number of critical sections, and hence the number of bugs, is that of active objects. This paper presents a design for active objects that is easy to understand, implement and use in any sufficiently powerful object-oriented programming language. We show the implementation and use of our design in both the Java^TM and C++ programming languages. © 1998 John Wiley & Sons, Ltd.     

一种新的基于在线采样的多物体跟踪方法

跟踪多个运动物体,尤其是在遮挡过程中跟踪多个运动物体,是计算机视觉领域一个重要但具有挑战性的问题.该文提出了一种新的在线采样、更新学习和分类的跟踪框架来处理多物体跟踪问题.首先,对遮挡发生前若干帧的各物体进行块采样,作为训练样本进行在线分类器设计.各帧的物体区域也在线进行块采样,并用这些分类器来进行分类标号.如果遮挡没有发生,一些新的训练样本被添加用来更新分类器.当遮挡发生时,根据标号结果,前景区域被分割成多个目标物体.和以往方法相比,新方法不依赖于一些假设条件,如场景深度信息、物体的先验模型(比如形状、种类、区域内颜色各向同性、运动规律等),具有更好的适应能力.实验结果验证了该文方法的稳定性和有效性.     

An overview of the Nexus distributed operating system design

Nexus is a distributed operating system designed to support experimental research in fault-tolerance techniques and object-oriented programming in distributed systems. The Nexus programming environment consists of objects, which are instances of abstract data types. Inheritance of types and multiple implementations for a type are supported by the system. Operations on objects are invoked, based on the remote-procedure-call paradigm and executed as atomic actions with provisions for application-controlled checkpointing and restart within actions. Nexus also supports parallel remote procedure calls. Interobject communication and location transparency in accessing objects is supported by the Nexus kernel     

Client ahead‐of‐time compiler for embedded Java platforms

Many embedded Java platforms execute two types of Java classes: those installed statically on the client device and those downloaded dynamically from service providers at run time. For achieving higher performance, the static Java classes can be compiled into machine code by ahead‐of‐time compiler (AOTC) in the server, and the translated machine code can be installed on the client device. Unfortunately, AOTC cannot be applicable to the dynamically downloaded classes. This paper proposes client‐AOTC (c‐AOTC), which performs AOTC on the client device using the just‐in‐time compiler (JITC) module installed on the device, obviating the JITC overhead and complementing the server‐AOTC. The machine code of a method translated by JITC is cached on a persistent memory of the device, and when the method is invoked again in a later run of the program, the machine code is loaded and executed directly without any translation overhead. A major issue in c‐AOTC is relocation because some of the address constants embedded in the cached machine code are not correct when the machine code is loaded and used in a different run; those addresses should be corrected before they are used. Constant pool resolution and inlining complicate the relocation problem, and we propose our solutions. The persistent memory overhead for saving the relocation information is also an issue, and we propose a technique to encode the relocation information and compress the machine code efficiently. We developed a c‐AOTC on Sun's CDC VM reference implementation, and our evaluation results indicate that c‐AOTC can improve the performance significantly, as much as an average of 12% for EEMBC and 4% for SpecJVM98, with a persistent memory overhead of 1% on average. Copyright © 2008 John Wiley & Sons, Ltd.     

Interactive constrained dynamics for rigid and deformable objects

Following the continuous increase in computational power of consumer hardware, interactive virtual environments have been recently enriched with more and more complex deformable objects. However, many physics engines are still very limited in the way they handle interacting rigid and deformable objects. This paper proposes a constraint‐based approach to real‐time simulation of coupled rigid and deformable objects capable of providing two‐way interactions. Similar techniques have seen widespread usage for either rigid or deformable objects, but not for the simultaneous simulation of both. By extending such approaches, we show not only how interaction is possible but also how it can be performed at real‐time rates. We address contact response and also show how to implement typical constraints to enforce limitations in the degrees of freedom and to enhance the dynamical properties of deformable objects. The method is easily integrated into existing physics engines that use similar constraint solvers and is independent on the kind of deformable object paradigm chosen. The provided simulation results show that the method is fast and effective in handling contacts between rigid and deformable objects and in simulating friction and other kinds of constraints. Copyright © 2015 John Wiley & Sons, Ltd.     

Volumetric Billboards

We introduce an image‐based representation, called volumetric billboards, allowing for the real‐time rendering of semi‐transparent and visually complex objects arbitrarily distributed in a 3D scene. Our representation offers full parallax effect from any viewing direction and improved anti‐aliasing of distant objects. It correctly handles transparency between multiple and possibly overlapping objects without requiring any primitive sorting. Furthermore, volumetric billboards can be easily integrated into common rasterization‐based renderers, which allows for their concurrent use with polygonal models and standard rendering techniques such as shadow‐mapping. The representation is based on volumetric images of the objects and on a dedicated real‐time volume rendering algorithm that takes advantage of the GPU geometry shader. Our examples demonstrate the applicability of the method in many cases including levels‐of‐detail representation for multiple intersecting complex objects, volumetric textures, animated objects and construction of high‐resolution objects by assembling instances of low‐resolution volumetric billboards.     

An Object Model for Multimedia Programming

The development of multimedia applications is a complex task. Much of this complexity stems from requirements associated with programming multiple media objects and the control of dependences and inter-relationships between these media objects and the user(s). It is clearly necessary to have a basic framework on which to build multimedia applications in the face of such complexities. Such a conceptual model is what we have called an object model and it is the main subject of this paper. The MADE object model represents a novel approach to multimedia application programming that is founded on the two principal concepts of active objects and delegation. Although these concepts are not novel in themselves, we believe that their combined use in a multimedia development environment represents a substantial enhancement to more traditional approaches to programming in this area.