Pattern languages in HCI: A critical review

This article presents a critical review of patterns and pattern languages in human-computer interaction (HCI). In recent years, patterns and pattern languages have received considerable attention in HCI for their potential as a means for developing and communicating information and knowledge to support good design. This review examines the background to patterns and pattern languages in HCI, and seeks to locate pattern languages in relation to other approaches to interaction design. The review explores four key issues: What is a pattern? What is a pattern language? How are patterns and pattern languages used? and How are values reflected in the pattern-based approach to design? Following on from the review, a future research agenda is proposed for patterns and pattern languages in HCI

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

QuiiQ automation foundation

Tese de mestrado. Engenharia Informática. Faculdade de Engenharia. Universidade do Porto. 200

TOWARD EASING THE INSTANTIATION OF APPLICATIONS USING GRENJ FRAMEWORK BY MEANS OF A DOMAIN SPECIFIC LANGUAGE

White-box frameworks are a collection of extensible classes representing reusable designs that can be extended, to varying degrees, to instantiate custom-tailored software systems. Due to its inherent benefits (e.g., large-scale reuse of code, design, and domain knowledge), such domain-specific reuse approach has become a de facto standard to implement business systems. However, in order to fully realize the advantages of white-box frameworks, developers need to have substantial architectural and technical knowledge. In effect, developers must be familiar with the framework's extension points (e.g., hot spots) and how to program those extensions using the programming language in which the framework was implemented. GRENJ is a white-box framework implemented in Java. Thus, instantiating applications through such framework is quite complex and demands detailed architectural knowledge and advanced Java programming skills. In order to lessen the amount of source code, effort, and expertise required to instantiate applications by using GRENJ framework, we have developed a domain specific language that manages all application instantiation issues systematically. This domain specific language facilitates the application instantiation process by acting as a facade over GRENJ framework as well as providing the user with a more concise, human-readable syntax than Java. In this paper, we contrast the major differences and benefits resulting from instantiating applications solely using GRENJ framework and indirectly reusing its source code by applying our domain specific language.White-box frameworks are a collection of extensible classes representing reusable designs that can be extended, to varying degrees, to instantiate custom-tailored software systems. Due to its inherent benefits (e.g., large-scale reuse of code, design, and domain knowledge), such domain-specific reuse approach has become a de facto standard to implement business systems. However, in order to fully realize the advantages of white-box frameworks, developers need to have substantial architectural and technical knowledge. In effect, developers must be familiar with the framework's extension points (e.g., hot spots) and how to program those extensions using the programming language in which the framework was implemented. GRENJ is a white-box framework implemented in Java. Thus, instantiating applications through such framework is quite complex and demands detailed architectural knowledge and advanced Java programming skills. In order to lessen the amount of source code, effort, and expertise required to instantiate applications by using GRENJ framework, we have developed a domain specific language that manages all application instantiation issues systematically. This domain specific language facilitates the application instantiation process by acting as a facade over GRENJ framework as well as providing the user with a more concise, human-readable syntax than Java. In this paper, we contrast the major differences and benefits resulting from instantiating applications solely using GRENJ framework and indirectly reusing its source code by applying our domain specific language

Specifying Reuse Interfaces for Task-Oriented Framework Specialization

Reuse of existing carefully designed and tested software improves the quality of new software systems and reduces their development costs. Object-oriented frameworks provide an established means for software reuse on the levels of both architectural design and concrete implementation. Unfortunately, due to frame-works complexity that typically results from their flexibility and overall abstract nature, there are severe problems in using frameworks. Patterns are generally accepted as a convenient way of documenting frameworks and their reuse interfaces. In this thesis it is argued, however, that mere static documentation is not enough to solve the problems related to framework usage. Instead, proper interactive assistance tools are needed in order to enable system-atic framework-based software production. This thesis shows how patterns that document a framework s reuse interface can be represented as dependency graphs, and how dynamic lists of programming tasks can be generated from those graphs to assist the process of using a framework to build an application. This approach to framework specialization combines the ideas of framework cookbooks and task-oriented user interfaces. Tasks provide assistance in (1) cre-ating new code that complies with the framework reuse interface specification, (2) assuring the consistency between existing code and the specification, and (3) adjusting existing code to meet the terms of the specification. Besides illustrating how task-orientation can be applied in the context of using frameworks, this thesis describes a systematic methodology for modeling any framework reuse interface in terms of software patterns based on dependency graphs. The methodology shows how framework-specific reuse interface specifi-cations can be derived from a library of existing reusable pattern hierarchies. Since the methodology focuses on reusing patterns, it also alleviates the recog-nized problem of framework reuse interface specification becoming complicated and unmanageable for frameworks of realistic size. The ideas and methods proposed in this thesis have been tested through imple-menting a framework specialization tool called JavaFrames. JavaFrames uses role-based patterns that specify a reuse interface of a framework to guide frame-work specialization in a task-oriented manner. This thesis reports the results of cases studies in which JavaFrames and the hierarchical framework reuse inter-face modeling methodology were applied to the Struts web application frame-work and the JHotDraw drawing editor framework

A heuristic-based approach to code-smell detection

Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache