Tomas Cerny

Aspect-driven, data-reflective and context-aware user interfaces design

The increasing use of Web-based applications continues to broaden the user groups of enterprise applications at large. Since ordinary users often equate the quality of user interface (UI) with the quality of the entire application, the importance of providing easy-to-use UIs has been significantly increasing. Unfortunately, designing a single UI satisfying all end users remains challenging. To address this issue, researchers and developers are looking to Context-aware/Adaptive UIs (CUIs) that aim to provide end users with more personalized user interaction experiences. Although multiple proposals have been made, very few production systems provide such malleable interfaces due to the excessive cost of development and maintenance. In this paper, we propose a technique that aims to reduce development and maintenance efforts of CUI to a level comparable with a single UI. Unlike most of the existing CUI approaches, our technique does not involve an external UI model. Instead, it aims to reflect runtime-information and structures already captured in the application, while extending them to provide an appropriate CUI. With this technique, developers do not design forms or tables directly for each page or panel. Instead they design generic and reusable transformation rules capable of presenting application data instances in the UI while considering the runtime context. To demonstrate our technique and its impact on CUI development and maintenance, we provide a case study. Moreover, we present our experience from its application to an existing production-level enterprise application, with high demands on performance.

Context-sensitive, cross-platform user interface generation

User interfaces (UI) of software applications play a crucial part in communication with users. Attractive UIs often lead to market success, and thus there is a significant incentive to provide users with malleable UIs that can adapt as much as possible to their needs. However, such UIs require significant development and maintenance efforts. In this paper, we describe a context model based on ability-based design that is well suited to the purposes of automated UI generation. We then introduce a platform that delivers adaptive UIs across various platforms. We use runtime combinatoric optimisation to support usability and to generate context-sensitive UIs. Since the development and maintenance of such UIs can be complex, our platform integrates a module for code-inspection for data-oriented applications to reduce these efforts. It also utilises a visual editor to simplify manual UI design.

On separation of platform-independent particles in user interfaces

The complexity of user interface (UI) design grows quickly with the number of application concerns. Such complexity compounds with additional requirement of contextual-awareness (i.e., adapt to user location, skill level, etc.) and support of heterogeneous devices and platforms (e.g., web, mobile app). Implementation support of such a wide-range of orthogonal concerns often results in restatement of a significant portion of the UI description using platform-specific components. Replication requires repeated implementation decision, greatly increasing development costs since each version/context variant may need separate development. Naturally, such replication also produces error prone maintenance because code updates must correlate among all replicas. Using separation of concerns, the application can be decomposed into fine-grain fragments, which we call particles, some of which are platform independent and others are not. Using this decomposition, this paper addresses the above inefficiency by dynamically composing particles at runtime that match user demands, context, and target platform.

Aspect-Driven Design of Information Systems

Contemporary enterprise web applications deal with a large stack of different kinds of concerns involving business rules, security policies, cross-cutting configuration, etc. At the same time, increasing demands on user interface complexity make designers to consider the above concerns in the presentation. To locate a concern knowledge, we try to identify an appropriate system component with the concern definition. Unfortunately, this is not always possible, since there exist concerns cross-cutting multiple components. Thus to capture the entire knowledge we need to locate multiple components. In addition to it, often, we must restate the knowledge in the user interface because of technological incompatibility between the knowledge source and the user interface language. Such design suffers from tangled and hard to read code, due to the cross-cutting concerns and also from restated information and duplicated knowledge. This leads to a product that is hard to maintain, a small change becomes expensive, error-prone and tedious due to the necessity of manual changes in multiple locations.

Automated Business Rules Transformation into a Persistence Layer

Abstract Enterprise Information Systems maintain data with respect to various business processes. These processes consist of business operations restricted by business rules expressed as preconditions and post-conditions. Each rule must be considered and enforced throughout the system, from user interface to persistence storage. Such rule evaluation in multiple contexts results in both significant rule restatement and high maintenance complexity, as there is no single focal point for capturing and reusing these rules. In this paper, we apply the Aspect-Oriented Design Approach to the persistence layer to simplify business rules management, enforce business rules throughout the system and consequently decrease development and maintenance efforts. Our preliminary results show that it is possible to define business rules in a single place and then apply them automatically in a persistence layer. We retrieve data sets restricted by given operation post-conditions with respect to current execution context without any manual rule restatement. This paper provides a small case study emphasizing the benefits and future challenges.

Towards effective adaptive user interfaces design

The increasing use of Web-based applications continues to broaden the user groups of enterprise applications at large. The importance of providing easy-to-use user interfaces (UIs) that conform to each users specific preferences, such as different skill levels, capabilities and physical locations has, therefore, been significantly increasing. Unfortunately, designing a single UI satisfying all end users remains challenging. To address this issue, researchers and developer are looking to Adaptive User Interfaces (AUIs) that aim to provide end users with more personalized user interaction experiences. However, very few production system provide such malleable interfaces due to the excessive cost for the development and maintenance. In this paper, we propose a technique that provides AUIs for production enterprise systems while reducing development and maintenance efforts to a level comparable with a single UI development, called Rich Entity Aspect/Audit Design (READ). READ complies with application development standards used in industry to support an easy transition from design to production systems. We conclude by evaluating our approach along with a case study that demonstrates reduction in development and maintenance efforts while preserving performance.

How to reduce costs of business logic maintenance

Three tier enterprise applications introduce multiple challenges for software engineers. Although we can divide the application into three tiers, we still need to design properly each tier internally to achieve multiple design qualities. The middle business tier captures logic in which we associate objects, validate business rules, etc. Often multiple cross-cutting concerns are mixed in the services which results in bloated, highly coupled design with very low cohesion. In this paper we present a case study that we develop based on our four year experience with enterprise application that struggled from multiple weak design decisions. We emphasize multiple aspects that should be decoupled from the rest of the services which increase service cohesion and results in better readability, maintenance, testability, reuse and error-avoidance. Our “best practices” suggestions for business tier are generally applicable and allow the designer to separate service concerns into multiple units allowing to achieve the mentioned quality attributes.

Contextual understanding of microservice architecture: current and future directions

Current industry trends in enterprise architectures indicate movement from Service-Oriented Architecture (SOA) to Microservices. By understanding the key differences between these two approaches and their features, we can design a more effective Microservice architecture by avoiding SOA pitfalls. To do this, we must know why this shift is happening and how key SOA functionality is addressed by key features of the Microservice-based system. Unfortunately, Microservices do not address all SOA shortcomings. In addition, Microservices introduce new challenges. This work provides a detailed analysis of the differences between these two architectures and their features. Next, we describe both research and industry perspectives on the strengths and weaknesses of both architectural directions. Finally, we perform a systematic mapping study related to Microservice research, identifying interest and challenges in multiple categories from a range of recent research.

Efficient description and cache performance in Aspect-Oriented user interface design

Increasing demands on web user interface (UI) usability, adaptability, and dynamic behavior drives ever growing development and maintenance complexity. Conventional design approaches scale poorly with such rising complexity, resulting in rapidly increasing costs. Much of the complexity centers around data presentation and processing. Recent work greatly reduces such data complexity through the application of Aspect-Oriented UI (AOUI) design, which separates various UI concerns; however, rendering in conventional and even AOUI approaches fails to maintain this separation, often resulting in high repetitions of concern fragments due to tangling. Even worse, mixing of dynamic and immutable components greatly limits caching efficacy as each have differing lifetimes. We extend AOUI design to push down concern separation to rendering, which reduces description size, through repetition reduction, and enables separate caching of individual concerns. Our results show considerable size reduction of UI descriptions for data presentations, faster load times and extended caching capabilities.

Towards Smart User Interface Design

User interface development and maintenance presents a burden for many developers. UI development approaches often restate information already captured in the application model such as entity attributes, validation, security, etc. Changes in application model often require many subsequent changes to the UI. Such duplication creates additional maintenance requirements for synchronization (at a minimum) and often is a source for errors (i.e., when model and UI disagree). Adding to the difficulties of creation and maintenance, typical UI implementations often tangle multiple concerns together such as presentation, validation, layout, security, etc. In this paper, we provide an approach that reduces information duplication and untangles mixed concerns. The capability of runtime UI generation can render user-specific UI, reduce conditional evaluation, and integrate third party security frameworks. To evaluate our approach, we provide a case study that demonstrates reduction of maintenance efforts, separation of concerns and performance of runtime UI generation.