bluuebunny/crossref_metadata_2025 huggingface dataset:
Animating operating systems algorithms with XTANGO
Authors: Hartley Stephen J.
Published: July 2004

In operating systems courses, students study the major algorithms used in operating systems to manage the various objects and resources in a computing system: processes, files, buffer space, processors, messages, main memory, semaphores, and disk storage. Various classical synchronization problems such as the dining philosophers, the readers and writers, and the producers and consumers with bounded buffer are also analyzed. Even though the computing systems being studied are getting more and more powerful, these algorithms and classical problems are usually analyzed using blackboard, chalk, pencil, and paper. This paper describes an X-windows based package called
xtango
that was used to animate some of the algorithms and classical problems studied in operating systems. One animation typical of those that have been developed is presented. Students can use these animations during study outside the classroom for a better understanding of the algorithms. Instructors can use the animations to facilitate the presentation of the algorithms in the classroom.
Using graphical presentation techniques in closed laboratory exercises (abstract)
Authors: Proulx Viera , Fell Harriet , Rasala Richard , Koomen Johannes A. G. M. , Wilson Carol W.
Published: July 2004

The panelists will share their experiences in developing closed laboratory exercises for lower level CS courses with particular emphasis on using graphical presentation techniques as a pedological and motivational tool. The use of interactive animations and visualization is combined with structured support for the student programmer to provide an apprentice style learning environment.

Three major threads form the backbone of this curriculum. The first is the use of interactive animations and experimentation programs to introduce and illustrate dynamic processes—e.g. algorithm behavior, or changes in data structures over a period of time. The second thread is the use of graphics in student programs, not only as motivation, but also as a visual feedback and debugging tool. The third thread trying all together is the extensive use of model programs, shell drivers, toolkits, and procedures that encapsulate abstractions. These programming tools support the apprentice style of learning and illustrate good software design and practice throughout the curriculum.
Integrating status and event phenomena in formal specifications of interactive systems
Authors: Abowd Gregory D. , Dix Alan J.
Published: July 2004

In this paper we investigate the appropriateness of formal specification languages for the description of user interface phenomena. Specifically, we are concerned with the distinction between continuously available information, which we call status, and atomic, non-persistent information, which we call events. We propose a hybrid model and notation to address status and event phenomena symmetrically. We demonstrate the effectiveness of this model for designing and understanding mixed control interaction, an especially important topic in the design of multi-user systems.
Towards scalable compositional analysis
Authors: Corbett James C. , Avrunin George S.
Published: July 2004

Due to the state explosion problem, analysis of large concurrent programs will undoubtedly require compositional techniques. Existing compositional techniques are based on the idea of replacing complex subsystems with simpler processes with the same interfaces to their environments, and using the simpler processes to analyze the full system. Most algorithms for proving equivalence between two processes, however, require enumerating the states of both processes. When part of a concurrent system consists of many highly coupled processes, it may not be possible to decompose the system into components that are both small enough to enumerate and have simple interfaces with their enviornments. In such cases, analysis of the systems by standard methods will be infeasible.In this paper, we describe a technique for proving trace equivalence of
deterministic
and
divergence-free
systems without enumerating their states. (For deterministic systems, essentially all the standard notions of process equivalence collapse to trace equivalence, so this technique also establishes failures equivalence, observational equivalence, etc.) Our approach is to generate necessary conditions for the existence of a trace of one system that is not a trace of the other; if the necessary conditions cannot be satisfied the systems are equivalent. We have implemented the technique and used it to establish the equivalence of some systems with state spaces too large for enumeration to be practical.
Data flow analysis for verifying properties of concurrent programs
Authors: Dwyer Matthew B. , Clarke Lori A.
Published: July 2004

In this paper we present an approach, based on data flow analysis, that can provide cost-effective analysis of concurrent programs with respect to explicitly stated correctness properties. Using this approach, a developer specifies a property of a concurrent program as a pattern of selected program events and asks the analysis to verify that all or no program executions satisfy the given property. We have developed a family of polynomial-time, conservative data flow anlysis algorithms that support reasoning about these questions. To overcome the traditional inaccuracies of static analysis, we have also developed a range of techniques for improving the accuracy of the analysis results. One strength of our approach is the flexibility allowed in choosing and combining these techniques so as to increase accuracy without making analysis time impractical.We have implemented a prototype toolset that automates the analysis for programs with explicit tasking and rendezvous style communication. We present preliminary experimental results using this toolset.
Reengineering a complex application using a scalable data structure compiler
Authors: Batory Don , Thomas Jeff , Sirkin Marty
Published: July 2004

P2 is a scalable compiler for collection data structures. High-level abstractions insulate P2 users from data structure implementation details. By specifying a target data structure as a composition of components from a reuse library, the P2 compiler replaces abstract operations with their concrete implementations.LEAPS is a production system compiler that produces the fastest sequential executables of OPS5 rule sets. LEAPS is a hand-written, highly-tuned, performance-driven application that relies on complex data structures. Reengineering LEAPS using P2 was an acid test to evaluate P2's scalability, productivity benefits, and generated code performance.In this paper, we present some of our experimental results and experience in this reengineering exercise. We show that P2 scaled to this complex application, substantially increased productivity, and provided unexpected performance gains.
Removing implementation details from C++ class declarations
Authors: Headington Mark R.
Published: July 2004

Data abstraction—a concept introduced at varying places in the CS1/CS2/CS7 sequence—separates the properties of a data type (its values and operations) from the implementation of that type. This separation of specification from implementation is achieved by encapsulating the implementation so that users of the type can neither access nor be influenced by the implementation details. Ideally, therefore, the specification should be implementation-independent.

The C++ class mechanism compromises information hiding by requiring the interface to include information—the private part of the class declaration—that is needed only for implementation purposes. This paper describes two techniques for removing details of implementation structure from the C++ class declaration and discusses the advantages and disadvantages of each.
Using an internal internship to enhance computer science education in a two-year college
Authors: Cohen Norman , Dann Wanda
Published: July 2004

A student internship in a suitable business or organization can augment, reinforce, and embellish material learned in the classroom. Computer Science student interns can experience such things as real-world development environments, projects which greatly exceed the scale of typical programming assignments, the utter importance of (possibly lacking) documentation, as well as diverse languages, operating systems, and hardware. Opportunities for such internships occur rarely, however, for many rural two-year colleges, especially those geographically isolated from companies which could provide this experience.

Despite such a situation at our college, we still provide students with an internship experience by creating an internal organization: the Software Development Internship (SDI) with the mission to develop custom software for other departments on campus. In this paper we describe the formation of the SDI, its activities, and some of the benefits and lessons learned to date.
Teaching dynamic programming techniques using permutation graphs
Authors: Liang Y. Daniel
Published: July 2004

Dynamic programming is one of important techniques in algorithm design. The permutation graph is a special type of graphs with theoretical significance and practical applications. Many graph problems such as the domination, and independent set problems can be solved efficiently using dynamic programming schemes by exploring the structural properties of permutation diagrams. Most of current algorithm textbooks use the knapsack problem and matrix chain product as examples for teaching this technique. This paper introduces an incremental and comprehensive approach to teaching dynamic programming using permutation graphs.
XDP
Authors: Arnow David M.
Published: July 2004

XDP is a simplified interface to the DP distributed programming library. I describe its use in a course on workstation programming, a pragmatic course whose mission is to cover concurrent programming, graphical user interfaces and event driven programming as well as network and distributed computing. Using XDP, rather than the native socket interface, makes it feasible to cover the last topics, squeezed though they are into a rather overloaded course. Finding (or building) teaching tools like XDP will become increasingly essential as more demands are placed on undergraduate CS curriculum coverage.
Youngster: a simplified introduction to computing
Authors: Studer Scott D. , Taylor James , Macie Ken
Published: July 2004

One of the more difficult portions of learning to program is memorizing and understanding the syntactic and semantic rules associated with a language. This paper discusses how to simplify this task as well as presents a case study of a simplified implementation to include multiple variable types successfully tested on first grade students.
Parallel threads
Authors: Harlan Robert M. , Akulis Joseph G.
Published: July 2004

One objective in establishing our NSF ILI funded parallel computation laboratory was to use closed, formal laboratory assignments to introduce parallelism throughout the core computer science curriculum. We discuss laboratory assignments developed for the Computer Organization (CS 3) and Algorithms (CS 4) courses.

The CS 3 lab introduces parallelism based upon processor replication and two-performance indices for evaluating performance of parallel algorithms, speedup and efficiency. One factor that effects performance on MIMD message passage architectures, the ratio of computation to communication, is also introduced.

The CS 4 lab guides students in developing a parallel version of Dijkstra's single source shortest path algorithm. A case study using parallel addition assists students in identifying potential parallelism by examining the data dependency of computations. Students working in teams of two develop a pseudo-code version of the single source shortest path algorithm for an abstract parallel machine. They also analyze the speedup and efficiency of an implementation of the algorithm for one, four and eight processors.
O.S. bridge between academia and reality
Authors: Pérez-Dávila Alfredo
Published: July 2004

This paper presents a different approach to solving the dilemma of balancing the theory and the practice in an undergraduate operating systems course. We are in the process of implementing a laboratory that allows students to experiment with a copy of the 386BSD Unix System. Students are guided through exercises with increasing complexity, from a single exercise of initializing a new file system to more complicated team projects. The laboratory does not require a set of machines dedicated to the Operating Systems Class which is the reason many instructors choose to use simulators or small academic operating systems. This is accomplished through the use of recent removable disk technology that provides enough speed and capacity to load the source code of a real system. This approach provides a more in-depth study of a system students are more likely to encounter when they leave school. It also allows students to work in teams in an environment closer to the real world and provides a strong foundation for students wishing to enter graduate school with intentions to specialize in the area of operating systems development.
An environment for interpreter-based programming language projects
Authors: Barr John , King L. A. Smith
Published: July 2004

This paper discusses the programming language course and presents an approach to some of the pedagogical challenges presented. We aim to expose students to all the concepts central to a traditional programming language course but also give experience with the implementation of various languages. To this end, we are developing a software environment, MULE, which supports this teaching goal. This paper gives an overview of MULE and discusses our recent experiences using MULE as a teaching tool.
A C-based graphics library for CS1
Authors: Roberts Eric S.
Published: July 2004

This paper describes a simple graphics library designed for a CS 1 course using ANSI C as its programming language. The library can be implemented easily on a variety of hardware platforms, providing a reasonable level of portability. Implementation currently exist for compilers on the Apple Macintosh, the IBM PC, and Unix workstations; the source code for each of these implementations is publicly available by anonymous FTP from the
Roberts.C.CS1
area on host
aw.com
. In addition, the public distribution includes a fully standard implementation that generates a PostScript representation of the graphical image.
Old dogs, new tricks
Authors: Willshire Mary Jane
Published: July 2004

The object oriented paradigm is sweeping the world of computer science and many educators advocate an object oriented programming language for CS1. At our school a large proportion of our student body consists of non-traditional students who are either starting college later, changing fields, or brushing up on their skills. We wanted to determine if older, non-traditional students were interested in OOP, and if interested, could they adequately compete with the younger students. We instituted a pilot program to teach C++ in a traditional academic style and collected data for a year for this study. We show that our older students in every age bracket did as well as, and in most cases much better than, those students in the 25 and under group. Based on the data collected, we feel the pilot program was a complete success.
Integrating a breadth-first curriculum with relevant programming projects in CS1/CS2
Authors: Wilson Ronald E.
Published: July 2004

The ACM/IEEE Guidelines (1990) for CS1/CS2 recommend that these classes present a variety of concepts from the field of computer science. This is a departure from the traditional method of presenting this course, a course that stressed primarily programming. This paper describes a CS1/CS2 curriculum that integrates the breadth-first approach coupled with programming assignments that reinforce concepts covered in this curriculum. Students still spend a majority of their effort on programming. However, the programs that they write represent concepts that are usually presented later in the curriculum. These programs include an SLR parser, a problem from the realm of scientific computation, a dynamic programming problem from formal language theory, an implementation of the relational algebra operators for querying relational databases, an example from the field of artificial intelligence, and a simple example of concurrent programming. This curriculum is no doubt daunting to some students, but it does succeed in integrating topics covered in a breadth-first curriculum with related programming assignments. Experience has shown that most students prefer this rigorous set of meaningful programming assignments to ones that are more contrived and trivial.
A cognitive-based approach to introductory computer science courses
Authors: Doran Michael V. , Langan David D.
Published: July 2004

A project has been undertaken this past year using a cognitive based approach to implement the Computing I and II courses as defined in Implementation D of Computing Curricula 1991. The salient features of this project include: (i) strategic sequencing and associated levels of mastery of key topics based on Bloom levels; (ii) a spiral approach to presentation; (iii) integral use of structured closed labs; (iv) frequent feedback and (v) early use of teams. This project has led to a series of course documents that explicitly define and schedule course micro-objectives, that map each micro-objective to a specific Bloom knowledge level, and that help to achieve and measure those objectives.
An experiment in learning about basic information system concepts
Authors: Laribi Atika , Léonard Michel , Parchet Olivier
Published: July 2004

We present, in this paper, an experiment in learning basic Information Systems (IS) concepts through practice in a self teaching environment. Students with no formal background in the area, engaged in a role playing game to produce a requirements document for a fictitious organisation, which was then implemented by students with a technical background. We used staff observations and student feedback, collected in different ways, to assess the experiment against the set goals. Students, who were very enthusiastic, learned about important aspects of IS analysis and design through their own group experience. Our own observations can also be used in a more general study of IS human factors.
An interactive lecture approach to teaching computer science
Authors: Rodger Susan H.
Published: July 2004

Students get more out of an interactive lecture than a passive lecture because they are given time to think. This time allows them to determine if they understand a concept, and if not to ask questions. This understanding is crucial when concepts build on one another. We describe our positive experiences in teaching sophomore-level computer science courses in an interactive lecture format with a computer in the classroom.
Teaching elementary queueing theory with a computer algebra system
Authors: Fitzgerald Sue , Place Jerry
Published: July 2004

Computer algebra systems such as Maple, Mathematica and MACSYMA are readily available for a wide range of PC's and workstations. Many college campuses have site licenses for these software tools and make them widely available to students through PC labs, across networks and on time sharing systems. Additionally student versions of these software tools are widely available at nominal cost. Computer algebra systems provide sophisticated computational support and are intuitive to use. In this paper we describe how we use a computer algebra system to support an upper division undergraduate course teaching elementary queueing theory. We discuss the significant enhancement added by using a computer algebra system for this course work. We present the traditional approach to this material, i.e., deriving the closed form solutions for a specific queueing model then we show how we approach the material using numerical solutions based on the general equations for steady state probabilities for a Poisson Birth-Death process. We present several examples and discuss the strengths of our approach.
Tools for teaching CCRs, monitors, and CSP concurrent programming concepts
Authors: Olsson Ronald A. , McNamee Carole M.
Published: July 2004

This paper describes three preprocessors that, respectively, convert conditional critical region (CCR) notation, monitor notation, and Communicating Sequential Processes (CSP) notation into equivalent programs written in the SR concurrent programming language. Our goal is to allow students to experiment and to obtain hands-on experience with these notations. Together with native SR, the three preprocessors provide a teaching tool for a wide spectrum of synchronization mechanisms. This paper also describes the favorable experience obtained in using the preprocessors in several courses. The preprocessors are part of the standard SR distribution, which runs on most UNIX systems; they are in the public domain and available via ftp.
Using metrics to evaluate student programs
Authors: Leach Ronald J.
Published: July 2004

Student programs in electronic form can be tested by the instructor against his or her own test data. There are other advantages to electronic submission. We report on the use of software metrics analysis tools to determine "similarities" in student programs. Availability of these tools has virtually eliminated student copying of assignments.
Explaining recursion to the unsophisticated
Authors: Haynes S. M.
Published: July 2004

This paper addresses the topic of explaining recursion to Beginning programmers. It briefly presents the common approaches, then describes an extension to those methods called the
activation tree
.
Computer language usage in CS1
Authors: Levy Suzanne Pawlan
Published: July 2004

The Reid Report [Reid 94] is a list of more than 400 schools throughout the world and the language they are using in their first computer science course (commonly referred to as ACM's CS1). It is a voluntary report updated regularly. Its list of schools is not exhaustive or complete. Based on this report, 139 colleges and universities within the United States who are not using Pascal were surveyed. The intent of the survey was threefold:• to find out why these schools are using their choice of language in their CS1 course,• how the instructors at these schools feel about their current language as it compares to Pascal in the way it aids in the teaching of introductory programming skills, and• which language these instructors feel is the best one to use in a CS1 course.The results of this survey, conducted in February 1995, are summarized below.
An educational project in computer science for primary and high school
Authors: Zanconi Marcelo , Moroni Norma , Señas Perla
Published: July 2004

We analyze four different points of view in the teaching of computer science at school, taking into account the aims of institutions, i.e, computer sciences as a formative, operational, informative and pedagogical tool.We present a particular experience that links the four points of view proposed in a curriculum for primary and high school. This is the result of a two year work developed under a project between our research group, InE, and a private institution of our city. We believe our approach is quite original because these four points of view were traditionally considered as opposites.
A methodology for a unified ADT course
Authors: Evans M. D.
Published: July 2004

"From an instructor's perspective (and also from the student's perspective) a course is rarely satisfying unless there is some 'big idea' that seems to hold the disparate elements together." [3,Pg.78]. This big idea is often lacking in a traditional introductory abstract data type (ADT) course, as students frequently perceive it to be a study of disjoint topics - a collection of ADTs. This paper proposes a context, indeed a methodology, for providing a unifying view of the topics and their significance, while suggesting an emphasis on the
abstract
nature, and
design
, of ADT's. Simultaneously, it supports a set of broad themes and recurring concepts which offer a unifying perspective on the pair of courses CS1 and CS2, and which establish fundamental ideas and skills pervasive throughout further studies in computing science.
Paradigms and laboratories in the core computer science curriculum
Authors: Hartel Pieter H. , Hertzberger L. O.
Published: July 2004

Recent issues of the bulletin of the ACM SIGCSE have been scrutinised to find evidence that the use of laboratory sessions and different programming paradigms improve learning difficult concepts and techniques, such as recursion and problem solving.Many authors in the surveyed literature believe that laboratories are effective because they offer a mode of learning that complements classroom teaching. Several authors believe that different paradigms are effective when used to support teaching mathematics (logic and discrete mathematics) and computer science (programming, comparative programming languages and abstract machines).Precious little evidence by way of reported results of surveys, interviews and exams was found in the ACM SIGCSE bulletins to support these beliefs.
Evolutionary design of complex software (EDCS)
Authors: Salasin John , Shrobe Howie
Published: July 2004

This document is intended to provide background information for offerers responding to BAA 95-40: Evolutionary Design of Complex Software (EDCS). It describes the general problem that the EDCS Program addresses along with some of the characteristics of the Program's organization. Then it discusses some concepts for evolutionary systems and some of the technology investigations that are felt to support those concepts. This is presented for illustrative purposes only. Offerors should not feel constrained to the particular concepts of evolution articulated nor to the technology areas and sample investigation projects delineated.
The chaos strategy
Authors: Raccoon L. B. S.
Published: July 2004

"What line of code should I write next?" This paper resulted from my search for an answer that reflects my experiences in writing real programs, and reflects both the Chaos model and life cycle. After trying to infer an answer directly from the Chaos life cycle, in fact from any life cycle, I ultimately gave up. I concluded that while life cycles describe what I
can
do in a project, life cycles do not describe what I
should
do in a project. For that I need another concept, such as strategy.Strategies are idealized plans of how software development should work. Strategies help us to prioritize the things we do. A general strategy defines an overall approach for solving a problem that must be adapted to meet local circumstances. A specific strategy defines immediate goals. A good specific strategy balances short-term progress with long-term goals.Applying the concept of strategy to software development may seem inappropriate, or even absurd, to software developers who normally worry about concepts like
correctness, specification,
and
quality.
Developers have been taught to think of software development as totally predictable, with each step a perfectly understood element. Strategy implies a contest which admits that a developer could lose. On the other hand, developers may be more familiar applying strategy to investments, marketing, elections, and war. People do meaningfully use strategy for complex military and business problems.In The Chaos Model and the Chaos Life Cycle, I argued that each software development project is a chaotic, multi-level sequence of issues that arise and get resolved. Developers repeatedly select an issue to resolve, devise an approach, implement a solution, maintain the resulting program, and so forth. Software development is a project-to-project, situation-to-situation, minute-to-minute process, with many levels. Developers must deal with all levels from the "whole project" level down to the "one line of code" level. In The Complexity Gap, I argued that the middle levels of a project are not addressed by the traditional Stepwise Refinement and Object-Oriented Design strategies. The macro-process and top-down strategies address the top levels of a project. The micro-process and bottom-up strategies address the bottom levels of a project.In this paper, I propose the Chaos strategy to guide development on the levels of a project within the Complexity Gap. I begin by describing parallels between software development and games of strategy, and by defining the Software Development Game. I then define elements of the Chaos strategy, a middle-out, technology-independent strategy. Finally, I show how to adapt the Chaos strategy to fit the various circumstances that arise in complex software development projects.
A GUI for a manager of lightweight processes
Authors: Billard Edward A. , Riedmiller Alice E.
Published: July 2004

A design is presented for a graphical user interface to a manager of lightweight processes. The manager is XINU-like in its support for semaphores, messages and sleeping but is implemented with the lightweight process library of UNIX. Each state change is piped to a GUI written in Tcl/Tk. The display shows processes waiting in queues and processes moving from state to state (i.e. free, suspended, ready, current, waiting, receiving, sleeping, writing, reading). The GUI has a control panel that allows the user to watch and debug user-written concurrent processes.
Beyond objects
Authors: Appelbe Bill , Abowd Gregory
Published: July 2004

In a recent article [5], Shaw puts forth the argument that a process control paradigm for structuring software is more natural, and hence most appropriate for process control applications. However, we believe that there are other considerations, such as scalability and maintainability, that need to be addressed when choosing a design paradigm. Our experience, and a re-examination of Shaw's models, suggests that object modeling is more appropriate for large scale process control applications.
Adaptable, reusable code
Authors: Davis Margaret J.
Published: July 2004

This paper discusses the concept of adaptability as a means for reaping the cost and schedule reduction benefits of reuse. Adaptability strives to implement the variability identified by domain analyses while managing the cost of implementation, extension, and use. The paper discusses a context for understanding different domain-specific reuse approches relative to adaptability and analyzes experience in designing and developing adaptable code. The experience is drawn from the ARPA Software Technology for Adaptable, Reliable Systems (STARS) joint demonstration project with U.S. Navy.
A reuse approach based on object orientation
Authors: Ghezala Henda Hadjami Ben , Kamoun Farouk
Published: July 2004

The aim of this paper is to present an approach to facilitate reuse. This approach, which is based on an object oriented design method, describes a way of structuring components and reuse library.

Two concepts, domain and theme, are introduced to allow a classification of components by the services that they offer and by application domain. The library itself is organized in three hierarchical levels -general, dedicated and personal-, where the reusable components are stored according to their degree of “interest” (general interest, by application type or particular). So, the library is generic and could cluster various reusable component types (specification components, design components, packages,…).

The contributions of this approach in the development of CASE tools are also emphasized.
An integrated approach to software reuse practice
Authors: Mambella E. , Ferrari R. , Carli F. D. , Surdo A. L.
Published: July 2004

Since 1993, Sodalia's Software Engineers have been studying a reuse program whose goal is making software reuse a significant and systematic part of the software process. The Sodalia's Corporate Reuse Program is intended to develop a Software Reuse Process that incorporates reuse-specific activities along the Object-Oriented Software Development Process, and a reuse library to support the classification and management of reusable components.

This paper focuses on the on-going experience of Sodalia in the gradual introduction of reuse practice in the organization, illustrates the evolutionary stages, and the reached results.
Specification matching for software reuse
Authors: Jeng Jun-Jang , Cheng Betty H. C.
Published: July 2004

Using formal specifications to represent software components facilitates the determination of reusability because they more precisely characterize the functionality of the software, and the well-defined syntax makes processing amenable to automation. We present specification matching as a method for classification, retrieval, and modification of reusable components. A software component is specified in terms of order-sorted predicate logic. For both components and methods, we consider not only exact match, but also relaxed match and logical match for peforming specification matching over a library of reusable software components.
From reuse library experiences to application generation architectures
Authors: Jarzabek Stan
Published: July 2004

Reuse through application generators has been successful in the area of programming language systems. We analyzed three language system projects that realized transition from the initial ad hoc programs, through libraries of reusable modules to application generator solutions. We tried to understand the underlying thinking process and technical factors that made such a transition possible. Based on this study, we generalized reuse experiences gained in the language system domain and formulated a reuse implementation framework. Our framework is to facilitate transition from component-based reuse to application generators in other domains. Ultimately, we hope our framework will offer reuse implementation guidelines for companies to realize such a transition. Initial findings are described in this paper.
Melding structured abstracts and World Wide Web for retrieval of reusable components
Authors: Poulin Jeffrey S. , Werkman Keith J.
Published: July 2004

Reusable Software Libraries (RSLs) often suffer from poor interfaces, too many formal standards, high levels of training required for their use, and most of all, a high cost to build and maintain. Hence, RSLs have largely failed to return the reuse benefits promised by their developers. This paper first describes an RSL implementation using the World Wide Web (WWW) browser Mosaic and shows how it meets most RSL needs, avoids most RSL pitfalls, and costs only a fraction of the cost for the average commercial RSL. Second, the paper describes a way to quickly assess the important aspects of a piece of software so programmers can decide whether or not to reuse it. Using the observation that when programmers discuss software they tend to convey the same key information in a somewhat predictable order, this paper describes a method to automatically mimic this activity using a Structured Abstract of reusable components. Structured Abstracts provide a natural, easy to use way for developers to (1) search for components, (2) quickly assess the component for use, and (3) submit components to the RSL.
Developing domain knowledge through the reuse of project experiences
Authors: Henninger Scott
Published: July 2004

Software development is no longer a homogenous field. Software is being developed for an increasingly diverse set of applications and user populations, each with different characteristics and development constraints. As a consequence, researchers and practitioners have begun to realize the importance of identifying and understanding the characteristics and special development needs of application domains. This paper presents a method for developing and refining knowledge about application domains by creating a repository of project experiences. Subsequent projects can then benefit from these experiences by locating similar projects and reusing the knowledge accumulated in the repository. We develop a framework for a system to capture relationships between development projects and resources for developing software, including process models, methods, technologies, and tools. We then show how this information can be reused to improve the productivity and quality of software development efforts.
Applying domain analysis and modeling
Authors: France Robert B. , Horton Thomas B.
Published: July 2004

In this paper we describe our experience in applying domain analysis within a company that develops personal electronic devices. We describe how we tailored the DSSA method to suit our needs and then present the process and representations that we found most useful for this situation. The conclusions and lessons learned are useful because few studies published at this time provide details about applications of domain engineering in commercial development environments.
Supporting software reuse within an integrated software development environment (position paper)
Authors: Ransom Keith J. , Marlin Chris D.
Published: July 2004

Significant gains in programmer productivity have been achieved through the use of simple abstraction mechanisms that enhance the reuse of code. There are other useful forms of abstraction (over arbitrary identifier bindings, for example) which could further increase reuse rates, but are not well supported by programming languages; such forms may be better expressed by exploiting mechanisms provided by an integrated programming environment. This paper outlines ongoing work which aims to provide programming environment mechanisms that support the reuse of code via various forms of abstraction that complement those traditionally provided by programming languages. The concept of derivation-based reuse is also defined, and a generic framework for its support is outlined. In addition, a collection of environment mechanisms, intended to fit within this framework, are outlined.
Software testability
Authors: Voas J. , Payne J. , Mills R. , McManus J.
Published: July 2004

Software reuse can be more readily enabled if the testing of the code in the previous environment is still applicable to the new environment. The reusability of previous verification efforts is an important parameter is assessing the “immediate” reusability of the code; in this paper, the verification technique that we are focusing on is software testing. This paper presents the use of a software testability measure, sensitivity analysis, as a quantitative assessment of the reusability of previous verification. The ability to reuse verification is a factor to consider in determining the reusability of code. We have applied this technique to a large NASA supersonic software simulation, High Speed Civil Transport (HSCT), and the reusability results of that application suggest a possible concern about the sufficiency of the original verification.
The quality of questionnaire based software maintenance studies
Authors: Jøgensen Magne
Published: July 2004

Questionnaires sent to maintenance managers is a frequently used approach to collect data on software maintenance. This paper reports findings from two studies, carried out at a large Norwegian maintenance organisation, investigating the quality of questionnaire based software maintenance studies.Interesting findings were, among others, that:- The definition of essential terms, for example of 'software maintenance', at the beginning of a questionnaire did not assure a consistent use of the terms by the questionnaire respondents.- Manager estimates of the proportion of effort spent on corrective maintenance were biased when based on best guesses instead of good data. For this reason, the frequently referred studies of Lientz and Swanson (1980) and Nosek and Palvia (1990) may have reported a too high proportion of effort spent on corrective maintenance.
Test and analysis of software architectures
Authors: Tracz Will
Published: July 2004

Some DoD programs now require prospective contractors to demonstrate the superiority of their software architectures for new weapons systems. This acquisition policy provides new software engineering challenges that focus heavily on the test and analysis of software architectures in order to determine the "best" architecture in terms of its implementability, affordability, extendability, scalability, adaptability, and maintainability --- not overlooking whether or not it will meet the functional requirements of the system.
An efficient state space generation for analysis of real-time systems
Authors: Kang Inhye , Lee Insup
Published: July 2004

State explosion is a well-known problem that impedes analysis and testing based on state-space exploration. This problem is particularly serious in real-time systems because unbounded time values cause the state space to be infinite. In this paper, we present an algorithm that produces a compact representation of reachable state space of a real-time system. The algorithm yields a small state space, but still retains enough timing information for analysis. To avoid the state explosion which can be caused by simply adding time values to states, our algorithm first uses history equivalence and transition bisimulation to collapse states into equivalent classes. In this approach, equivalent states have identical observable events although transitions into the states may happen at different times. The algorithm then augments the resultant state space with timing relations that describe time distances between transition executions. For example, the relation @(
tr
1
) + 3 ≤ @(
tr
2
) ≤ @(
tr
1
) + 5 means that transition
tr
2
is taken 3 to 5 time units before transition
tr
2
is taken. This is used to analyze timing properties such as minimum and maximum time distances between events. To show the effectiveness of our algorithm, we have implemented the algorithm and are currently comparing it to other existing techniques which generate state space for real-time systems.
An incremental approach to structural testing of concurrent software
Authors: Koppol Pramod V. , Tai Kuo-Chung
Published: July 2004

Structural testing of a concurrent program P involves the selection of paths of P according to a structure-based criterion. A common approach is to derive the reachability graph (RG) of P, select a set of paths of P, derive one or more inputs for each selected path, and force deterministic executions of P according to the selected paths and their inputs. The use of RG(P) for test path selection has the state explosion problem, since the number of states of RG(P) is an exponential function of the number of processes in P.In this paper, we present a new incremental approach to structural testing of P. Based on the hierarchy of processes in P, our incremental testing approach is to integrate processes in P in a bottom-to-top manner. When a set S of processes in P at the same level are integrated, we construct a reduced RG for S such that the reduced RG contains all synchronizations involving the processes in S and some of the synchronizations involving processes at lower levels in order to connect synchronizations involving processes in S. Based on the reduced RG for S, we can select test paths to focus on the detection of interface faults involving processes in S. After the selection of paths, RG(S) is further reduced in order to retain only some of the synchronizations involving processes in S that are needed in order to connect synchronizations between S and other processes in P. Our incremental approach alleviates the state explosion problem and offers other advantages.
Improving the accuracy of Petri net-based analysis of concurrent programs
Authors: Chamillard A. T. , Clarke Lori A.
Published: July 2004

Spurious results are an inherent problem of most static analysis methods. These methods, in an effort to produce conservative results, overestimate the executable behavior of a program. Infeasible paths and imprecise alias resolution are the two causes of such inaccuracies. In this paper we present an approach for improving the accuracy of Petri net-based analysis of concurrent programs by including additional program state information in the Petri net. We present empirical results that demonstrate the improvements in accuracy and, in some cases, the reduction in the search space that result from applying this approach to concurrent Ada programs.
Generating functional test cases in-the-large for time-critical systems from logic-based specifications
Authors: Morasca Sandro , Morzenti Angelo , SanPietro Pieluigi
Published: July 2004

We address the problem of generating functional test cases for complex, highly structured time-critical systems starting from a modularized logic-based specification written in the TRIOR
+
language, an object-oriented extension of the temporal logic TRIO.First, we present methods for producing test cases for a TRIO
+
specification module, referring both to the internal, hidden, portion of the module and to its interface. Then, we discuss criteria to be used in the construction of test cases from a TRIO
+
specification based on its composing modules and the connections among their interfaces. We formally define the notions related to test case derivation from TRIO
+
modules and we introduce an executable language for describing a variety of strategies for constructing test cases for structured TRIO
+
specifications starting from (parts of) the test cases of the composing modules. This language can be the basis for the implementation of an interactive tool for the semiautomatic construction of functional test cases from complex time-critical systems starting from their TRIO
+
specification.
Structural specification-based testing with ADL
Authors: Chang Juei , Richardson Debra J. , Sankar Sriram
Published: July 2004

This paper describes a specification-based black-box technique for testing program units. The main contribution is the method that we have developed to derive
test conditions,
which are descriptions of test cases, from the formal specification of each program unit. The derived test conditions are used to guide test selection and to measure comprehensiveness of existing test suites. Our technique complements traditional code-based techniques such as statement coverage and branch coverage. It allows the tester to quickly develop a black-box test suite.In particular, this paper presents techniques for deriving test conditions from specifications written in the Assertion Definition Language (ADL) [SH94], a predicate logic-based language that is used to describe the relationships between inputs and outputs of a program unit. Our technique is fully automatable, and we are currently implementing a tool based on the techniques presented in this paper.
Issues in the full scale use of formal methods for automated testing
Authors: Crowley J. L. , Leathrum J. F. , Liburdy K. A.
Published: July 2004

Experience from a full scale effort to apply formal methods to automated testing in the open systems software arena is described. The formal method applied in this work is based upon the Clemson Automated Testing System (CATS) which includes a formal specification language, a set of guidelines describing how to use the method effectively, and tool support capable of translating formal specifications into executable tests. This method is currently being used to develop a full scale test suite for IEEE's Ada Language Binding to POSIX. Following an overview of CATS, an experience report consisting of results, lessons learned and future directions is presented.