Edy S. Liongosari

UniCast, OutCast & GroupCast: Three Steps Toward Ubiquitous, Peripheral Displays

Artifacts and surfaces that can display digital content are proliferating at a steady rate. Many of these displays will be peripheral, i.e., used for content that is not directly related to ones primary activities. However, what kinds of content would people want to see on such peripheral displays? We have begun to investigate the use of peripheral displays in three workplace contexts: within an individual office (Uni-Cast), outside an individual office (OutCast) and in a common area (GroupCast).

Toward software plug-and-play

The growing size and complexity of systems has revealed many shortcomings of existing software engineering practices, for example, lack of scalability. This in turn raised interest in component-based and architecture-driven software development. In all likelihood, component-based software will form the foundation on which future systems will be built. The shift toward developing systems from components has been more evolutionary than revolutionary. It has its roots in accepted architectural principles such as layering, modularization, and information hiding. But it also introduces its own principles and concepts and presents new challenges. This paper discusses research ideas and technologies that will facilitate the transition toward component-based software development by leveraging object-oriented middleware technologies such as CORBA and OLE. We also present an innovative component-based development environment to illustrate the ideas we introduce.

Automatic Test Generation From GUI Applications For Testing Web Services

Graphical User Interface (GUI) Applications (GAPs) are ubiquitous and provide various services. Since many GAPs are not designed to exchange information (i.e., intemperate), companies replace legacy GAPs with web services, that are designed to intemperate over the Internet. However, it is laborious and inefficient to create unit test cases to test the web services. We propose a novel approach for generating tests for web services from legacy GAPs. This approach combines accessibility technologies for accessing and controlling GAPs in a uniform way with a visualization mechanism that enables nonprogrammers to generate unit test cases for web services by performing drag-and-drop operations on GUI elements of legacy GAPs. We built a tool based on our approach, and we used this tool to generate unit test cases from different GAPs. We believe that our approach is unique, and our evaluation suggests that our approach is effective and it can be used to generate test cases from nontrivial GAPs.

In search of a new generation of knowledge management applications

Todays typical Knowledge Management systems are not much different from document management systems. In both cases, the retrieval process involves entering a set of keywords and then browsing through a list of documents related to those keywords found by the systems. If Knowledge Management is to live up to its promises, a new generation of Knowledge Management-enabled applications has to be developed. The information has to be presented beyond just a list of documents. Applying data mining techniques to these systems is one of the few promising avenues that may yield a new set of applications. This paper describes our on-going research effort to extract and mine information from one of the largest private Knowledge Management systems in the world.

Architectural Mismatch in Service-Oriented Architectures

Architectural mismatch results from implicit and conflicting assumptions that designers of components make about the environments in which these components should operate. While architectural mismatch was extensively studied in monolithic and distributed applications, it has not been applied to service-oriented architectures (SOAs). A major contribution of this paper is the analysis of how architectural mismatch affects SOAs. We study how implicit and conflicting assumptions that designers make about web services and their compositions affect the quality of resulting SOA-based systems. We support our analysis with empirical data that we collected from a large-scale SOA-based project within Accenture and other smaller projects.

BAL/SRW: Assembler re-engineering workbench

Abstract BAL/SRW is a knowledge-based interactive software re-engineering workbench for IBM 370 Assembler programs. It assists its user in recovering design specifications directly from Assembler code. BAL/SRW uses a number of re-engineering techniques, including automated code pattern understanding, source code browsing/navigation, control flow analysis, structure simplification and abstraction, and program annotation. It also uses a set of diagramming tools to facilitate capture of program design. The output of BAL/SRW can be fed into computer-aided software engineering (CASE) tools to be used in the forward phase of system re-engineering. The paper describes the major components of the workbench in the context of how they help the analyst examine, abstract, and capture the design information of Assembler programs. It also discusses practical experience in using the workbench on a re-engineering project.

COBOL/SRE: A COBOL System Renovation Environment

COBOL/SRE is a software reengineering and renovation environment for COBOL systems. It supports a wide range of features such as system-level analysis and browsing, program-level analysis and browsing, data model recovery, concept recognition, and code segmentation. COBOL/SRE is implemented on top of a distributed execution architecture to address issues of multi-user access, performance and openness. An overview of the major features of COBOL/SRE and its underlying architecture is given.

Architecture specification support for component integration

The paper describes an approach to automating the construction of software systems from components. We illustrate how integration-related concerns such as component interfacing, interconnection, distribution and configuration can be modeled with a specification language. We also show how a graphics-based design environment can be used to support visual specification and transformation of integration specifications into implementations. This approach raises the level of architecture specifications to assist the currently labor-intensive and error-prone process of system integration.<<ETX>>

Understanding code architectures via interactive exploration and layout of layered diagrams

Visualization tools that target helping developers understand software have typically had visual scalability limitations, requiring significant input before providing useful results. In contrast, we present Strata, which has been designed to actively help users by providing layered diagrams. The defaults used are based on the package structure, and user interactions can allow for overriding these defaults and focusing on relevant parts of the codebase.