Bo Nørregaard Jørgensen

Customization of object request brokers by application specific policies

This paper presents an architectural framework for customizing Object Request Broker (ORB) implementations to application-specific preferences for various non-functional requirements. ORB implementations are built by reusing a domain-specific component-based architecture that offers support for one or more non-functional requirements. The domain-specific architecture provides the mechanism that allows the ORB to reconfigure its own implementation at run-time on the basis of application-specific preferences. This mechanism is based on a run-time selection between alternative component implementations that guarantee different service-levels for non-functional requirements. Application-specific preferences are defined in policies and service-level guarantees are defined in component descriptors. Policies and component descriptors are expressed using descriptive languages. This gives application programmers an easy and powerful tool for customizing an ORB implementation. To validate the feasibility of our architectural framework we have applied it in the domain of robotic control applications.

Towards a dynamic-update-enabled JVM

This paper advocates that de facto dynamic updates of Java applications will eventually require a dynamic-update-enabled Java virtual machine. We argue that our approach for dynamic updates of component-based Java applications complements the new module system planned for upcoming Java releases. We conclude that simple extensions to an existing JVM can bring full flexibility and transparency to dynamic updates in Java.

An agent-based extensible climate control system for sustainable greenhouse production

The slow adoption pace of new control strategies for sustainable greenhouse climate control by industrial growers, is mainly due to the complexity of identifying and resolving potentially conflicting climate control requirements. In this paper, we present a multi-agent-based climate control system that allows new control strategies to be adopted without any need to identify or resolve conflicts beforehand. This is achieved by representing the climate control requirements as separate agents. Identifying and solving conflicts then becomes a negotiation problem among agents sharing the same controlled environment. Negotiation is done using a novel multi-objective negotiation protocol that uses a generic algorithm to find an optimized solution within the search space. The multi-agent-based control system has been empirically evaluated in an ornamental floriculture research facility in Denmark. The evaluation showed that it is realistic to implement the climate control requirements as individual agents, thereby opening greenhouse climate control systems for integration of independently produced control strategies.

Fault detection and diagnosis for smart buildings: State of the art, trends and challenges

Worldwide, buildings account for ca. 40% of the total energy consumption and ca. 20% of the total CO2 emissions. While most of the energy goes into primary building use, a significant amount of energy is wasted due to malfunctioning building system equipment and wrongly configured Building Management Systems (BMS). For example, wrongly configured setpoints or building equipment, or misplaced sensors and actuators, can contribute to deviations of the real energy consumption from the predicted one. Our paper is motivated by these posed challenges and aims at pinpointing the types of problems in the BMS components that can affect the energy efficiency of a building, as well as review the methods that can be utilized for their discovery and diagnosis. The goal of the paper is to highlight the challenges that lie in this problem domain, as well as provide a strategy how to counterfeit them.

Challenge: Advancing Energy Informatics to Enable Assessable Improvements of Energy Performance in Buildings

Within the emerging discipline of Energy Informatics people are researching, developing and applying information and communication technologies, energy engineering and computer science to address energy challenges. In this paper we discuss the challenge of advancing energy informatics to enable assessable improvements of energy performance in buildings. This challenge follows a long-standing goal within the built environment to develop processes that enable predictable outcomes. Implementing this goal in the research framework of energy informatics creates a need for establishing a new underlying assumption, which states that the impact of energy informatics solutions should be assessable. This assumption applies to particular building contexts and when solutions act simultaneously. Research based on this assumption will enable new sound processes for the built environment facilitating informed decision for adding intelligent solutions to buildings compared to only favoring passive building improvements.

Commercial buildings energy performance within context occupants in spotlight

Existing commercial buildings represent a challenge in the energy efficiency domain. Energy efficiency of a building, very often equalized to a building;s performance should not be observed as a standalone issue. For commercial buildings, energy efficiency needs to be observed and assessed within the context of performance of resident businesses. We examine both business performance and energy performance and how they relate to one another to conclude that building occupants, who are also employees, hold the key to optimizing both metrics in one of the most cost-efficient ways. Finally, the goal of our contribution is twofold: 1) to re-scope the concept of building performance to and show the importance to consider, hand-in-hand, both energy performance and performance of resident businesses, and 2) re-state the importance of the potential that lies in the active involvement of building occupants in optimizing overall building performance.

Remodularizing Java programs for improved locality of feature implementations in source code

Explicit traceability between features and source code is known to help programmers to understand and modify programs during maintenance tasks. However, the complex relations between features and their implementations are not evident from the source code of object-oriented Java programs. Consequently, the implementations of individual features are difficult to locate, comprehend, and modify in isolation. In this paper, we present a novel remodularization approach that improves the representation of features in the source code of Java programs. Both forward and reverse restructurings are supported through on-demand bidirectional restructuring between feature-oriented and object-oriented decompositions. The approach includes a feature location phase based on tracing of program execution, a feature representation phase that reallocates classes into a new package structure based on single-feature and multi-feature packages, and an annotation-based reverse transformation of code. Case studies performed on two open-source projects indicate that our approach requires relatively little manual effort and reduces tangling and scattering of feature implementations in the source code.

Evolution of collective object behavior in presence of simultaneous client-specific views

When different clients, each with their own individual customization requirements, use the same system simultaneously, the system must dynamically adapt its behavior on a per client basis. Each non-trivial adaptation of the system’s behavior will very likely crosscut the implementation of multiple objects. In this paper we present an extension to the Java programming language that supports the dynamic evolution of collective object behavior in the presence of simultaneous client-specific views. In accordance with the separation of concerns and locality principles, client-specific customization of collective object behavior is organized as layers of mixin-like wrappers. Each layer of wrappers incrementally adds behavior and state to a group of core objects without modifying their respective implementations. Hence, collective object behavior can evolve in an additive and non-invasive way. The extension that we propose provides language constructs for defining, encapsulating and selecting behavioral refinements, and runtime support for transparently integrating them on demand.

Javeleon: An Integrated Platform for Dynamic Software Updating and Its Application in Self-*Systems

Practical dynamic updating of modern Java applications requires tool support to become an integral part of the software development and maintenance lifecycle. In this paper we present Javeleon, an easy-to-use tool for dynamic updates of Java applications. To support integration with specific frameworks, component systems and application servers, Javeleon currently provides tight integration with the NetBeans Platform, facilitating dynamic updating for applications built on top of the NetBeans Platform in an unconstrained manner. Javeleon supports state-preserving unanticipated runtime evolution including dynamic changes to the type hierarchy of classes without modifying a JVM and without utilizing new language constructs. In addition to the obvious benefits of using Javeleon during development, we argue that Javeleon is a strong candidate for being useful in other research fields. In order to substantiate this argument, we present an overview of an ongoing research that applies Javeleon in the development of Self-systems.

Run-time phenomena in dynamic software updating: causes and effects

The development of a dynamic software updating system for statically-typed object-oriented programming languages has turned out to be a challenging task. Despite the fact that the present state of the art in dynamic updating systems, like JRebel, Dynamic Code Evolution VM, JVolve and Javeleon, all provide very transparent and flexible technical solutions to dynamic updating, case studies have shown that designing dynamically updatable applications still remains a challenging task. This challenge has its roots in a number of run-time phenomena that are inherent to dynamic updating of applications written in statically-typed object-oriented programming languages. In this paper, we present our experience from developing dynamically updatable applications using a state-of-the-art dynamic updating system for Java. We believe that the findings presented in this paper provide an important step towards a better understanding of the implications of dynamic updating on the application design.