Joon-Sang Lee

An automated refactoring approach to design pattern-based program transformations in Java programs

Software often needs to be modified to accommodate requirements changes during the software lifecycle. To deal with several accidental requirements changes related to software maintenance, a systematic and safe approach to modifying software is needed. Design patterns provide a high degree of design flexibility for such accidental requirements changes. In this paper, we propose an automated approach to refactoring based on design patterns in Java programs. In our approach, for a particular design pattern, we define an inference rule to automatically identify a set of candidate spots and a refactoring strategy to transform a candidate spot into the desired design pattern structure. A candidate spot may be a class or a set of classes to which design patterns can be applied. We believe that our approach would be helpful to maintainers in the sense that much manual analysis of source code can be reduced, and the method of automated program transformation preserves behavior of the original program by means of the refactoring technique.

An enhanced role model for alleviating the role-binding anomaly

Roles and role models have received much attention as useful concepts for developing highly reusable and dynamically evolvable systems. Role models belong to the category of collaboration‐based development techniques, but most of the existing approaches to role models do not explicitly incorporate the core principle of collaboration‐based developments as an essential property of their primary design goals. Consequently, the existing approaches still suffer from a problematic phenomenon that the structural and behavioral constraints defined in a role system can be violated during the role‐binding stage. We call such a problematic phenomenon the role‐binding anomaly. In order to alleviate the role‐binding anomaly, we propose an enhanced role model, in which all role instances and core objects can exist by themselves, namely, they can be developed, executed, and tested independently. Roles and core classes can be bound to each other at the instance level. In addition, the role system describes and encapsulates the behavior for dynamic reconfigurations among role instances. The enhanced role model is designed so as to be meaningful with respect to software engineering principles, rather than dynamic evolution. It also facilitates role model implementation using general programming languages (i.e. not supporting dynamic specialization) such as Java. To illustrate how the proposed role model makes such benefits, we develop a set of Java classes necessary for implementing the enhanced role model in the form of a Java package role, and present a simplified automatic teller machine system as an example application. Copyright

AN APPROACH TO CHECKING BEHAVIORAL COMPATIBILITY BETWEEN WEB SERVICES

This paper proposes an approach to checking behavioral compatibility between Web services. If Web service B can be used in replacement of Web service A in such a way that the replacement is transparent to clients, Web service B is compatible to Web service A. We use state machines with guarded transitions to specify behaviors of Web services. To check compatibility between two Web services, we propose an extended version of the conventional methods rule, which has been used in object-oriented paradigm. To support our approach, we have implemented a tool. First, the tool constructs a state machine for a Web service whose behavior is expressed in WSDL and WSCI. Then, the tool can verify compatibility between Web services by using the extended methods rule.

An aspect-oriented framework for developing component-based software with the collaboration-based architectural style

Component-based development (CBD) technique for software has emerged to fulfill the demand on the reuse of existing artifacts. In comparison to traditional object-oriented techniques, CBD can provide more advanced abstraction concepts such as subsystem-level reusability, gross structure abstraction, and global control flow abstraction. Unfortunately, existing software development techniques are not mature enough to make it come true that components developed in the third party can be used in a highly flexible way. It is notable that there are certain kinds of software requirements, such as non-functional requirements, that must be implemented cross-cutting multiple classes, largely losing the modularity in object-oriented design and implementation code. Therefore, it is not easy that components are reused without consideration of their low-level implementation details. In this article, we propose Aspect-Oriented Development Framework (AODF) in which functional behaviors are encapsulated in each component and connector, and particular non-functional requirements are flexibly tuned separately in the course of software composition. To support the modularity for non-functional requirements in component-based software systems, we devise Aspectual Composition Rules (ACR) and Aspectual Collaborative Composition Rule (ACCR). Note that AODF makes component-based software built to provide both supports of modularity and manageability of non-functional requirements such as synchronization, performance, physical distribution, fault tolerance, atomic transaction, and so on. With the Collaboration-Based architectural style, AODF explicitly enables to deal with nonfunctional requirements at the intra-component and inter-component levels. q 2003 Elsevier B.V. All rights reserved.

Using Metrics for Estimating Maintainability of Web Applications: An Empirical Study

Software maintenance is a very expensive activity in software life cycle. As in conventional systems, Web-based applications also needs a considerable cost of maintenance efforts and in general the more cost because of their inherent complex architecture. To estimate the maintainability cost of software, many software metrics have been proposed. This paper presents the result of an experimental study to explore the relationship between maintainability and some typical software metrics. We have collected time really spent for maintenance activity for Web-based applications. In the experimental study, we have found that for web-based systems, the existing metrics may not be indicators to maintenance effort on the contrary to conventional systems.

Domain-specific language approach to modelling UI architecture of mobile telephony systems

Although there has been a considerable increase in the use of embedded software including mobile telephony applications, the development of embedded software has not proved so manageable as compared with conventional software. From the experience of working with mobile telephony systems for over three years, it is the authors belief that the huge amount of variance in application logics, not the diversity of hardware platforms, is the major obstacle to the development of embedded software. A domain specific language (DSL) for modelling the user interface (UI) architecture of embedded software, especially focusing on telephony applications is proposed. With the proposed DSL, developers can describe the UI architecture of applications by the fundamental domain concepts at a higher level of abstraction. The proposed DSL is based on the concept of scene. A scene is proposed as a unit of UI in the UI architecture and UI-related behaviours are associated with scenes. The result of a pilot project conducted in a major company dedicated to developing mobile telephony applications is also described.

Developing a common operating environment for military application

Interoperability and reusability are major issues in large-scale software system development. Military applications, one of such large scale software systems, have utilized the Common Operating Environment (COE) for the last decade. The COE reduces duplicated development effort and enhances the reusability/interoperability by providing standardized infrastructure and development guidelines. The COE is an intrinsically distributed computing environment, and needs a various techniques in realization. Generally, widely accepted techniques in industry and academic are practical for such environment to implement. We performed a development of the COE pilot project, and in this paper we cover some issues on the COE realization and show certain ways for practical implementation.

Developing distributed software systems by incorporating meta-object protocol (diMOP) with unified modeling language (UML)

Although object-oriented paradigm is becoming a more realistic approach to the development of large-scale software systems, the existing object-oriented notations and methodologies do not fully support the development of distributed object systems. In this paper, we integrate Meta-Object Protocol (MOP) into a de facto standard object-oriented modeling language UML together to build a software architecture for distributed object systems. We propose a high-level extension of conventional MOPs, called diMOP which helps to develop distributed object systems by realizing a reflective architecture. To incorporate diMOP with UML, we introduce two new specification languages: Class Diagram Supporting diMOP (CDSM) and Dynamically Configurable Object-oriented Statemachine (DCOS), which are proposed to replace the class diagram and the state diagram of UML. The two specification languages support the specification of dynamic configuration behaviors as well as incorporating the diMOP. This paper gives a methodology to develop efficiently distributed object systems through UML.

Aspect-Oriented Design (AOD) Technique for Developing Distributed Object-Oriented Systems over the Internet

While software development techniques for identifying specifying, and analyzing functional requirements of software systems are quite mature, existing traditional design methods are not mature enough to capture non-functional requirements such as concurrency, performance, fault tolerance, distribution, and persistence of a software application. Very recently, Aspect-Oriented Programming (AOP) approach has been introduced to provide an implementation-level programming framework for separately developing basic functionalities and non-functionalities of a software application. However, this is just an implementation-level approach. There are still needs for supporting AOP concepts at the design level, and for providing the traceability between the design model and the implementation model. In this paper, we propose an approach called Aspect-Oriented Design (AOD), which supports the concept of AOP at design level, for developing distributed object systems over the Internet. We also demonstrate the usability of the proposed approach with Multi-media Video Conference Systems (MVCS) example.

A User eXperience Evaluation Framework for Mobile Usability

The worldwide mobile software market has grown dramatically since feature phones became popular in the early 1990s. In practice, mobile usability — which can be defined for a resource-constrained device in two ways, namely, User eXperience (UX) and User Interface (UI) — has been regarded as the key to gaining superiority in terms of both market share and customer loyalty. Unfortunately, de facto standards for software design and the development process, such as Unified Modeling Language (UML) and Rational Unified Process (RUP), do not seem to promote mobile usability in a systematic manner in practice. This paper proposes a systematic and generalizable approach to modeling and evaluating the properties of mobile usability, herein treating it as a first-class software quality from the perspective of software engineering. We devise a UX evaluation framework for mobile usability, which we call UX Evaluation Framework (UEF) throughout this paper. A UX is specified by inter-scene interactions between users and terminals of software products using Extended Menu Navigation Viewpoints (EMNVs); then, a model checker, NuSMV, is adopted to observe whether the EMNV model meets a set of given UX properties. Importantly, the analysis and design of RUP is extended to support the co-design of UX and UI so that major roles, activities and artifacts in the UX and UI can be explicitly monitored and controlled by stakeholders. Through case studies, we demonstrate that UEF works properly to treat software products that prioritize mobile usability. Consequently, UEF plays a key role in filling the gap between two research disciplines to address usability: software engineering and human–computer interactions.