Browsing by Author "Liang, Donglin"

Now showing 1 - 9 of 9
  • Thumbnail Image
    Item
    A Monitoring Profile for UML Sequence Diagrams
    (2006-07-24) Xu, Kai; Liang, Donglin
    UML sequence diagrams are widely used during requirements analysis and design for specifying the expected behaviors of a system. In this paper, we present a monitoring profile that extends sequence diagrams to facilitate the comparison between the actual behaviors and expected behaviors of a system. With the profile, the developers can precisely specify the runtime objects to be monitored, the expected sequences of message exchanges among these objects, and the monitoring actions to be performed when the message exchanges are observed. Supported by the tools that we develop, the monitoring actions can inspect program states, verify assertions, record coverage information, and visualize the computation during the progress of various scenarios. These tools allow software developers to effectively use their design knowledge to detect and localize bugs during testing and debugging.
  • Thumbnail Image
    Item
    Aspects for Modularizing Collaborating Behaviors in Method Implementation
    (2005-04-06) Liang, Donglin; Guo, Yi
    A method of a class in an object-oriented (OO) program often must implement collaborating behaviors that require multiple inter-dependent tasks to be performed within the same period of time to accomplish a certain goal. To achieve the separation of concerns in the description of a collaborating behavior, the tasks involved and the protocol through which these tasks interact should be modularized and described separately. This paper presents a new programming technique to support such a modularization strategy during method design. With examples, we illustrate that our technique may allow the achievement of better modularity in an OO program than using existing techniques.
  • Thumbnail Image
    Item
    Debugging Object-Oriented Programs with Behavior Views
    (2005-04-06) Liang, Donglin; Xu, Kai
    A complex software system may perform many program tasks during execution to provide the required functionalities. To detect and localize bugs related to the implementation of these tasks, the software developers must be able to monitor the progress of the tasks during execution and check whether the actions for these tasks have been performed correctly. This paper presents a debugger to facilitate this monitoring. The debugger introduces a new kind of abstraction, the behavior views, that can be used to specify how the actions for a program task are expected to occur in various scenarios. Enhanced with statements that can check properties at various steps during the progress of the task, a behavior view can be used to monitor whether the actions for the tasks have been performed at the right time, on the right set of data, and with the right effects on the program states. Our initial case study indicates that the debugger can be useful for localizing bugs.
  • Thumbnail Image
    Item
    Effective Language Support for Aspectual Behavior Decomposition
    (2005-04-04) Liang, Donglin; Guo, Yi
    Aspects have been proposed as a new program abstraction to achieve better separation of concerns during software design. Although many aspect-oriented programing (AOP) techniques have been proposed to support the use of aspects, the conceptual framework for characterizing the design problems that can be solved using aspects is not well formulated. The lack of a well-formulated framework makes it difficult for software developers to identify the places where aspects can be best used; it also makes it difficult to evaluate and to improve the techniques that support aspects. In this paper, we propose to formulate a conceptual framework with the concept of collaborating behaviors. Based on this perspective, we discuss the concept of aspectual behavior decomposition and the limitations with the existing AOP techniques in supporting such a decomposition strategy. We also give a brief overview of a new AOP technique that illustrates how some of these limitations can be overcome.
  • Thumbnail Image
    Item
    Monitoring with Behavior View Diagrams for Scenario-Driven Debugging
    (2005-06-08) Liang, Donglin; Xu, Kai
    UML sequence diagrams have been widely used during requirements analysis and design for specifying the expected message exchanges among a set of objects in various scenarios for the program to perform a certain task. In this paper, we present the behavior view diagrams, a type of extended sequence diagrams, to facilitate execution monitoring during debugging. Using a behavior view diagram, the software developers can precisely specify the runtime objects whose behaviors will be monitored during debugging. The software developers can also specify the important message exchanges that are expected to be observed among these objects in various scenarios, and may further define the monitoring actions to be performed for inspecting the program state when a message exchange is observed. We also present a debugger that can automatically monitor the program execution using the information specified in a behavior view diagram. Through this monitoring, the debugger can not only check whether the scenarios are progressed as intended, but also check whether the actions performed by the program have the the desired effects on the program states. Therefore, it can be useful for detecting and localizing bugs.
  • Thumbnail Image
    Item
    Program Execution Monitoring with Scenario Implementation Models
    (2004-09-29) Liang, Donglin; Xu, Kai
    Scenarios have become an important concept for understanding and specifying the required behaviors for a system and its components. To gain confidence for the correctness of the implementation, software developers must compare the scenarios identified during requirements analysis and software design with the behaviors observed during execution. This paper presents an execution monitoring framework that facilitates such a comparison. The framework allows the software developers to specify, in scenario implementation models, how the scenarios are expected to be implemented and used in the program. Enhanced with statements that check properties of the scenarios or visualize the progress of the scenarios, these models can be used to check at runtime whether the scenarios have been implemented and used correctly. Our initial case study indicates that the framework can be useful for uncovering bugs.
  • Thumbnail Image
    Item
    Servicetizing User Experiences for Complex Business Applications
    (2006-08-07) Liang, Donglin; Tsai, Wei-Tek
    Web interfaces have been widely used to support user interactions in complex business applications. In a typical design of such an application, the execution is driven by the http requests sent by the web-browser. Thus, the control of the workflow is encoded by the hyperlinks and buttons embedded in various web pages that support the user interactions. This web-driven design makes it hard to reason about and to maintain the workflows, especially when the web pages are dynamically generated at runtime. This design also increases the complexity in developing rich user interactions for complex workflows. In this paper, we propose a new design that separates the workflow specification from the user interaction specification in a business application. This design is based on a workflow-driven service-oriented architecture pattern. In this architecture, the user interactions are captured by user experience services that can be developed, deployed, and maintained independently of the application. These services can be composed together with other business services by an executable workflow specification to provide the functionalities required by the application. This approach increases the flexibility in the implementation of the user interactions. It also enables a model-driven development approach for implementing the workflows that involve sophisticated user interactions.
  • Thumbnail Image
    Item
    Supporting Scenario-Driven Debugging with Behavior View Diagrams
    (2006-02-09) Liang, Donglin; Xu, Kai
    Software developers often must use their knowledge about the expected behaviors of software and its components to guide debugging. This paper presents a debugging technique that supports the effective use of higher level knowledge of software behaviors in bug investigation. Our technique provides behavior view diagrams (BVDs) as a new type of abstraction for users to specify their expectations of the software behavior based on scenarios. Our technique also provides an algorithm that automatically monitors the program execution based on BVDs. The algorithm can detect and track the important message exchanges that are required for implementing the scenarios. The algorithm can also inspect the program states at various points of time to check whether the scenarios progress as intended. Therefore, our technique can help software developers to uncover and locate bugs by utilizing their knowledge of the scenarios.
  • Thumbnail Image
    Item
    The Modularization of Scenario Implementation
    (2004-12-10) Liang, Donglin
    The notion of ``scenarios'' has become an important concept for understanding and specifying the required behaviors for a software system and its components during requirements gathering, analysis, and software design. Unfortunately, in existing programming languages, there is no programming abstraction for modularizing the implementation of scenarios in a program. Like a cross-cutting concern, when implemented with a traditional programming language, a scenario may have to be implemented with statements that scatter at various locations in the program. These statements may also tangle with the statements that implement other scenarios. This paper presents an extension to object-oriented programming languages that allows the software developers to define, within a scenario implementation module, the implementation for a set of related scenarios that represent the alternative paths that the system and its components will take in performing a specific task. At runtime, the scenario implementation module can be instantiated to observe the execution events within specific program contexts and to perform appropriate scenario actions in response for integrating the scenarios into the program execution. When used properly, this new kind of behavior abstraction can improve the program structures and the traceability of the scenarios from design to implementation.