Various visualization techniques have been adopted to educational Object-Oriented Programming (OOP) environments. Some provide software development with visual notations without source code, while others support programming with visual aids. Our research supports Java programming along with static UML class diagrams and dynamic execution trace of program synchronized in a webbased programming environment - JaguarCode. It aims to help students better understand static structure and dynamic behavior of Java programs, and object-oriented design concepts. This paper reports on an initial evaluation of JaguarCode to investigate its effectiveness and user satisfaction through quantitative and qualitative experiments. The experimental results revealed that having both static and dynamic visualizations did positively impact the correctness of program understanding and tracing problems, and the visual representations did affect students' understanding on program execution of the problems to higher accuracy. It was also observed that students were satisfied with the aspects of those visualizations provided in JaguarCode.

While Object-Oriented programming in Java has been widely adopted as an introductory programming course in Computer Science, it is considered difficult to teach and learn. Studies have identified that the difficulty is from the underlying Object-Oriented concepts and principles. To help student programmers better understand the structure of a program and the concepts of Object-Oriented design, visualizations in various formats have been applied to programming environments. This paper presents a web-based interactive educational programming environment, JavlinaCode, and its unique design principles. JavlinaCode is designed for teaching object-oriented programming in Java. It aims to enhance student programmers' programming skill and to help them understand object-oriented design concepts. It provides integrated static and dynamic visualizations: the static state of a Java program in an UML class diagram and the dynamic run-time state of the program execution. With the synchronized multi-view real time visualization along with source code, JavelinaCode is highly expected to reduce student programmers' cognitive workload in Java programming and to enhance comprehension of the objectoriented programming and design concepts.

We present a multicore-enabled smart storage for clusters in general and MapReduce clusters in particular. The goal of this research is to improve performance of data-intensive parallel applications on clusters by offloading data processing to multicore processors in storage nodes. Compared with traditional storage devices, next-generation disks will have computing capability to reduce computational load of host processors or CPUs. With the advance of processor and memory technologies, smart storage systems are promising devices to perform complex on-disk operations. The proposed smart storage system can avoid moving a huge amount of data back and forth between storage nodes and computing nodes in a cluster. To enhance the performance of data-intensive applications, we have designed a smart storage system called Multicore-enabled Smart Storage (McSD), in which a multicore processor is integrated in storage nodes. We have implemented a programming framework for data-intensive applications running on a computing system coupled with McSD. The programming framework aims at balancing load between computing nodes and multicore-enabled smart storage nodes. To fully utilize multicore processors in smart storage nodes, we have implemented the MapReduce model for McSDs to handle parallel computing on a cluster. A prototype of McSD has been implemented in a cluster connected by Gigabit Ethernet. Experimental results show that McSD can significantly reduce the execution times of three real-world applications - word count, string matching, and matrix multiplication. We demonstrate that the integration of multicore-enabled smart storage with MapReduce clusters is a promising approach to improving overall performance of data-intensive applications on clusters.

Computer supported cooperative work (CSCW) research is the discipline that explores how to utilize computing and networking technologies to facilitate cooperation and collaboration among people. A variety of research has been conducted on CSCW architecture. However, how to ensure CSCW system effectiveness and efficiency on supporting collaboration remains a challenge. In this paper we present a rule mitigated framework for CSCW applications. This research contributes to the state of the art by presenting a robust and comprehensive architecture to support distributed collaboration.

This paper presents a method for test scenario generation based on formal specifications and usage profiles. It is a major component of a framework for testing object-oriented programs. In this framework, the requirements of a software system are formally specified. The anticipated application of the system is expressed in a usage profile, which is a state model that indicates the dynamic behavior of the system and execution probabilities for the behaviors. The state model is used as a guide to derive the anticipated operation scenarios. An enhanced state transition diagram is used to represent the state model, which incorporates hierarchy, usage and parameter information. Since the number of feasible scenarios can be extremely large, probability and importance criteria are used to select the most probable and important scenarios.

This paper presents a prototype computer supported cooperative work (CSCW) environment that supports the engineering design process. In particular, this environment provides collaborative tools that support computer-aided design (CAD) and computer-aided software engineering (CASE). This paper takes an high level look at the system as a whole and then focuses on the method used to implement the CASE support. It addresses how group members can simultaneously work on coding a program and then integrate their work to form a single program inside this environment. © 1998 John Wiley & Sons, Ltd.

Software testing is an important step in the development of complex systems. The construction of test cases using traditional methods usually requires considerable manual effort. QUEST/Ada—Query Utility Environment for Software Testing of Ada, is a prototype test case generation system that uses various heuristics-based approaches to generate test cases. The system, which is designed for unit testing, generates test cases by monitoring the branch coverage progress and intelligently modifying existing test cases to achieve additional coverage. Three heuristics-based approaches along with a random test case generation method were studied to compare their branch coverage performance. Although some constraints are imposed by the prototype, the framework provides a useful foundation for further heuristics-based test case generation research. The design of the system, the heuristic rules used in the system, and an evaluation of each rule’s performance are presented.

Rule-based software test data generation is proposed as an alternative to either path/predicate analysis or random data generation. A prototype rule-based test data generator for Ada programs is constructed and compared to a random test data generator. Four Ada procedures are used in the comparison. Approximately 2000 rule-based test cases and 100000 randomly generated test cases are automatically generated and executed. The success of the two methods is compared using standard coverage metrics. Simple statistical tests showing that even the primitive rule-based test data generation prototype is significantly better than random data generation are performed. This result demonstrates that rule-based test data generation is feasible and shows great promise in assisting test engineers, especially when the rule base is developed further.>

Normally, a plan must be carried out in a world whose behavior cannot be predicted exactly, so that failures (or unexpected events) can occur during execution. A system that is capable of handling such failures is presented. The error recovery process consists of error detection, error identification, and plan repair. The problem of error identification has been solved by using the condition-oriented approach, which is the authors' central theme. Error classification is accomplished by checking the role of failed conditions in the plan. If all conditions in a plan are stored during the plan generation phase, the subplans that are affected by a failed condition can be easily located. Three error categories and the modification processes are described.>

A planning model described in terms of its goal analysis and hierarchical operator representation is presented. With this system, successful plans have been made for nonlinear problems that are described as a conjunction of subgoals. The system uses heuristic rules to analyze the problem, and thus achieves an ordered sequence of subgoals and constraints that can be achieved successively without interfering with each other. The operators are designed in a goal-oriented fashion and are stored in operator hierarchies. During the plan generation phase, each subgoal is mapped into a goal operator, which is further refined to meet details and specific conditions of the problem. As the generation phase follows the analysis, conflicts among subgoals are eliminated implicitly.>

This paper describes an approach to generate task level plans for mechanical assembly using robots. The system generates assembly plans by inferring from the knowledge base of workpiece structures, assembly rules, and robot operations. The novel feature of the system is its goal (workpiece) structure analysis. The goal structure analysis is capable of producing a correctly ordered sequence of subgoals such that the interactions among the subgoals will not interfere with achieving the goal. A plan generator then follows the analysis information to select the appropriate robot operations to formulate the final plan without much searching and reasoning. We believe that this goal-analyzing approach is much closer to human-like planning model than other interaction-resolving planning systems.