Arthur G. Ryman

Visualizing and querying software structures

Software engineering problems often involve large sets of objects and complex relationships among them. This report proposes that graphical visualization techniques can help engineers undersland and solve a class of these problems. To illustrate this, two problems are analyzed and recast using the graphical language GraphLog. The first problem is that of simplifying dependencies among components of a system, which translates into removing cycles from a graph. The second problem is that of designing an efficient code overlay structure, which is facilitated in several ways through graphical techniques.

Architecture and applications of the Hy + visualization system

The Hy + system is a generic visualization tool that supports a novel visual query language called GraphLog. In Hy + , visualizations are based on a graphical formalism that allows comprehensible representations of databases, queries, and query answers to be interactively manipulated. This paper describes the design, architecture, and features of Hy + with a number of applications in software engineering and network management.

IBM visualage for Java

This paper introduces the IBM VisualAge® for JavaTM product, a robust, visual suite of tools designed for rapid prototyping and enterprise application development. The paper outlines the development-time benefits of using VisualAge for Java.

WebSphere Studio overview

In this paper we provide an overview of IBM WebSphere Studio, a family of tools for developing distributed applications for J2EE™ servers for state-of-the-art information technology systems. In todays business environment such systems are complex, comprise multiple platforms, and make use of a wide range of technologies and standards. Through a representative development scenario we illustrate the way WebSphere Studio satisfies the challenging requirements for a modern integrated development environment. The scenario covers a variety of technologies and standards, including database access, Web services standards, Enterprise JavaBeans™ implementation, integrated application testing, Web page design, and performance optimization. We also describe the Eclipse Modeling Framework, the open source technology base on which WebSphere Studio is built.

Developing XML web services with WebSphere studio application developer

Web services have recently emerged as a powerful technology for integrating heterogeneous applications over the Internet. The widespread adoption of Web services promises to usher in an exciting new generation of advanced distributed applications. These will support a new and growing set of specifications, such as Simple Object Access Protocol (SOAP), Web Services Description Language (WSDL), and Universal Description, Discovery, and Integration (UDDI). Extensible Markup Language (XML) and its associated family of standards also play a central role in Web services by providing a data interchange format that is independent of both programming languages and operating systems. The application developer seeking to reap the benefits of Web services is therefore faced with a significant, and potentially steep, new learning curve. Clearly, application development tools that lower this barrier are crucial for the rapid and widespread adoption of Web services. This paper discusses the development tasks associated with XML Web services and describes a new suite of tools that improve developer productivity, by reducing the requirements for detailed knowledge of the underlying specifications and standards, and allow the developer to focus on the business problem domain. This suite of XML and Web services tools is part of IBMs recently released WebSphere® Studio Application Developer product, which is based on the new Eclipse open source tool integration platform.

Constructing Software Design Theories and Models

Software design methods are often taught informally and supported by CASE tools that do not make their underlying rules, or theory, explicit. The user of such a method is concerned with constructing a model of the system being built that satisfies the theory of this method. We suggest that it is useful to make the underlying design theory explicit, and to allow the designer to extend it to more closely describe the system being built. This paper describes 4Thought, a tool for constructing theories and models, which combines conceptual modeling (Entity-Relationship), graphical database visualization (higraphs), and visual logic programming (GraphLog).

Where's My Jetpack?

Software development tools often fail to deliver on inflated promises. Rather than the predicted progression toward ever-increasing levels of abstraction, two simple trends have driven the evolution of currently available software development tools: integration at the source-code level and a focus on quality. Thus source code has become the bus that tools tap into for communicating with other tools. Also, focus has shifted from defect removal in the later phases to defect prevention in the earlier phases. In the future, tools are likely to support higher levels of abstraction, perhaps in the form of domain-specific languages communicated using XML.

Personal systems image application architecture: lessons learned from the ImagEdit program

Image applications require complex processing on large amounts of data. The application designer is presented with difficult challenges that are exacerbated on personal systems which have limited processor speed and constrained memory. This paper discusses the problems relevant to personal systems image application architecture and how these problems were solved in the ImagEdit® program. A virtual array manager (VAM) consisting of a virtual memory manager (VMM) and an access scheduler was used to solve the data management problem. The VAM divided each image into segments and transferred them to the VMM for storage. These segments were swapped between memory and disk in response to a sequence of access requests, controlled by the access scheduler using performance-maximizing heuristics. Object-oriented design was used to address the functional complexity problem. The processing functions were divided into two classes. The data-stream class included scanning, printing, and filing, with each data-stream function decomposed into a series of demand-driven pipe objects. The editing class included cut and paste, textual and graphical annotation, and freehand drawing.

Visual constraint diagrams: runtime conformance checking of UML object models versus implementations

This paper presents visual constraint diagrams (VCD), an extension to UML (Unified Modeling Language) object diagrams for expressing constraints over object models. VCD allows designers to express well-formedness constraints that cannot be expressed using class diagrams alone; an example of such a constraint is that a linked list data structure cannot have any loops. VCD offers two advances over existing techniques: (1) they allow constraints to be expressed within the visual notation of UML, without resorting to complex textual notations such as OCL; and (2) VCD can be checked at runtime, increasing the value of design documents to developers. An editor and a checker for VCD have been implemented as part of the Rosetta software design tool.

Timesheet assistant: mining and reporting developer effort

Timesheets are an important instrument used to track time spent by team members in a software project on the tasks assigned to them. In a typical project, developers fill timesheets manually on a periodic basis. This is often tedious, time consuming and error prone. Over or under reporting of time spent on tasks causes errors in billing development costs to customers and wrong estimation baselines for future work, which can have serious business consequences. In order to assist developers in filling their timesheets accurately, we present a tool called Timesheet Assistant (TA) that non-intrusively mines developer activities and uses statistical analysis on historical data to estimate the actual effort the developer may have spent on individual assigned tasks. TA further helps the developer or project manager by presenting the details of the activities along with effort data so that the effort may be seen in the context of the actual work performed. We report on an empirical study of TA in a software maintenance project at IBM that provides preliminary validation of its feasibility and usefulness. Some of the limitations of the TA approach and possible ways to address those are also discussed.