Search

Summary: Background: WHO recommends daily iron supplementation for pregnant women, but adherence is poor because of side-effects, effectiveness is low, and there are concerns about possible harm. The iron-regulatory hormone hepcidin can signal when an individual is ready-and-safe to receive iron. We tested whether a hepcidin-guided screen-and-treat approach to combat iron-deficiency anaemia could achieve equivalent efficacy to universal administration, but with lower exposure to iron. Methods: We did a three-arm, randomised, double-blind, non-inferiority trial in 19 rural communities in the Jarra West and Kiang East districts of The Gambia. Eligible participants were pregnant women aged 18–45 years at between 14 weeks and 22 weeks of gestation. We randomly allocated women to either WHO's recommended regimen (ie, a daily UN University, UNICEF, and WHO international multiple-micronutrient preparation [UNIMMAP] containing 60 mg iron), a 60 mg screen-and-treat approach (ie, daily UNIMMAP containing 60 mg iron for 7 days if weekly hepcidin was

Background: Recent genome-wide association and cross-sectional studies have identified novel human genetic polymorphisms associated with alterations in severe malaria risk. Some of the strongest associations have been identified in the ATP2B4 gene. ATP2B4 codes for PMCA4b, the primary regulator of erythrocyte calcium concentration. Methods: To investigate the cellular mechanisms by which polymorphisms in ATP2B4 alter malaria pathogenesis, we performed in vitro assays that model malaria pathogenesis on red blood cells (RBCs) collected from individuals (n=96) with and without copies of ATP2B4 variant haplotype. Findings: We found reduced rates of PMCA4b expression (p

Background: Human neonates elicit a profound hypoferremia to protect against bacterial and fungal sepsis on their first day of life. We examined the transience of this effect by measuring iron and its chaperone proteins, inflammatory and hematological parameters over the first post-partum week. Methods: We prospectively studied term (>37 completed gestational weeks), normal weight (>2500g) newborns at Kanifing General Hospital, The Gambia. Blood was sampled from the umbilical cord vein (CDV) and artery (CDA). Neonatal venous blood was sampled at 6-24h (V1) in all babies who were then randomized to a second blood draw at 25-80h (V2), 81-136h (V3) or 137-192h (V4). Hepcidin, serum iron, transferrin saturation, transferrin, haptoglobin, CRP, AGP, sTfR, ferritin, TIBC, UIBC and full blood count were assayed. Findings: 278 neonates (54.3% males, gestational age 39.4±1.3wk, birth weight 3299±368g) were enrolled. We confirmed the profound early post-natal decrease in serum iron (CDV=22.7±7.0µmol/L to V1=7.3±4.3µmol/L, P

OBJECTIVES: Full-term newborns elicit an immediate postnatal hypoferremia at birth. We examined whether preterm and low birthweight babies are capable of a similar response. The transience of this innate defence in full-term babies was assessed by measuring iron, inflammatory and haematological parameters over the first postpartum week. METHODS: We conducted an observational study of 152 babies who were either preterm (>32 to

Background: Neonates, particularly those born preterm (PTB) and with low birthweight (LBW), are especially susceptible to bacterial and fungal infections that cause an estimated 225,000 deaths annually. Iron is a vital nutrient for the most common organisms causing septicaemia. Full-term babies elicit an immediate postnatal hypoferremia assumed to have evolved as an innate defence. We tested whether PTB and LBW babies are capable of the same response. Methods: We conducted an observational study of 152 babies who were either PTB (born ≥32 to

Background: Iron deficiency is the most prevalent nutritional deficiency worldwide. WHO recommends daily iron supplementation for all pregnant women where anaemia exceeds 40%, but adherence is limited by side-effects, effectiveness is low, and there are concerns around possible harm. The iron-regulatory hormone, hepcidin, signals 'ready-and-safe' to receive iron. We tested a hepcidin-guided screen-and-treat (S&T) approach to combat iron deficiency anaemia (IDA) aimed at achieving equivalent efficacy to universal administration but at lower levels of supplemental iron exposure. Methods: We conducted a 3-arm randomised-controlled double-blind trial in rural Gambia to assess non-inferiority of two ST b) daily UNIMMAP containing 60mg iron for 7d if weekly hepcidin was

Neonates regulate iron at birth and in early postnatal life. We reviewed literature from PubMed and Ovid Medline containing data on umbilical cord and venous blood concentrations of hepcidin and iron, and transferrin saturation (TSAT), in human neonates from 0 to 1 mo of age. Data from 59 studies were used to create reference ranges for hepcidin, iron, and TSAT for full-term-birth (FTB) neonates over the first month of life. In FTB neonates, venous hepcidin increases 100% over the first month of life (to reach 61.1 ng/mL; 95% CI: 20.1, 102.0 ng/mL) compared with umbilical cord blood (29.7 ng/mL; 95% CI: 21.1, 38.3 ng/mL). Cord blood has a high concentration of serum iron (28.4 μmol/L; 95% CI: 26.0, 31.1 μmol/L) and levels of TSAT (51.7%; 95% CI: 46.5%, 56.9%). After a short-lived immediate postnatal hypoferremia, iron and TSAT rebounded to approximately half the levels in the cord by the end of the first month. There were insufficient data to formulate reference ranges for preterm neonates.

This paper presents the data structure animation tool jGRASP, which can automatically generate multiple synchronized views while the underlying code is being developed. The seamless integration of the the IDE with pedagogically effective software visualizations makes jGRASP an interesting tool for both educators and students.

This paper describes efforts to use industry wireless software development practices in the classroom. Nokia's OK Java 2 Platform Micro Edition (J2ME) application certification program was chosen for use in a core set of wireless software engineering courses. The adaptation process included 1) modifying Nokia OK application standards for classroom use as examples of what is expected of industry-quality software; 2) incorporating Nokia OK software development tools into a student-friendly software development environment; and 3) implementing in-house Nokia OK certification procedures as a basis for assessing student projects and providing feedback.

A process-oriented perspective on large student projects guides students in integrating end-to-end life-cycle skills and provides consistency of experience among projects. After conducting 49 Capstone projects, the authors learned that they must cultivate a process culture, that agile processes provide a bridge from ad hoc programming assignments to organized project work, and that process requires a suitable infrastructure of tools and process expertise.

Recently, the first two in a series of planned comprehension experiments were performed to measure the effect of the control structure diagram (CSD) on program comprehensibility. Upper- and lower-division computer science and software engineering students were asked to respond to questions regarding the structure and execution of one source code module of a public domain graphics library. The time taken for each response and the correctness of each response was recorded. Statistical analysis of the data collected from these two experiments revealed that the CSD was highly significant in enhancing the subjects' performance in this program comprehension task. The results of these initial experiments promise to shed light on fundamental questions regarding the effect of software visualizations on program comprehensibility.

This workshop will focus on using the new jGRASP viewer canvas which provides an exciting new dimension to dynamic program visualization. The canvas allows students and instructors to organize dynamic viewers of multiple objects and primitives to quickly form coherent program visualizations. Students can quickly build and save visualizations of their own programs, and faculty can create visualizations and provide them to students with example programs. "Playing" a program in canvas mode brings the visualization to life as objects come into scope and the canvas is updated automatically. All educators who teach Java will benefit from this workshop. It will be especially suitable for instructors who teach CS1 (introduction to programming), CS2 (introduction to data structures), and CS3 (introduction to algorithms), as well as for instructors of AP courses in high schools. jGRASP is a freely available educational IDE (http://www.jgrasp.org/); no prior experience with jGRASP is expected. Laptop required.

In this paper, we describe our experiences using dynamic program visualizations in our Java-based CS1 and CS2 courses during the spring semester 2013. The visualizations were constructed by both faculty and students using the new viewer canvas in jGRASP. A public beta version was downloaded and installed in our computer labs and on student and faculty machines. Program visualizations were used in the classroom as well as in lab activities and programming projects. Since the viewers had already been evaluated in controlled experiments, our focus was on ease of use of the viewer canvas by the students and the utility of the program visualizations in helping students understand their programs. Direct observations in the lab and individual meetings with students to discuss their work indicated that students could indeed build dynamic visualizations that, in conjunction with the debugger, helped them understand and correct bugs in their programs much more effectively than using the debugger alone.

1. ABSTRACT GRASP is a software engineering tool which uniquely combines a source code diagramming technique, the control structure diagram (CSD), with other comprehension aids such as complexity visualization, syntax coloring and source code folding. The synergistic combination of these features in GRASP has the potential to be a powerful aid in any activity where source code is expected to be read. The primary focus of GRASP is to improve the comprehension efficiency of software and, as a result, improve reliability and reduce costs during design, implementation, testing, maintenance and reengineering.

The idea that representing something visually can help us understand it has long been promoted in common practice and in the literature [1,2,3,4,5,6]. Indeed, "a picture is worth a thousand words" has become a standard cliché in our culture. In the case of software, however, one must take great care that it is the correct thousand words that are being conveyed [5]. Nonetheless, appropriate visualizations of software can be quite beneficial to programmers, especially when faced with program comprehension tasks. Such tasks exist throughout the software life cycle (e.g., formal technical reviews, debugging, verification, reverse engineering) and in the classroom (e.g., students reading examples from the text or examples from the professor).The GRASP (Graphical Representations of Algorithms, Structures, and Processes) research project at Auburn University seeks to develop tools and techniques for the effective use of graphical representations and visualizations of software. The overall goal of this research is to increase the efficiency of programmer comprehension and understanding of source code, and thereby decrease overall software cost. As an integral part of the research project, the GRASP software engineering tool has been developed as a continuously evolving prototype. The emphasis of the tool to this point has been on visualizing program structure and complexity via the automatic generation of Control Structure Diagrams (CSDs) and Complexity Profile Graphs (CPGs) from Ada source code [7]. The current release of GRASP provides generation of CSDs and CPGs together with other program comprehension aids such as syntax coloring, typographical enhancements, and source code folding [8]. When coupled with an appropriate compilation system such as GNAT, GRASP becomes an integrated graphical development environment for Ada 95, allowing users to edit, visualize, pretty-print, compile, link, execute and debug Ada software.The GRASP prototype for Ada was first made available to the public in January 1996. Since that time, thousands of copies of GRASP have been downloaded via anonymous file transfer protocol (FTP) and the World Wide Web (WWW) from educational, government, military and commercial sites, both in the United States and abroad. When it was released to the public, GRASP was also made available to users of the Auburn University College of Engineering computer network. GRASP is now used extensively throughout the computer science and engineering curriculum at Auburn University, in approximately three to five courses per quarter.

GRASP is a prototype software visualization and development tool currently being used both in industry and in computer science curricula. GRASP is freely available for Solaris, Linux, Windows 95, and Windows NT. This paper describes the Windows version of GRASP along with its primary visualization, the Control Structure Diagram.

A new graphical representation, the Control Structure Diagram (CSD), has been created to visualize software at both the source code and program design language (PDL) level. The primary impetus for creation of the CSD was to improve the comprehension efficiency of software and, as a result, improve reliability and reduce costs. The CSD has the potential to replace traditional prettyprinted source code. As part of the GRASP (Graphical Representations of Algorithms, Structures, and Processes) research project at Auburn University, the GRASP software engineering tool has been successfully developed. GRASP automatically generates CSDs from source code written in Ada, C, C++, Java, and VHDL. The emphasis to this point has been on the automatic generation of the CSD to support development, maintenance, reverse engineering and reengineering through the use of GRASP. GRASP has been applied successfully to numerous programs ranging in size from several hundred to several thousand lines of source code and is efficient and sufficiently flexible for use in a production setting. To demonstrate the potential benefits of the CSD and its automatic generation using GRASP, a series of empirical studies has been planned and initiated. First, as reported in this article, the perceived usefulness of the CSD was evaluated using a preference instrument based on eleven performance characteristics in which a comparison was made with other well-known graphical representations for algorithms. Statistical analysis indicated numerous significant differences with a clear preference for the CSD in seven of the eleven performance characteristics. Further empirical studies, currently being implemented, will examine the effect of the CSD and GRASP on objective measures such as comprehension efficiency and effectiveness.

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.

Case-Based Reasoning (CBR) is the process of solving a given problem based on the knowledge gained from solving precedents. It is an effective technique in the area of customer services or helpdesks. That is, a CBR system is used to solve most of the commonly occurring customer problems. While the implementation techniques may vary, most CBR systems include the following five steps: case representation and storage, precedent matching and retrieval, adaptation of the retrieved solution, validation of the solution, and finally, casebase update to include the information gained from the new problem. This paper details the various implementation techniques for these five steps, while focusing on a particular helpdesk system, namely SmartUSA, developed for the Union Camp Corporation. This system solves a customer's problem by filtering the problem description through an alias table to generate a brief description and then matching the brief description with the cases in the database. It has proved to be an effective and user-friendly system that has successfully handled different descriptions of the same problem and allowed for the casebase to be built in free-format (plain) text. This system has significantly reduced the workload and the response time in the customer services department of the Union Camp Corporation.

A technique for reverse engineering graphical user interfaces (GUIs) produced with Xtoolkit source code is presented. Two independent graphical representations are automatically generated to assist GUI programmers in the development, testing, maintenance, and reengineering of X-based GUI source code. This capability to generate both structural and behavioral views has the potential to provide major improvements in the comprehensibility of X source code. Whereas generating widget instance trees to describe the structure of an X interface is common, the automatic generation of dialogue state diagrams to describe the behavior of an X interface is unique to our technique. The intent of this paper is to provide insight into the functional details of our automated reverse engineering process for the benefit of other reverse engineering researchers and programming tool developers.

Dynamic program viewing is a form of visual verification in which a student executes one or more statements in a program and interactively observes the behavior in basic viewers (e.g., an object with its fields) and/or conceptual viewers (e.g., the structural display of binary search tree). This activity can be extremely useful from a program understanding perspective as well as a debugging perspective. In contrast, testing (e.g., with JUnit) provides a way to create persistent test cases and then run and re-run them in an efficient way. We have observed that dynamic program viewing and testing are quite complementary. When test cases are written and executed, dynamic program viewing becomes a valuable aid in traditional debugging as well. Since most test cases are written at the functional level (e.g., did a method return the expected value?), dynamically viewing test methods as they execute can provide students with a deeper level of understanding. The jGRASP IDE has been extended to allow students to combine dynamic program viewing with JUnit testing. In this paper, we discuss both the technical success of this effort and several examples that demonstrate the potential for student use in early computing courses.

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. >

The key to applying computer-aided software engineering to the maintenance and enhancement of existing systems lies in applying reverse-engineering approaches. However, there is considerable confusion over the terminology used in both technical and marketplace discussions. The authors define and relate six terms: forward engineering, reverse engineering, redocumentation, design recovery, restructuring, and reengineering. The objective is not to create new terms but to rationalize the terms already in use. The resulting definitions apply to the underlying engineering processes, regardless of the degree of automation applied. >

This paper describes a software engineering project course for freshman. The course has been designed to engage and motivate software engineering students at the beginning of their matriculation, while at the same time providing solid software engineering content. Student teams use a simple software process based on extreme programming to complete a semester-long project in computer animation. Course motivation, structure, and implementation are described

In 2001, the ACM and the IEEE-CS published Computing Curricula 2001 which contains curriculum recommendations for undergraduate programs in computer science. That report also called for additional discipline-specific volumes for each of computer engineering, information systems, and software engineering. In addition, it called for an Overview Volume to provide a synthesis of the various volumes. The Computing Curricula 2004 Task Force undertook the job of fulfilling the latter charge. The purpose of this session is to present the recently completed work of that Task Force, now known as Computing Curricula 2005 (CC2005), and to generate discussion among, and feedback from SIGCSE members about ongoing and future work.

Although many visualization techniques have been shown to be pedagogically effective, they are still not widely adopted. The reasons include: lack of suitable methods of automatic-generation of visualizations, lack of integration among visualizations, and lack of integration with basic integrated development environment (IDE) support. To effectively use visualizations when developing code, it is useful to automatically generate multiple synchronized views without leaving the IDE. The jGRASP IDE provides object viewers that automatically generate dynamic, state-based visualizations of objects and primitive variables in Java. Such seamless integration of a lightweight IDE with a set of pedagogically effective software visualizations is unique and is currently unavailable in any other environment. Multiple instructors have reported positive anecdotal evidence of their usefulness. We conducted formal, repeatable experiments to investigate the effect of these viewers for singly linked lists on student performance and we found a statistically significant improvement over traditional methods of visual debugging that use break-points.

jGRASP is an integrated development environment, created specifically to provide automatic generation of visualizations for improving the comprehensibility of the software. These visualizations, which are particularly well suited for CS1 and CS2 students learning Java, include Control Structure Diagrams, UML Class Diagrams, and new dynamic Object Views. The object workbench and integrated debugger facilitate a unique way for students to view objects created by their programs. The workshop will include tutorials and example programs to demonstrate how instructors can improve the learning and programming experience of their students with jGRASP. Instructors are encouraged to bring programs from their own courses to experiment with the visualizations during the workshop. jGRASP is freely available at www.jgrasp.org. The jGRASP software and workshop materials will be provided.

The development of pedagogically sound learning tools using software visualization (SV) techniques has been a very popular area of research. In this paper we will conduct a qualitative comparison of a few such tools with an emphasis on data structure visualization. There are numerous tools available in academia to aid in the instruction of introductory level data structures. In this paper, we will evaluate a representative sample of these tools using Price's SV taxonomy and suggest improvements that can be incorporated in future work.

SIGCSE 2004 marked the official announcement of the ACM Java Task Force, which is working to develop a stable collection of pedagogical resources that will make it easier to teach Java to first-year computing students. The Java Task Force has received funding from the ACM Education Board, the SIGCSE Special Projects Fund, and the National Science Foundation (NSF Award DUE-0411905). This session offers an update on the work of the Java Task Force over the past year and provides an opportunity for community feedback prior to the publication of the final report in June 2005.

A framework for producing dynamic data structure visualizations within the context of a lightweight IDE is described. Multiple synchronized visualizations of a data structure can be created with minimal coding through the use of an external viewer model. The framework supplies a customizable viewer template as well as high-level APIs to a graph drawing library and the Java Debugger Interface. Initial classroom use has demonstrated the framework's ease of use as well as its potential to as an aid to student learning.

Traditionally, using a debugger has had the connotation of finding and removing defects. In this paper and presentation, we explore the use of a modern integrated debugger as a program understanding tool for novice programming students in CS1. With the move to Java in the first course, instructors and students are faced with either ignoring the details of object-oriented concept or with explaining the concepts in a way that novices can understand. We show how the debugger can be used to depict the initial construction of an object, the object's inherited members, and polymorphic calls to the object's methods. Although each of these concepts can be difficult for beginning programmers, using the debugger to explicitly illustrate these concepts provides students with an opportunity for a much deeper understanding of their programs.

By supporting well-defined cognitive processes employed during a comprehension task, graphical representations of software could have a beneficial effect on comprehension efficiency and effectiveness. Documented empirical evidence of measurable benefits of software visualization is, however, limited in scope and often contradictory. The GRASP research project is currently evaluating the effects of software visualizations in both software engineering education as well as in software production environments. This paper describes the experimental framework and design used for evaluation in an academic setting.

The GRASP/Ada project (Graphical Representations of Algorithms, Structures, and Processes for Ada) has successfully created and prototyped a new algorithmic level graphical representation for Ada software, the Control Structure Diagram (CSD). The primary impetus for creation of the CSD is to improve the comprehension efficiency of Ada software and, as a result, improve reliability and reduce costs. The emphasis is on the automatic generation of the CSD from Ada PDL or source code to support reverse engineering and maintenance. The CSD has the potential to replace traditional prettyprinted Ada source code. The current prototype provides the capability for the user to generate CSDs from Ada PDL or source code with a level of flexibility suitable for practical application. >

Visualizations of software can be utilized in varying degrees throughout the software development cycle as aids to comprehension, analysis, and measurement. This research focuses on the experimental evaluation and refinement of a set of scalable visualizations that show promise for improving the overall software process. The roles which visualizations may play during reverse engineering and maintenance are of particular interest. This research also investigates the manner in which software visualizations are used in practice by software professionals. Partners from government and industry have agreed to participate by providing access to appropriate production software. This paper will describe a framework for evaluating visual techniques and investigating their practical use and application.

Multi-lingual software systems are those in which the component modules are implemented in multiple languages. Reverse engineering such systems raises several issues, particularly with regard to providing automated tool support for the process. GRASP is a prototype software engineering tool designed to provide visualization of software control structure, complexity, and architecture. The paper describes GRASP and its use in reverse engineering multi-lingual software systems.

As part of the ongoing research of Auburn University's GRASP (Graphical Representations of Algorithms, Structures and Processes) project, a markup language has been designed and prototyped to facilitate the automatic generation of static program visualizations from source code. Specifically, the latest release of the GRASP/Ada tool uses a markup language called GRASP-ML as the basis for automatically generating control structure diagrams from Ada source code. This markup language is described, and its role in reverse engineering with GRASP/Ada is explained. Finally, promising future work is outlined and discussed.

The "write once, run anywhere" model for Java-based systems holds great promise for reducing the cost associated with maintaining software systems that must run on multiple hardware platforms and multiple operating systems. The GRASP research project at Auburn University has recently completed a port of its software engineering tool, also called GRASP, from its original implementation in C to Java. This effort has provided an excellent opportunity for the authors to empirically observe the effects on portability, efficiency, and maintainability that such a transformation could have. This case study in reengineering and maintenance suggests that Java has not yet matured to the point that all its potential and promises can be fulfilled. However, as it matures and becomes more stable, Java offers the opportunity to significantly reduce the cost and effort of maintaining multiple host software systems.

Recently, the first in a series of planned comprehension experiments was performed to measure the effect of the control structure diagram (CSD) on program comprehensibility. Upper-division computer science students were asked to respond to questions regarding the structure and execution of a source code module written in Java. Statistical analysis of the data collected from this experiment revealed that the CSD was highly significant in enhancing the subjects' performance in this program comprehension task. The results of this initial experiment along with the planned follow-on experiments promise to shed light on fundamental questions regarding the effect of software visualizations on program comprehensibility.

In the fall of 1998, the ACM Education Board and the Educational Activities Board of the IEEE Computer Society appointed representatives to a joint task force to prepare Curriculum 2001, the next installment in a series of reports on the undergraduate computer science curriculum that began in 1968 and was then updated in 1978 and 1991. Interim reports on the initial planning of the curriculum were presented at the SIGCSE symposium in March 1999 and at the IEEE Frontiers in Education Conference in November 1999. In February 2000, the Curriculum 2001 Task Force will release a preliminary version of its report, in the hope of gaining feedback from a wider audience. The purpose of this panel is to give attenders at the SIGCSE conference to review the current state of the preliminary draft and offer their comments to the members of the Curriculum 2001 steering committee on the panel.

Recently one of the first in a series of planned comprehension experiments was performed to measure the effect of the control structure diagram (CSD), reverse engineered from source code, on program comprehensibility. Computer science students in an object oriented programming course were asked to respond to questions regarding the structure and execution of a source code module written in Java. Statistical analysis of the data collected from this experiment revealed that the CSD was highly significant in enhancing the subjects' performance in this program comprehension task. The results of this initial experiment along with the planned follow-on experiments promise to shed light on fundamental questions regarding the effect of software visualizations on program comprehensibility.

Although a computer science curriculum may use a single language as its "core" language, many curricula require students to learn and use multiple languages for course or practicum work. Students benefit from the exposure to other languages and other language models. However, a problem arising from the multi-lingual nature of a curriculum is the necessity to learn and use different development environments and language front-ends. GRASP (Graphical Representations of Algorithms, Structures, and Processes) is a software engineering tool currently being successfully utilized as a common development environment for the multi-lingual computer science curriculum at Auburn University. Besides providing a common front-end for different languages, GRASP also provides automated visualization of source code in the form of the control structure diagram and the complexity profile graph. This paper describes GRASP and its current use in the computer science curriculum. GRASP is freely available via the Internet at the following URL: http://www.eng.auburn.edu/grasp

This paper discusses recent trends in the field of reverse engineering, particularly those highlighted at the Second Working Conference on Reverse Engineering, held in July 1995. The trends observed include increased orientation toward tasks, grounding in complex real-world applications, guidance from empirical study, analysis of non-code sources, and increased formalization. The paper also summarizes open research issues and provides pointers to future events and sources of information in this area.

As part of an ongoing project at Auburn University we have developed GRASP/Ada, a program visualization tool that supports both reverse engineering and forward engineering of Ada source code. This paper describes our current work in reengineering the GRASP/Ada system. Although the basic functionality of the tool will remain unchanged, our reengineering effort will completely reimplement GRASP/Ada and fundamentally change our approach to rendering graphical representations from source code.

This paper focuses on team selection methods and related issues that may have a substantial impact on students' overall experience working on a “large-scale” programming project. Teams can be selected randomly, by the students, by academic performance, by using psychological profiles, or by using a combination of these methods. Advantages and disadvantages are presented for each method. Issues concerning size of teams include number of students in the class, type and size of software to be built, single project per team versus shared project, software tools available, and the programming skills and general academic maturity of the students in the class. From the students perspective, the most discernable effects of team size involve communication, scheduling, and general cooperation. Important grading issues are described with emphasis on peer grading. The paper concludes with a summary of observations and experiences the authors have had including pitfalls to be avoided.