The Design & Intelligence Laboratory at Georgia Tech is expanding the capability of its on-demand agent-based simulation generator to enable users to divide components into separate habitats. The Virtual Ecological Research Assistant (VERA) currently provides a concept map creator to designate biotic organisms and abiotic factors with their relevant relationships which then feed parameters into a compiler that generates server-side NetLogo code that is runtime compiled and executed and then outputs to the end user for a line graph displaying the population cycles of the organisms involved. The software enables easy access to generate multiple simulations by changing parameters and settings to meet user chosen goals such as more correctly emulating realistic natural environments or testing potential solutions to a problem. In reality, organisms and abiotic factors are often divided into separate habitats by a variety of factors such as a wall or by their very nature such as an ocean being separate from a landmass. With the additional feature of habitats to the VERA project, we can enable experiments that will show the viability of this approach to create more accurate models.

Despite its vast capacity and associative powers, the human brain does not deal well with interruptions. Particularly in situations where information density is high, such as during a programming task, recovering from an interruption requires extensive time and effort. Although modern program development environments have begun to recognize this problem, none of these tools take into account the brain's structure and limitations. In this paper, we present a conceptual framework for understanding the strengths and weaknesses of human memory, particularly with respect to it ability to deal with work interruptions. The framework explains empirical results obtained from experiments in which programmers were interrupted while working. Based on the framework, we discuss programmer information needs that development tools must satisfy and suggest several memory aids such tools could provide. We also describe our prototype implementation of these memory aids.

In this paper, we describe the evolution of an interactive technology called the Ecological Modeling Toolkit (EMT) that supports learning about complex ecological systems in middle school science. Authentic learning of science is facilitated by imitation, rehearsal and understanding of real-world scientific practices such as observation, experimentation, problem formulation, hypothesis testing, and model construction and revision. We illustrate how the tools in EMT work together to support many real-world scientific practices such as model construction, simulation and revision, and scaffold others such as observation, problem formulation and hypothesis testing.

We describe a technique that takes conceptual, declarative Structure-Behavior-Function (SBF) models of a complex system, and simulates the behavior of the system in Net Logo, an agent-based simulation environment. Our technique uses a library of behavior patterns, where a behavior pattern is a parameterized generic abstraction over classes of SBF models. Given an SBF model constructed by a student, our technique first recognizes the model as an instance of a behavior pattern, then uses the parameters of the pattern to set up the Net Logo simulation, and finally runs the simulation to produce an animation that acts as feedback on the conceptual model.

The core problem we address in this paper is how to take a declarative conceptual representation of a complex system and produce an agent-based simulation of that model. In particular, we describe a computational technique that takes Structure-Behavior-Function models of complex systems and simulates the behavior of the modeled system in NetLogo, an agent-based programming and simulation environment. This technique has been implemented in an interactive learning environment to promote complex systems learning among middle school students.

Developers must actively maintain status information about the programming tasks they are engaged in. Unfortunately, much of this knowledge does not exist in tangible form. Commonly, developers are forced to recover the details of this knowledge after encountering an unanticipated interruption. In this paper, we present a technique enabling developers to quickly reengage in a task after such an interruption. A dashboard visualization, called TaskBoard, of intermediate task knowledge is constructed from recent activities and program executions and then displayed to assist reengagement. Developers can annotate its contents with task descriptions and prospective cues.

Interruptions are a daily reality for professional programmers. Unfortunately, the strategies programmers use to recover lost knowledge and resume work have not yet been well studied. In this paper, we perform exploratory analysis on 10,000 recorded programming sessions of 85 programmers to understand the variety of strategies used by programmers for resuming programming tasks. In our study, we find that only 10% of the programming sessions have coding activity start in less than a minute, only 7% of the programming sessions involve no navigation to other locations prior to editing, and find evidence of programmers seeking other sources of task context during task resumption. Based on the analysis, we suggest how task resumption might be better supported in future development tools.

Ectropic Design is a feature-oriented, collaborative design method, patterned on Open Source software development. Software evolves ectropically through the continuous augmentation of its features, which are bound to specific program goals. These evolving features are defined in terms of the end-user goals the features achieve and how the features interact, both statically and dynamically, with other features. By binding source code and collaboration technology to identified program goals, Ectropic Design provides developers with the necessary mechanisms to enhance software continuously, while maintaining the conceptual integrity of the program.Ectropic Design is taught as a part of our curriculum's Sophomore required course on Objects and Desig. In the course, we introduce students to CRC cards (Class, Responsibility, Collaborator cards) and scenarios. Traditionally, CRC cards are simply 3x5 index cards, one for each class being considered in a design, annotated with two columns: One for the responsibilities of that class, and the other with the collaborators that the class will need to complete the responsibilities. Scenarios are narrative descriptions of how the system being designed should respond to user-initated events.We have students understand enjoy, and actually use CRC cards in the introductory object-oriented design process. We attempted to teach a more sophisticated design process that would grow upon the students' interest in CRC Cards, and we provided a design tool to support that process. The Ectropic Collaborative Design Environment, ECoDE, is a development tool designed to capture CRC Cards and Scenarios, and it provides a natural mechanism for tying these two design notions to the underlying code the students were writing.The results of using ECode in the class were not as promising as we had hoped. Students did develop much better scenarios than they had in the past, but they did not use the ties to code at all. More importantly, students found that ECoDE actually stifled their collaborations: With current computer monitors, it's much easier to gather around a table full of 3x5 cards than a screen of graphical index cards.Students expressed frustration in having to learn how to use ECoDE, and indicated that they were more comfortable with pencil and paper. An important indicator of the usability of ECoDE was the decision of the student whether to use ECoDE for the final two design submissions ---for it they were free to choose not to use ECoDE. It is interesting to note that 68.5% of the students voluntarily chose to use ECoDE. The top reason given for choosing to use ECoDE was its simplicity in updating their previous design versions. Of the students who chose not to use ECoDE, the reason most frequently given was that they preferred pencil and paper (44%). Subjectively, the subject group documentation was much more detailed in nature. Many of the subject group students demonstrated a clearer personal understanding of their actual design.A high level conclusion of our study could be, "Beginning students will not willingly use a detailed design process", but that is a little too simplistic. The students did appreciate CRC cards and willingly used them. They did also use some of the aspects of the Ectropic Design process, such as the emphasis on scenarios. But simply putting things in a computer tool does not make them better. Student's primary goal is the completion of the program, not the design. The limitations of a one semester course makes it difficult to make it otherwise. It is the challenge of educators to build design tools that will be adopted that meet that goal. Studying ECode has given us some insight on how best to proceed to meet that challenge.

Reverse engineering a program constructs a high-level representation suitable for various software development purposes such as documentation or reengineering. Unfortunately however, there are no established guidelines to assess the adequacy of such a representation. We propose two such criteria, completeness and accuracy, and show how they can be determined during the course of reversing the representation. A representation is successfully reversed when it is given as input to a suitable code generator, and a program equivalent to the original is produced. To explore this idea, we reverse engineer a small but complex numerical application, represent our understanding using algebraic specifications, and then use a code generator to produce code from the specification. We discuss the strengths and weaknesses of the approach as well as alternative approaches to reverse engineering adequacy.

Evolving an existing software system is fundamentally different from developing one from scratch. Consequently, tools to support evolution must go beyond traditional development tools. The paper describes the Esprit de Corps Suite (EDCS) of software evolution tools. EDCS supports the mission oriented architectural legacy evolution (MORALE) software reengineering process. The paper briefly describes MORALE before presenting the individual tools and how they interoperate to support legacy system evolution.

A large portion of software development effort is focused on modification and evolution of existing software systems. To feed forward-engineering and design activities, analysts must first recover and synthesize a complete and consistent set of architectural representations. Architectural Synthesis is one method to build this representation. During the Architectural Synthesis of a software system, an analyst must combine information derived from a variety of sources (which we call perspectives). This combination process requires the analyst to make decisions about which elements in the perspectives denote the same underlying parts of the software system. We present an automated technique for matching these elements based upon a mathematical technique called concept analysis. This technique constructs a spectrum of matching relations using a lattice of concepts drawn from the perspectives and descriptive information about the system's application domain. The results show the promise of using concept analysis to match elements and aid in synthesizing a large number of perspectives.

Program understanding relates a computer program to the goals and requirements it is designed to accomplish. Application-domain analysis is a source of information that can aid program understanding by guiding the source-code analysis and providing structure to its results. The authors use the term "dowsing" to describe the process of exploring software and the related documentation from an application-domain point of view. They have designed a tool framework to support dowsing and have populated it with a variety of commercial and research tools.

Automated user-interface generation environments have been criticized for their failure to deliver rich and powerful interactive applications. To specify more powerful systems, designers require multiple specialized modeling notations. The model-composition problem is concerned with automatically deriving powerful, correct, and efficient user interfaces from multiple models specified in different notations. Solutions balance the advantages of separating code generation into specialized code generators with deep, model-specific knowledge against the correctness and efficiency obstacles that result from such separation. We present a correct and efficient solution that maximizes the advantage of separation through run-time composition mechanisms.

Software evolution is the most costly and time-consuming software development activity, yet software engineering research is predominantly concerned with initial development. MORALE is a development method specifically designed for evolving software. It features an inquiry-based approach to eliciting change requirements, a reverse engineering technique for extracting architectural information from existing code, an approach to impact assessment that determines the extent to which the existing system's architectural components can be reused in the evolved version, a reflective approach to actually perform the evolution, and a specific technique for dealing with the difficulties that arise when evolving user interfaces. MORALE is described in the context of making a specific change to an existing system: adding user-configurable viewers to Version 2.4 of the Mosaic Web browser. Issues that arise are discussed, and the Esprit de Corps tool-suite is described

Current software reengineering technology is typically based on program analysis methods such as parsing and data flow analysis. This is inadequate for two reasons. First, such methods inherently fail to capture the context or purpose of the program. Second, the results of the program comprehension are not directly usable in program evolution. We introduce a method that addresses both of these problems. We use a domain model to understand the context of a program and an object oriented framework to record that understanding. The main step of this method consists of the construction of an executable domain model whose scope covers a family of target programs. A program is then reverse engineered using the domain model both as a guide and as a recording medium. In the last step, developers reengineer the target artifact using its abstract domain driven representation. We present a thorough example to illustrate this approach. Issues raised by the confluence of domain analysis and representation, reverse engineering, and artifact evolution are discussed. Implications on future work in the area are suggested.

The various goals and requirements of a system are realized in software as fragments of code that are typically "interleaved" in that they may be woven together in the same contiguous textual area of code. The fragments of code are often delocalized and overlap rather than being composed in a simple linear sequence. Interleaving severely complicates software comprehension and maintenance. To address this problem, we are developing analysis tools, based on the Software Refinery. This paper describes our experiences in detecting interleaving in a corpus of mathematical software written in Fortran from the Jet Propulsion Laboratory. In particular, it discusses how feasible it is to detect interleaving of various types and the ability of existing tools to assist these types of detection.

Current reverse engineering technology is typically based on program analysis methods such as parsing and data flow analysis. As such, it is limited in what it can accomplish. Knowledge of the application domain containing a program can help overcome this limit and aid the comprehension process. The paper discusses the relationship of application domain analysis and reverse engineering. Two case studies are presented. The first describes how domain knowledge, expressed as an object-oriented framework, can aid the reverse engineering process for a well-understood domain. The second studies how reverse engineering can be used to build a domain model. Issues raised by the confluence of domain analysis and reverse engineering are discussed, and implications on future work in the area are suggested.>

A significant problem in reengineering large systems is adapting the user interface to a new environment. Often, drastic changes in the user interface are inevitable, as in migrating a text-based system to a workstation with graphical user interface capabilities. This experience report chronicles a study of user interface migration issues, examining and evaluating current tools and techniques. It also describes a case study under taken to explore the use of knowledge engineering to aid in migrating interfaces across platforms.>

It is becoming increasingly desirable to move older application programs from their traditional mainframe execution environments to networked workstations. These management information systems are most often written in COBOL and store their data in files. A networked environment enables the use of a relational database management system and its fourth-generation access language, SQL. A conceptual framework is described that comprises a variety of strategies for making such a transition. Decision criteria for selecting among them are then presented. Finally, a variety of experiments intended to explore the strategies are recounted. The experiments include efforts to automate parts of the process.>

A strategy for quickly producing special-purpose tools is described. The strategy combines existing tools including simple off-the-shelf text processing tools; rule-based, language-specific analysis tool; and a commercial CASE (computer-aided software engineering) tool. The strategy has been successfully used in the context of the maintenance and reverse engineering of a large, real-time software system used for telephony. The approach is illustrated by examples that include the generation of cross reference information, calling trees, run-time stack analysis, and code restructuring.>

A real-time embedded system was the subject of a series of experiments in reverse engineering. These experiments used a method of reverse engineering, called synchronized refinement, that analyzes a program, describing its behavior in the vocabulary of the application domain and its structure in terms of design decisions. The results provide insight into the role of domain knowledge in this type of analysis, together with the tools used in the detailed analysis of code. The experiments, which included the redesign of a component and the diagnosis of a critical software failure, showed that the real work of a software maintenance is in resolving apparent inconsistencies between the expectations that have been derived from domain knowledge and the facts that have been uncovered by applying reverse engineering tools to the software.>