Architecting and implementing distributed Web applications using the graph‐oriented approach

This paper presents a graph‐oriented framework, called WebGOP, for architecture modeling and programming of Web‐based distributed applications. WebGOP is based on the graph‐oriented programming (GOP) model, under which the components of a distributed program are configured as a logical graph and implemented using a set of operations defined over the graph. WebGOP reshapes GOP with a reflective object‐oriented design, which provides powerful architectural support in the World Wide Web environment. In WebGOP, the architecture graph is reified as an explicit object which itself is distributed over the network, providing a graph‐oriented context for the execution of distributed applications. The programmer can specialize the type of graph to represent a particular architecture style tailored for an application. WebGOP also has built‐in support for flexible and dynamic architectures, including both planned and unplanned dynamic reconfiguration of distributed applications. We describe the WebGOP framework, a prototypical implementation of the framework on top of SOAP, and a performance evaluation of the prototype. The prototype demonstrated the feasibility of our approach. Results of the performance evaluation showed that the overhead introduced by WebGOP over SOAP is reasonable and acceptable. Copyright © 2003 John Wiley & Sons, Ltd.     

Using meta‐modeling in design and implementation of component‐based systems: the SOFA case study

To allow efficient and user‐friendly development of a component‐based application, component systems have to provide a rather complex development infrastructure, including a tool for component composition, component repository, and a run‐time infrastructure. In this paper, we present and evaluate benefits of using meta‐modeling during the process of defining a component system and also during creation of the development and run‐time infrastructures. Most of the presented arguments are based on a broad practical experience with designing the component systems SOFA and SOFA 2; the former designed in a classical ad hoc ‘manual’ way, whereas the latter with the help of meta‐modeling. Copyright © 2010 John Wiley & Sons, Ltd.     

Towards pattern‐based architectures for event processing systems

Recently, event processing (EP) has gained considerable attention as an individual discipline in computer science. From a software engineering perspective, EP systems still lack the maturity of well‐established software architectures. For the development of industrial EP systems, generally accepted software architectures based on proven design patterns and principles are still missing. In this article, we introduce a catalog of design patterns that supports the development of event‐driven architectures (EDAs) and complex EP systems. The design principles originate from experiences reported in publications as well as from our own experiences in building EP systems with industrial and academic partners. We present several patterns on different layers of abstractions that define the overall structure as well as the building blocks for EP systems. Architectural patterns that determine the top‐level structure of an EDA can be distinguished from design patterns that specify the basic mechanisms of EP. The practical application of the catalog of patterns is described by the pattern‐based design of a sample EDA for a sensor‐based energy control system. Finally, we propose a coherent and general reference architecture for EP derived from the proposed patterns.Copyright © 2013 John Wiley & Sons, Ltd.     

Streaming‐Enabled Parallel Dataflow Architecture for Multicore Systems

We propose a new framework design for exploiting multi‐core architectures in the context of visualization dataflow systems. Recent hardware advancements have greatly increased the levels of parallelism available with all indications showing this trend will continue in the future. Existing visualization dataflow systems have attempted to take advantage of these new resources, though they still have a number of limitations when deployed on shared memory multi‐core architectures. Ideally, visualization systems should be built on top of a parallel dataflow scheme that can optimally utilize CPUs and assign resources adaptively to pipeline elements. We propose the design of a flexible dataflow architecture aimed at addressing many of the shortcomings of existing systems including a unified execution model for both demand‐driven and event‐driven models; a resource scheduler that can automatically make decisions on how to allocate computing resources; and support for more general streaming data structures which include unstructured elements. We have implemented our system on top of VTK with backward compatibility. In this paper, we provide evidence of performance improvements on a number of applications.     

Feature‐based approach to object‐oriented engineering of applications for reuse

Object‐oriented technology is gaining popularity among software engineers with the goal of building reusable and adaptable software. Unfortunately, however, most methods introduced so far are not domain‐oriented and do not address the issue of reuse directly. For these methods, software reuse is not the primary goal; it is only a by‐product. The feature‐oriented reuse method, FORM, is extended in this paper for improving the object‐oriented engineering of applications for reuse. FORM concentrates on analyzing and modeling commonalities and differences in the applications of a given domain in terms of capability, operating environment, domain technology, and implementation technique features. These features are used to systematically derive objects that are tied to the features, and to develop reusable and adaptable domain architectures. We found that FORM facilitates analysis of variability (and commonality) of software before engineering and implementation start, and with this understanding, adaptability and reusability can be built into software. Feature modeling has been found to be an effective method for identifying and modeling reusable objects. Copyright © 2000 John Wiley & Sons, Ltd.     

Toward the adaptation of component‐based architectures by model transformation: behind smart user interfaces

Graphical user interfaces are not always developed for remaining static. There are GUIs with the need of implementing some variability mechanisms. Component‐based GUIs are an ideal target for incorporating this kind of operations, because they can adapt their functionality at run‐time when their structure is updated by adding or removing components or by modifying the relationships between them. Mashup user interfaces are a good example of this type of GUI, and they allow to combine services through the assembly of graphical components. We intend to adapt component‐based user interfaces for obtaining smart user interfaces. With this goal, our proposal attempts to adapt abstract component‐based architectures by using model transformation. Our aim is to generate at run‐time a dynamic model transformation, because the rules describing their behavior are not pre‐set but are selected from a repository depending on the context. The proposal describes an adaptation schema based on model transformation providing a solution to this dynamic transformation. Context information is processed to select at run‐time a rule subset from a repository. Selected rules are used to generate, through a higher‐order transformation, the dynamic model transformation. This approach has been tested through a case study which applies different repositories to the same architecture and context. Moreover, a web tool has been developed for validation and demonstration of its applicability. The novelty of our proposal arises from the adaptation schema that creates a non pre‐set transformation, which enables the dynamic adaptation of component‐based architectures. Copyright © 2014 Copyright © 2014 John Wiley & Sons, Ltd.     

Developing dynamic‐reconfigurable communication protocol stacks using Java

This paper proposes the development of a dynamic‐reconfigurable protocol stack, which allows the programmer to create, to remove, and to replace protocol modules during their operation. Moreover, this protocol stack also aims to preserve the module state, such as the data structures that manage the existing connections. To achieve these goals, a Java‐based component framework is developed so that the programmers are able to implement their components under the proposed framework. This framework can dynamically reconfigure the components at a safe period and can help the components transfer their states, and the dynamic reconfiguration is transparent to the user application running on top of the stack. To demonstrate the component framework, a TCP component is implemented. While maintaining active connections for the user application, the TCP component is able to be dynamically replaced by another version. Copyright © 2005 John Wiley & Sons, Ltd.     

A robust reconfiguration protocol for the dynamic update of component‐based software systems

This paper focuses on the dynamic reconfiguration of component‐based software systems. From a structural point of view, such systems are made of components linked together through their provided and required services, the code of components being defined by modules (e.g., jar files). Today, the ability to reconfigure component‐based systems at runtime faces limitations. Some component frameworks allow to dynamically reconfigure components – starting or stopping them, or changing how they are wired together for instance – but forbid any dynamic evolution of the modules defining their code. Other frameworks allow to dynamically update modules but at the cost of loosing control on component wires, preventing software architects or tools alike to decide how components are wired together. In this paper, we propose a component framework that addresses these limitations through a unified approach for the management of components and modules. Our approach uniquely enables to reconfigure both components and modules at runtime, without restrictions. We prototyped the proposed framework in Java and exercised various dynamic reconfigurations of component‐based systems. Furthermore, we formalized this framework and proved the correctness of its reconfiguration protocol with the Coq proof assistant. Copyright © 2017 John Wiley & Sons, Ltd.     

Playing MUSIC — building context‐aware and self‐adaptive mobile applications

Although the idea of context‐awareness was introduced almost two decades ago, few mobile software applications are available today that can sense and adapt to their run‐time environment. The development of context‐aware and self‐adaptive applications is complex and few developers have experience in this area. On the basis of several demonstrators built by the joint European research project MUSIC, this paper describes typical context and adaptation features relevant for the development of context‐aware and self‐adaptive mobile applications. We explain how the demonstrators were realised using the open‐source platform MUSIC and present the feedback of the developers of these demonstrators. The main contribution of this paper is to show how the development complexity of context‐aware and self‐adaptive mobile applications can be mastered by using an adaptation framework such as MUSIC. Copyright © 2012 John Wiley & Sons, Ltd.     

High‐level specifications for automatically generating parallel code

The arrival of multicore systems, along with the speed‐up potential available in graphics processing units, has given us unprecedented low‐cost computing power. These systems address some of the known architecture problems but at the expense of considerably increased programming complexity. Heterogeneity, at both the architectural and programming levels, poses a great challenge to programmers. Many proposals have been put forth to facilitate the job of programmers. Leaving aside proposals based on the development of new programming languages because of the effort this represents for the user (effort to learn and reuse code), the remaining proposals are based on transforming sequential code into parallel code, or on transforming parallel code designed for one architecture into parallel code designed for another. A different approach relies on the use of skeletons. The programmer has available set of parallel standards that comprise the basis for developing parallel code while programming sequential code. In this context, we propose a methodology for developing an automatic source‐to‐source transformation in a specific domain. This methodology is instantiated in a framework aimed at solving dynamic programming problems. Using this framework, the final user (a physician, mathematician, biologist, etc.) can express her problem using an equation in Latex, and the system will automatically generate the optimal parallel code for homogeneous or heterogeneous architectures. This approach allows for great portability toward these new emerging architectures and for great productivity, as evidenced by the computational results.Copyright © 2012 John Wiley & Sons, Ltd.     

Necessary and Sufficient Near‐Optimal Conditions for Mean‐Field Singular Stochastic Controls

We consider the near‐optimal control problems for mean‐field singular stochastic systems, where the control domain is non‐convex. By virtue of Ekeland's principle and some estimates on the state and adjoint processes, necessary and sufficient conditions for near‐optimality are established in the mean‐field framework. As an application, an example is presented to demonstrate the results.     

Developing WWW‐based highly interactive and collaborative applications using software components

This paper describes a layered framework to support WWW‐based interactive and collaborative applications. Using some commercial‐off‐the‐shelf (COTS) software, three basic services are built: virtual rooms, virtual file systems, and database connectivity. These services are used at a second layer, which actually provides the functionality of the framework. The components that have been described at this level can be embedded in WWW‐based business applications in an easy and direct way. Therefore, programmers can focus on the particular logic of their applications, avoiding most of the issues related to collaboration, networking, and access control. In order to test the developed framework a WWW‐based educational application has been implemented. This tele‐education system, with innovative features in the field of WWW‐based practical training, is the second contribution presented by the authors. Copyright © 2001 John Wiley & Sons, Ltd.     

Exception handling in the development of dependable component‐based systems

Exception handling is a structuring technique that facilitates the design of software systems by encapsulating the process of error recovery. In this paper, we present a systematic approach for incorporating exceptional behaviour in the development of component‐based software. The premise of our approach is that components alone do not provide the appropriate means to deal with exceptional behaviour in an effective manner, hence the need to consider the notion of collaborations for capturing the interactive behaviour between components when error recovery involves more than one component. The feasibility of the approach is demonstrated in terms of the mining control system case study. Copyright © 2004 John Wiley & Sons, Ltd.     

INTERNET‐BASED REAL‐TIME CONTROL ARCHITECTURES WITH TIME‐DELAY/PACKET‐LOSS COMPENSATION

The main objective of this paper is to demonstrate the feasibility of Internet‐based real‐time control. A novel client/server‐based architecture for Internet‐based supervisory control with a Common Gateway Interface/Hyper Text Markup Language (CGI/HTML) interface is presented. A real‐time operating environment was established for closed‐loop control over Ethernet. We conceived of an autoregressive (AR) prediction scheme and a novel compensation algorithm to compensate for network‐induced time delays and data‐packet losses simultaneously. We constructed an open‐loop unstable ball magnetic‐levitation (maglev) setup as a test bed to validate the two proposed control architectures. Experimental results proved the feasibility of Internet‐based real‐time control and verified the effectiveness of the proposed time‐delay/packet‐loss compensation algorithm in networked feedback control systems.     

Cross‐profiling for Java processors

Performance evaluation of embedded software is essential in an early development phase so as to ensure that the software will run on the embedded device's limited computing resources. The prevailing approaches either require the deployment of the software on the embedded target, which can be tedious and may be impossible in an early development phase, or rely on simulation, which can be very slow. In this article, we introduce a customizable cross‐profiling framework for embedded Java processors, including processors featuring a method cache. The developer profiles the embedded software in the host environment, completely decoupled from the target system, on any standard Java virtual machine, but the generated profiles represent the execution time metric of the target system. Our cross‐profiling framework is based on bytecode instrumentation. We identify several pointcuts in the execution of bytecode that need to be instrumented in order to estimate the CPU cycle consumption on the target system. An evaluation using the JOP embedded Java processor as target confirms that our approach reconciles high profile accuracy with moderate overhead. Our cross‐profiling framework also enables the performance evaluation of new processor architectures before they are implemented. As a case study, we explore the performance impact of various processor design choices and optimizations, such as different cache sizes or pipeline organizations, and come up with an improved processor design that yields speedups of up to 40% on standard Java benchmarks. Copyright © 2009 John Wiley & Sons, Ltd.     

A framework for high‐performance matrix multiplication based on hierarchical abstractions,algorithms and optimized low‐level kernels

Despite extensive research, optimal performance has not easily been available previously for matrix multiplication (especially for large matrices) on most architectures because of the lack of a structured approach and the limitations imposed by matrix storage formats. A simple but effective framework is presented here that lays the foundation for building high‐performance matrix‐multiplication codes in a structured, portable and efficient manner. The resulting codes are validated on three different representative RISC and CISC architectures on which they significantly outperform highly optimized libraries such as ATLAS and other competing methodologies reported in the literature. The main component of the proposed approach is a hierarchical storage format that efficiently generalizes the applicability of the memory hierarchy friendly Morton ordering to arbitrary‐sized matrices. The storage format supports polyalgorithms, which are shown here to be essential for obtaining the best possible performance for a range of problem sizes. Several algorithmic advances are made in this paper, including an oscillating iterative algorithm for matrix multiplication and a variable recursion cutoff criterion for Strassen's algorithm. The authors expose the need to standardize linear algebra kernel interfaces, distinct from the BLAS, for writing portable high‐performance code. These kernel routines operate on small blocks that fit in the L1 cache. The performance advantages of the proposed framework can be effectively delivered to new and existing applications through the use of object‐oriented or compiler‐based approaches. Copyright © 2002 John Wiley & Sons, Ltd.     

PIN‐OLEDs for active‐matrix‐display use

Abstract— Novaled's PIN‐OLED® technology allows for highly efficient, temperature stable, and long‐lived OLEDs suited for a variety of display applications. This paper delivers an overview about Novaled's state of the art, including top‐ and bottom‐emitting structures. It is discussed how PIN‐OLEDs give rise to an increased manufacturing yield. The main focus of this paper is the development of white OLEDs for display use. When the RGBW color‐filter approach is used in combination with white OLEDs, the resulting full‐color OLED display is able to deliver high color quality and remain highly power efficient. For such a case, the manufacturing infrastructure of OLEDs for lighting can be used. We use tandem architectures, bottom‐ and top‐emission architectures, and developed specific high‐temperature stable OLED stacks. The importance of matching color coordinates of the white OLED and the targeted display white color point is of outstanding importance. Results have mainly been achieved under the German‐funded project CARO and the European‐funded project AMAZOLED.     

Stepwise‐refinement for performance: a methodology for many‐core programming

Many‐core hardware is targeted specifically at obtaining high performance, but reaching high performance is often challenging because hardware‐specific details have to be taken into account. Although there are many programming systems that try to alleviate many‐core programming, some providing a high‐level language, others providing a low‐level language for control, none of these systems have a clear and systematic methodology as a foundation. In this article, we propose stepwise‐refinement for performance: a novel, clear, and structured methodology for obtaining high performance on many‐cores. We present a system that supports this methodology, offers multiple levels of abstraction to provide programmers a trade‐off between high‐level and low‐level programming, and provides programmers detailed performance feedback. We evaluate our methodology with several widely varying compute kernels on two different many‐core architectures: a Graphical Processing Unit (GPU) and the Xeon Phi. We show that our methodology gives insight in the performance, and that in almost all cases, we gain a substantial performance improvement using our methodology. Copyright © 2015 John Wiley & Sons, Ltd.