The rapid evolution of computing demands curricula that reflect modern practices, yet many CS1 and CS2 courses continue to emphasize only sequential programming. This NSF-funded project addresses that gap by designing and disseminating exemplar CS1 and CS2 courses that integrate parallel, distributed, and event-driven computing as core concepts. The materials include unplugged activities and programming labs for both C++ and Java. To ensure broad applicability and adoption, development occurred in collaboration with instructors from six diverse institutions who are now implementing the materials. Evaluation includes surveys, assignment-specific instruments, and cross-team analysis. This poster presents the project’s vision, methods, and resources, highlighting how others can adopt and adapt them to teach modern computing.

Computer Science education, and all education for that matter, is being disrupted by Generative AI. While there have been few truly transformational technologies similar to AI, other incremental but impactful advances have helped shape the computing ecosystem. Other recent examples include the transition to multicore systems (requiring the promotion of parallel computing from an elective topic), the shift to graphical interfaces (raising expectations for assignments and motivating the creation of Media Computation), and the emergence of object-oriented programming. In this Birds of a Feather Session, we ask the question ''How might we redesign our CS1 and CS2 courses to better prepare students for emerging and future computing paradigms while maintaining strong foundations in problem solving, programming, and computational thinking?'' Using collaborative brainstorming techniques, participants will create a list of potential future paradigms (either disruptive or incremental) that are relevant to CS1/CS2, and develop proposed roadmaps that identify how those paradigms can be leveraged as contexts for teaching the existing CS1 and CS2 courses within the CS2023 curriculum.

Parallel and distributed computing (PDC) has become pervasive in all aspects of computing, and thus it is essential that students include parallelism and distribution in the computational thinking that they apply to problem solving, from the very beginning. Computer science education is still teaching a 20th century model of algorithmic problem solving, where sequence, branch, and loop are the only organizing principles needed for algorithms. We invest considerable time in showing how best to sequentially process large volumes of data. All computing devices that students use currently have multiple cores as well as a GPU in many cases. Most of their favorite applications use multiple cores and distributed resources. Often concurrency offers simpler solutions than sequential approaches. In this tutorial we overview key PDC concepts and provide examples of how they may naturally be incorporated in early computing classes. We lead participants through plugged and unplugged curriculum modules that have been successfully integrated and tested in existing computing classes at multiple institutions. We also discuss recent efforts at integrating AI methods, including LLMs, into early classes. In addition, we highlight other CDER activities for integration of PDC and AI into undergraduate computing curricula. Additional Information: No equipment or prior PDC experience is required, although a laptop that can run C++, Java and Python is recommended for following along with some code examples if desired.

Parallel and distributed computing (PDC) has become pervasive in all aspects of computing, so it is essential that students include parallelism and distribution in the computational thinking that they apply to problem solving, from the beginning of their computing education. With all computing devices that students use having multiple cores as well as a GPU in many cases, many students' favorite applications use multiple cores and/or distributed processors. However, we are still teaching them to solve problems using only sequential thinking. Why?

This work in progress innovative practice paper documents ways in which current introductory computing courses are designed for an earlier generation of computers. We describe our plans for updating these courses for modern systems and programming practices and share details of the development of exemplar courses that will be adoptable by diverse institutions and programs teaching introductory programming courses.

This innovative practice full paper describes a two-semester capstone experience that trains students in agile software engineering principles and incorporates the material into building an actual product for an industry partner. Recently, teaching agile software engineering has garnered considerable attention, and research has focused on effective pedagogical approaches, challenges, and outcomes. However, while computer science students are exposed to agile methodologies in their curriculum, and students even use the approach in a project, the experience tends to be brief and non-real-world. In this work, we believe our approach provides a more cohesive learning experience, better prepares students for jobs in industry, and introduces them to incorporating an overall agile mind set. We outline specific activities, timelines, and best practices for managing team projects and providing a better experience for the students. The results of our efforts are reported through retrospectives and reflections with the students over five years.

This Innovative Practice Full Paper addresses the challenges of distribution of prior experience among students in the first course for computing majors (CS1) by allowing students to self-select an experience-based group for their lecture class. Rising enrollments in computer science have caused many challenges for computer science educators in student learning, engagement, and success. Included in these challenges is the diversity of previous programming experience of new students. To address these challenges, we introduced a student-centered learning approach in a test section of our CS1 course whereby students were afforded the ability to self-select an experience-based group. We also had a control section of our CS1 course that remained in the traditional setting of not having experience-based groups. The results from our collected data suggest that having self-selected experience-based groups improves retention and student success.

Mirroring the trend of the growth of Computer Science (CS) programs nation and worldwide, the CS program in the College of Engineering at Tennessee Technological University has experienced similar growth in the number of students enrolling in its B.S., M.S., and Ph.D. programs. This growth of enrollment in CS has been accompanied by a growth in another student population at the university that is often overlooked: Interdisciplinary Studies - Interest in Computer Science (ICSC) majors. This population represents students who have qualified for admission at Tennessee Tech, but have not qualified for entry into the CS program. Indeed, just as the freshman class of CS has grown 44%, the ICSC program has grown 63%. To address the problem of retention and migration into CS from ICSC, we have developed the pre-CS Redshirt program, which is aimed at providing increased advising, peer mentoring, tutoring, and connections to faculty. Launched in Fall 2020, the challenges facing these students have been compounded by COVID-19. In order to study initial effectiveness, we measured Fall-Spring retention, comparative GPAs for students in the CS and ICSC programs, and conducted a survey of students to measure students' sense of belongingness with the measured population including students of all levels currently enrolled in the CS program as well as the pre-CS Redshirt students.

This Innovative Practice Full Paper addresses the challenges of teaching data structures and algorithms to blind students using tactile media and a user-centered approach. Computer Science educators have have long used diagrams and other visualizations to assist in teaching data structures and algorithms. As enrollments in computer science rise, a more diverse student body has led to widespread access to computer science, including an increase in the number of students with sight impairments that are seeking computer science degrees. In the Department of Computer Science at Tennessee Technological University we have been actively engaging in the development of methodologies and approaches necessary to facilitate creation of tactile documents suitable for helping students with sight impairments to understand and effectively use common data structures. Using tools generally available to practitioners, we applied a user-centered iterative process to develop standards necessary to create visual idioms that capture various data structures and algorithms as diagrams expressed using tactile documents. With feedback from our visually impaired students, we created several diagrams that represent various data structures using common drawing tools such as Microsoft Visio with Braille font. These documents were then printed using swell paper and a tactile printer. Students using these diagrams have reported gaining an increased understanding of concepts that were previously static abstractions only read about in their textbooks. Many lessons have been learned along the way that range from the general (i.e., how to properly space words in order to not affect ambiguity in the layout of diagrams) to the specific (i.e., how to demonstrate movement of data in a data structure using the tactile medium). In this paper, we report on the approaches used to create tactile diagrams representing various data structures, the ways in which we interacted with students in order to gain a better understanding of how to represent visual idioms in tactile form, challenges faced in creating the documents, and lessons learned. In addition, we discuss the work in the context of the state of the art, and suggest future investigations.

This work in progress paper presents a course on DevOps which is a combination of software development skills and software operations skills. This new course is for sophomores and juniors in the computer science program who want to be prepared for professional software engineering careers. Introduction to DevOps Is a hands-on laboratory course that brings students through Git for source code management, Capybara for automated testing, AWS, Docker, and Ansible for automated virtual machine provisioning and configuration, and Jenkins for Continuous Integration. Unlike our current course offerings which primarily focus on the single developer context in a localized environment, this course prepares students for highly collaborative, team-based projects that use cloud resources to facilitate management of the software deployment pipeline. We developed this course based on feedback from our external advisory board and under consultation from a number of industrial partners. This is complementary to our current offerings in software engineering which focus on Agile software practices. In this paper we describe the core concepts, the design, learning experiences, technologies, and lessons learned through developing and conducting this course. In future work we hope to present student perceptions of learning and provide data collected through direct assessment of student outcomes.

This Research Paper presents our work using the Organizational Culture Framework to better understand the educational and operational culture of the Department of Computer Science at Tennessee Tech University. A large percentage of graduates with computing degrees will enter corporate environments dominated by the use of Agile development methods, including Scrum. A significant part of these methodologies is grounded in establishing cultural norms that emphasize teamwork, communication, reflection, and action. We conducted a study using an organizational culture framework to better understand both the ideal and current cultures of our department as well as the levers that can be used to move the current toward the ideal. The design of the study is based on the notion that by identifying an ideal culture and measuring the current culture we can identify the gap between the as-is and the to-be culture of the department. Our results demonstrate a marked difference between the target ideal culture identified by both the Agile experts and faculty/staff and what the students perceive the current culture to be. The results of the survey serve as a baseline for our ongoing effort to create a pathway for transitioning students towards adopting an Agile mindset that will ease the commencement of careers of graduates as practicing software engineers.

Program slicing has long been used to facilitate program understanding. Several approaches have been suggested for computing slices based on different perspectives, including forward slicing, backward slicing, static slicing, and dynamic slicing. The applications of slicing are numerous, including testing, effort estimation, and impact analysis. Surprisingly, given the maturity of slicing, few approaches exist for visualizing slices. In this paper, we present our tool for visualizing large systems based on program slicing and through two visualization idioms: treemaps and bipartite graphs. In particular, we use treemaps to facilitate slicing-based navigation, and we use bipartite graphs to facilitate visual impact analysis by displaying relationships among system decomposition slices showing the relevant computations involving a given slicing variable. We believe our tool will support various software maintenance tasks, including providing analysts an interactive visualization of the impact of potential changes, thus allowing them to plan maintenance accordingly. Finally, we show that, through the use of both existing scalable slicing and scalable visualization approaches, our tool can facilitate analysis of large software systems.

We have investigated whether Agile practices can be applied as a pedagogical approach to derive benefit in the areas of encouraging students to take responsibility for their learning (self managed learning), continuous improvement through reflection, alternative approaches for grading, increased engagement by learners, and more effective data collection and assessment of outcomes. Agile is an umbrella term for values, principles and practices applied to the process of software development. The Agile movement has aimed to develop a new and better culture within the software development community and has seen an increased rate of adoption within corporate settings. The goal of this workshop is to help participants explore how Agile development, a management technique borne out of the software industry, can not only change the way that students engage in project-based and team-based course projects, but also transform the way that we educate our students.

The Computer Science and Software Engineering (CS/SE) profession reports that new college graduates lack the communication skills needed for personal and organizational success. Many CS/SE faculty may omit communication instruction from their courses because they do not want to reduce technical content. We experimented in a software-engineering-intensive second-semester programming course with strategies for improving students' writing of black box test plans that included no instruction on writing the plans beyond the standard lecture on testing. The treatment version of the course used 1) a modified assignment that focused on the plan's readers, 2) a model plan students could consult online, and 3) a modified grading rubric that identified the readers' needs. Three external raters found that students in the treatment sections outperformed students in the control sections on writing for five of nine criteria on rubrics for evaluating the plans and on the raters' holistic impression of the students' technical and communication abilities from the perspectives of a manager and a tester.

The "Girls on the Go: The Mobile Computing College Experience" is a residential summer camp whose aim is to encourage female high school students to attend college, to consider computer science as viable major, and to pursue computing related degrees. The camp content is designed primarily around a user-centered design process, with the students gaining experience in the development of a zoo-themed mobile app. In addition to technical experience, students participate in sessions that educate them on campus life, the admissions process, and more importantly, what a computing-related career may hold for them. The camp was offered in two consecutive summers, with approximately 20 participants in each iteration. In this paper, we compare differences between the two iterations with the intent of identifying both lessons learned and avenues for improving the experience. We investigate whether the camp had an effect on attitudes towards computer science as a major, and on the careers available to computer science graduates. To this end, our analysis revealed a statistically significant effect upon raising awareness of the role of computer scientists and the relevancy of computing for solving real world problems.

Communication skills, including reading, writing, speaking, and teaming, are among the most sought after by employers of recent Computer Science/Software Engineering (CS/SE) graduates. We have been conducting a project that has developed a general framework for program-level integration of communication into CS/SE education. Our framework has been developed through workshops and field evaluation of training materials (and other resources) by faculty from a wide variety of institutions under the guidance of experts in writing and communication across the curriculum. This paper discusses the current state of communication teaching in the CS/SE domain, and presents our framework and experiences for program-wide implementation of communication skills.

In this paper, we describe our experience running "Girls on the Go: The Mobile Computing College Experience." We decided to do a residential summer camp for HS-age girls to achieve two goals: to encourage our campers to attend college and to interest them in computer science as a possible career option. We centered the camp around the design of a zoo-themed research tool where campers designed a mobile application to be used by researchers to document and study animal behavior. Post-camp surveys gave statistically significant results indicating that the camp increased the girls' confidence in performing computer science and understanding what computer scientists did.

The fact that employers regularly list communication skills among their top requirements for graduates of Computer Science programs and that communication skills are specifically included in ABET program outcomes attests to their significance for Computer Science educators. To prepare students, Computer Science programs typically require students to take a course in technical communications or writing intensive courses. A recent trend emerging from the communication specialist suggests that integrating communication skills with content across the Computer Science curriculum is more effective strategy. The three-year NSF-funded CPATH II project (CCF-0939122 and CCF-0939081) "Incorporating Communication Skills into the Computer Science Curriculum" brought together 40 Computer Science educators and communications specialists to develop assignments and communications supports that implement content and communication skills integration. The results are available on the project website (http://cs-comm.lib.muohio.edu/). Computer Science educators who seek to provide graduates of Computer Science programs with excellent communication skills will find this approach relevant and valuable. Those who have developed integrated materials will be encouraged to contribute to the project repository. Those who are interested in increasing the amount of communication taught in their curriculum will be encouraged to adapt assignments from the repository to their needs.

Recently, inquiry-based learning has been used to enable students to ask scientific questions and come to objective conclusions based on observation and experimentation. Within this context, we have been exploring the impact of mobile devices upon different modes of learning including inquiry-based instruction. While much attention has been on the acquisition of mobile devices for the classroom, mobile learning has the ability to facilitate education beyond the confines of the brick and mortar to improve information retention and student engagement. This paper describes research being performed at Miami University which explores best practices in engaging students in inquiry-based learning experiences using a suite of technological tools (including a mobile app) being developed to support citizen science and research data collection.

“Incorporating Communication Learning Outcomes Across the Computer Science (CS) and Software Engineering (SE) Curriculum” is an NSF-funded project that aims to identify the communication skills, specifically those involving reading, writing, speaking, and teaming, needed by CS and SE graduates and then determine how these skills can be taught within CS and SE curricula. This paper presents the results of our first two years of studying the programs at Miami University and North Carolina State University to determine the kinds of communication utilized in our courses and how communication is taught and assessed. When looking at student attitudes towards communication our analyses suggest that students do not consider technical (professional) activities such as code reading, writing, and inspections as communication activities, and the same applies to more complex genres such as software testing or design. They also appear to have difficulty relating writing and reading that may take place in the context of the courses to what they might be doing as software engineers and computer scientists once they start working. On the other hand, initial results indicate that our students' communications skills increase steadily throughout their stay in the university. We have also identified potential strategies for improved instruction in communication.

To be successful, CS and SE graduates need strong communication skills (writing, speaking, and teaming), particularly within their discipline. Students exercise these skills during their classes but are not always given explicit domain-specific instruction on these skills, instead relying on instruction provided outside the program. CS and SE faculty are not always comfortable in evaluating these aspects of their assignments and are often unhappy with the results. In this workshop we will lead sessions on teaching writing, speaking, and teaming; situating assignments in workplace-scenarios (to motivate students); and writing communication rubrics that convey faculty expectations to students and support evaluation of student work. For more information, see www.muohio.edu/sigcse_workshop11. A laptop is recommended but not mandatory for this workshop.

One way to improve the communication abilities of new software engineering graduates in the workplace is to integrate communication more effectively in the software engineering curriculum. But faculty typically conceive of communication as outside their realm of expertise. Based on the results of an NSF-funded project, we use theories of situated learning and genre to make the case that communication is integral to software engineering and that faculty are in the best position to guide students in becoming better communicators in the field. We identify software engineering genres and show how those genres may be used to integrate communication in the classroom and throughout the curriculum.

Software engineering educators and trainers are acutely aware that software engineering graduates need strong real-world communication abilities. The National Science Foundation is supporting a three-year project in which industry professionals, CS/SE faculty, and communication-across-the-curriculum specialists are collaborating to develop curricula and teaching resources designed to improve communication abilities of CS/SE graduates by integrating communication instruction and assignments with the technical work in courses across the students' four years of study. Our panelists — an industry practitioner, a CS/SE educator, and a communication specialist — will describe what has been learned in the project's first half and invite comments, insights and advice from the audience.

Capstone projects are a valuable opportunity for computer science and software engineering students to take what they have learned over the previous three years of their education and apply it to an open-ended project. Some universities offer multiple capstone projects, defined and supervised by different faculty members. Here we describe a set of dimensions that can be used to categorize capstone projects to determine the level of realism, areas of risk, as well as an overall project type. Instructors can use the capstone dimensions and project type in capstone planning to ensure that projects meet the desired course outcomes.

An inverted classroom is a teaching environment that mixes the use of technology with hands-on activities. In an inverted classroom, typical in-class lecture time is replaced with laboratory and in-class activities. Outside class time, lectures are delivered over some other medium such as video on-demand. In a three credit hour course for instance, contact hours are spent having students actively engaged in learning activities. Outside of class, students are focused on viewing 3-6 hours of lectures per week. Additional time outside of class is spent completing learning activities. In this paper we present the inverted classroom model in the context of a software engineering curriculum. The paper motivates the use of the inverted classroom and suggests how different courses from the Software Engineering 2004 Model Curriculum Volume can incorporate the use of the inverted classroom. In addition, we present the results of a pilot course that utilized the inverted classroom model at Miami University and describe courses that are currently in process of piloting its use.

Ajax-based web applications are designed to mimic more traditional desktop applications and require quick response times from the underlying Web services. However, since availability and performance of Web services cannot be guaranteed, response time and overall performance of Ajax-based applications can vary. In this paper we describe a framework for developing autonomic self-healing Web service-based applications that rely on the notion of differentiated services (i.e., services that provide common behavior with variable quality of service) in order to maintain required performance characteristics. We present the expected impact of the framework through the use of a theoretical QN model, demonstrate the framework with an example, and provide an evaluation of the technique.

The semantic web promises to bring automation to the areas of web service discovery, composition and invocation. In order to realize these benefits, rich semantic descriptions of web services must be created by the software developer. A steep learning curve and lack of tool support for developing such descriptions thus far have created significant adoption barriers for semantic web service technologies. In this paper, we present a model-driven architecture based approach for specifying semantic web service compositions through the use of a UML profile that extends class and activity diagrams. This profile is used in transformations that facilitate automatic construction of OWLS specifications from UML diagrams. Conditions required by the composition, such as those on control constructs, are specified using OCL and transformed into SWRL during the construction process.

The complexity of the systems that software engineers build has continuously grown since the inception of the field. What has not changed is the engineers' mental capacity to operate on about seven distinct pieces of information at a time. Improvements like the widespread use of UML have led to more abstract software design activities, however the same cannot be said for reverse engineering activities. The well known concept assignment problem is still being solved at the line-by-line level of analyzing source code. The introduction of abstraction to the problem will allow the engineer to move farther away from the details of the system, increasing his ability to see the role that domain level concepts play in the system. In this paper we present a technique that facilitates filtering of classes from existing systems at the source level based on their relationship to the core concepts in the domain. This approach can simplify the process of reverse engineering and design recovery, as well as other activities that require a mapping to domain level concepts.

OWL-S is an instance of the Web Ontology Language (OWL) that is used to describe and specify semantic Web services. While OWL-S provides a promising mechanism for specification, publication, discovery, integration, and access, the learning curve can be high. Current practices in Web services tend to focus on lightweight specification using automated tools that generate WSDL descriptions. One of the advantages of OWL-S is its flexibility in allowing the creation of many groundings or bindings for a single semantic Web service. In this paper, we propose an approach for generating groundings for a semantic Web service and demonstrate how the use of lightweight interactive tools facilitates creation of groundings for a semantic Web service.

The semantic Web promises automated invocation, discovery, and composition of Web services by enhancing services with semantic descriptions. One such language used for creating semantic descriptions is the Web ontology language or OWL. An upper ontology for Web services called OWL-S has been created to provide a mechanism for describing service semantics in a standard, well-defined manner. Unfortunately, the learning curve for semantic-rich description languages such as OWL-S can be steep, especially with given the current state of tool support for the language. This paper describes an automated software tool that uses model-driven architecture (MDA) techniques to generate an OWL-S description of a Web service from a UML model. This allows' the developer to focus on creating a model of the Web service in a standard UML tool, leveraging existing knowledge.

Recent advances in the area of Web services have enabled inter-organization sharing of data and data-oriented software services. The challenges of developing software in a service-oriented development environment include search, retrieval, and integration of services with client applications. Such applications can be dynamic in nature and may vary depending on current availability of services or on the current relationship between client and service organizations. As such, applications must be able to quickly locate and integrate different potential service components. In this paper we describe an approach for automating the process of searching for Web services using signature matching and describe a new signature match criteria called the contains match.

The Spin model checker is a system that has been used to model and analyze a large number of applications in several domains including the aerospace industry. One of the novelties of Spin is its relatively simple specification language, Promela, as well as the powerful abilities of the model checker. The Petri net notation is a mathematical tool for modeling various classes of systems, especially those that involve concurrency and parallelism. The Honeywell Domain Modeling Environment (DOME) is a tool that supports system design using a wide variety of modeling notations, including UML diagrams and Petri nets. We describe a tool that supports the use of the Spin model checker to analyze and verify Petri net specifications that have been constructed using the DOME tool. In addition to discussing the translation of Petri nets into Promela, we present several example Petri net specifications as well as their analysis using Spin.

This paper addresses the issue of how to perform architectural analysis on an existing product line architecture. The con tribution of the paper is to identify and demonstrate a repeatable product line architecture analysis process. The approach defines a “good” product line architecture in terms of those quality attributes required by the particular product line under development. It then analyzes the architecture against these criteria by both manual and tool-supported methods. The phased approach described in this paper provides a structured analysis of an existing product line architecture using (1) formal specification of the high-level architecture, (2) manual analysis of scenarios to exercise the architecture's support for required variabilities, and (3) model checking of critical behaviors at the architectural level that are required for all systems in the product line. Results of an application to a software product line of spaceborne telescopes are used to explain and evaluate the approach.

Article Free Access Share on A specification matching based approach to reverse engineering Authors: Gerald C. Gannod Computer Science and Engineering, Arizona State University, Box 875406, Tempe, AZ Computer Science and Engineering, Arizona State University, Box 875406, Tempe, AZView Profile , Betty H. C. Cheng Computer Science and Engineering, Michigan State University, 3115 Engineering Building, East Lansing, MI Computer Science and Engineering, Michigan State University, 3115 Engineering Building, East Lansing, MIView Profile Authors Info & Claims ICSE '99: Proceedings of the 21st international conference on Software engineeringMay 1999 Pages 389–398https://doi.org/10.1145/302405.302661Online:16 May 1999Publication History 9citation555DownloadsMetricsTotal Citations9Total Downloads555Last 12 Months4Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Formal approaches to software reuse rely heavily upon a specification matching criterion, where a search query using formal specifications is used to search a library of components indexed by specifications. In previous investigations, we addressed the use of formal methods and component libraries to support software reuse and construction of software based on component specifications. A difficulty for all formal approaches to software reuse is the creation of the formal indices. We have developed an approach to reverse engineering that is based on the use of formal methods to derive formal specifications of existing programs. In this paper, we present an approach for combining software reverse engineering and software reuse to support populating specification libraries for the purposes of software reuse. In addition, we discuss the results of our initial investigations into the use of tools to support an entire process of populating and using a specification library to construct a software application.

Given a program S and a precondition Q, the strongest postcondition, denoted sp(S,Q), is defined as the strongest condition that holds after the execution of S, given that S terminates. By defining the formal semantics of each of the constructs of a programming language, a formal specification of the behavior of a program written using the given programming language can be constructed. In this paper we address the formal semantics of pointers in order to handle a realistic model of programming languages that incorporate the use of pointers. In addition, we present a tool for supporting the construction of formal specifications of programs that include the use of pointers.

Reverse engineering of program code is the process of constructing a higher level abstraction of an implementation in order to facilitate the understanding of a system that may be in a "legacy" or "geriatric" state. Changing architectures and improvements in programming methods, including formal methods in software development and object-oriented programming, have prompted a need to reverse engineer and re-engineer program code. At the same time, there is a need to preserve the functionality of existing systems as well as reason about the correctness of changed code, each of which is facilitated by the existence of formal specifications. The paper describes an approach that incorporates the use of semi-formal analysis and formal program semantics to reverse engineer C programs. The reverse engineering techniques are applied to a portion of a ground-based command system for unmanned flight systems.

As software is increasingly used to control safety-critical systems, correctness becomes paramount. Formal methods in software development provide many benefits in the forward engineering aspect of software development. Reverse engineering is the process of constructing a high-level representation of a system from existing lower level instanti-ations of that system. Reverse engineering of program code into formal specifications facilitates the utilization of the benefits of formal methods in projects where formal methods may not have previously been used, thus facilitating the maintenance of safety-critical systems.

A description is presented of the development of the tool AUTOSPEC (automated specification), which abstracts formal specifications from program code. The abstraction process can incorporate domain-specific information supplied interactively by the user, as necessary. The abstraction algorithms and a discussion of the use of formal methods and object-oriented techniques for the development of AUTOSPEC are given. Implementation-specific information is given and related work is described.>