bluuebunny/crossref_metadata_2025 huggingface dataset:
Predicting dependability by testing
Authors: Hamlet Dick
Published: July 2004

In assessing the quality of software, we would like to make engineering judgements similar to those based on statistical quality control. Ideally, we want to support statements like: "The confidence that this program's result at
X
is correct is
p,
" where
X
is a particular vector of inputs, and confidence
p
is obtained from measurements of the software (perhaps involving
X
). For the theory to be useful, it must be feasible to predict values of
p
near 1 for many programs, for most values of
X.
Blum's theory of self-checking/correcting programs has exactly the right character, but it applies to only a few unusual problems. Conventional software reliability theory is widely applicable, but it yields only confidence in a failure intensity, and the measurements required to support a correctness-like failure intensity (say 10
-9
/demand) are infeasible. Voas's sensitivity theory remedies these problems of reliability theory, but his model is too simple to be very plausible. In this paper we combine these ideas: reliability, sensitivity, and self-checking, to obtain new results on "dependability," plausible predictions of software quality.
Using perturbation analysis to measure variation in the information content of test sets
Authors: Morell Larry , Murrill Branson
Published: July 2004

We define the information content of test set T with respect to a program P to be the degree to which the behavior of P on T approximates the overall behavior of P. Informally, the higher the information content of a test set, the greater the likelihood an error in the data state of a program will be manifested under testing.Perturbation analysis injects errors into the data state of an executing program and traces the impact of those errors on the intervening states and the program's output. The injection is performed by perturbation functions that randomly change the program's data state. Using perturbation analysis we demonstrate that different test sets may satisfy the same testing criterion but have significantly different information content.We believe that "consistency of information content" is a crucial measure of the quality of a testing strategy. We show how perturbation analysis may be used to assess individual testing strategies and to compare different testing strategies.The "coupling effect" of mutation testing implies that there is little variation among mutation-adequate test sets for a program. This implication is investigated for two simple programs by analyzing the variation among several mutation-adequate test sets.
Linear and structural event sequence analysis
Authors: Howden W. E. , Shi G. M.
Published: July 2004

An approach to systematic informal program analysis is discussed in which comments that describe hypotheses and assertions about the behavior of programs are analyzed. Event sequence comments analysis methods analyze the consistency of comments that describe events. Two event sequence analysis methods are discussed, one of which uses a linear event sequence model, and which has been applied to the analysis of large data processing systems. The other uses a new approach involving rule-based structural models, and has been applied to the analysis of Ada programs.
Generation of multi-formalism state-space analysis tools
Authors: Pezzè Mauro , Young Michal
Published: July 2004

As software evolves from early architectural sketches to final code, a variety of representations are appropriate. Moreover, at most points in development, different portions of a software system are at different stages in development, and consequently in different representations. State-space analysis techniques (reachability analysis, model checking, simulation, etc.) have been developed for several representations of concurrent systems, but each tool or technique has typically been targeted to a single design or program notation.We describe an approach to constructing space analysis tools using a core set of basic representations and components. Such a tool generation approach differs from translation to a common formalism. We need not map every supported design formalism to a single internal form that completely captures the original semantics; rather, a shared "inframodel" represents only the essential information for interpretation by tool components that can be customized to reflect the semantics of each formalism. This results in more natural and compact internal representations, and more efficient analysis, than a purely translational approach.We illustrate the approach by applying the prototype tool to a small example problem, coordination of access to a coffee machine. The coffee machine is controlled by an Ada program, and the protocol of human users is modeled with Petri nets. Nets and process graph models are represented in the common internal form, and their composite behavior is analyzed by the prototype tool.
A semantic model of program faults
Authors: Offutt A. Jefferson , Hayes J. Huffman
Published: July 2004

Program faults are artifacts that are widely studied, but there are many aspects of faults that we still do not understand. In addition to the simple fact that one important goal during testing is to cause failures and thereby detect faults, a full understanding of the characteristics of faults is crucial to several research areas in testing. These include fault-based testing, testability, mutation testing, and the comparative evaluation of testing strategies. In this workshop paper, we explore the fundamental nature of faults by looking at the differences between a syntactic and semantic characterization of faults. We offer definitions of these characteristics and explore the differentiation. Specifically, we discuss the concept of "size" of program faults --- the measurement of size provides interesting and useful distinctions between the syntactic and semantic characterization of faults. We use the fault size observations to make several predictions about testing and present preliminary data that supports this model. We also use the model to offer explanations about several questions that have intrigued testing researchers.
Reachability analysis of feature interactions
Authors: Pomakis Keith P. , Atlee Joanne M.
Published: July 2004

Features are added to an existing system to add functionality. A new feature
interacts
with an existing feature if the behavior of the existing feature is changed by the presence of the new feature. Our research group has started to investigate how to detect feature interactions during the requirements phase of feature development. We have adopted a layered state-transition machine model that prioritizes features and avoids interactions due to non-determinism. We have a tabular notation for specifying behavioral requirements of services and features. Specifications are composed into a reachability graph, and the graph is searched for feature interactions. This paper demonstrates how reachability analysis has been used to automatically detect known control interactions, data interactions, and resource contentions among telephony features.
Evaluating software engineering methods and tool—part 2
Authors: Kitchenham Barbara Ann
Published: July 2004

In the previous article about the DESMET evaluation methodology, I identified nine different types of evaluation:1. Quantitative Experiments2. Quantitative Case Studies3. Quantitative Surveys4. Feature Analysis---Screening mode5. Feature Analysis---Case Study6. Feature Analysis---Experiment7. Feature Analysis---Survey8. Qualitative Effects Analysis9. Benchmarking.This article considers the way in which different evaluation requirements and organisation capabilities affect your choice of evaluation method. Your particular choice of evaluation method will be affected by your evaluation goals, the characteristics of the object you want to evaluate, the characteristics of the organisation you work in, and the limitations and constraints placed on the evaluation exercise. These different factors interact in complicated ways, so it is difficult to identify which evaluation method is the most appropriate.The specific criteria that the DESMET methodology uses to determine your circumstances are:1. The evaluation context.2. The nature of the expected impact of using the method/tool.3. The nature of the object (i.e., method/tool/generic method) to be evaluated.4. The scope of impact of the method/tool.5. The maturity of the method/tool.6. The learning curve associated with the method/tool.7. The measurement capability of the organisation undertaking the evaluation.These issues are discussed in the following sections.
Toward quality oriented IS design processes using two levelled design
Authors: Kokol Peter
Published: July 2004

The quality of information systems (IS) is strongly related with the quality of the IS design process and both are fundamental issues in successful IS construction and use process. In the paper we present a two-levelled IS design approach aimed to result in both quality oriented information system design processes and quality information systems.
The systems engineer and the software crisis
Authors: Johnson D. M.
Published: July 2004

This report examines the software crisis from a systems engineer's viewpoint. It analyses the key areas of requirements specification, verification and validation and software re-use. It assesses some of the solutions to the crisis proposed by the software engineering community and highlights some of their problems and limitations from the systems engineer's perspective.The report describes how, through the use of computer-aided symbolic specification techniques and simulation, and with an understanding of the software development process, the skilled systems engineer can contribute to the resolution of the software crisis. The skilled systems engineer, can through the use of these techniques and by the application of systems engineering methods and project management skills, reduce the demands placed on software engineers, hence reducing the software engineering effort and also reducing the total development cost.
Bad fixes, change specifications, and linguistic constraints on problem diagnosis
Authors: Kelsey Robert Bruce
Published: July 2004

Analyzing, diagnosing, and proposing fixes to problems in complex software is essentially a linguistic activity: we think in languages such as C and English, we analyze written problem reports, we read listings. In cognitive psychology and interpretation theory, the linguistic constraints upon cognition are well established; but with the exception of those authors working within the field of Speech Act Theory, little has been said about how these constraints affect software problem diagnosis or what we can do to overcome these constraints. This paper examines some of the linguistic aspects of software problem analysis, showing how these may contribute to the bad fix, and then describes a change specification procedure specifically designed to help development teams overcome some of the liabilities of interpreting complex software failures.
Airport 95
Authors: Swartz A. John
Published: July 2004

The Denver International Airport automated baggage system was a major news story spanning the years 1994-95. Reconstruction of the events of the project management of this system serves as an example of project summary reporting, which is stipulated in every project management methodology, but which is seldom or never done. The author provides sufficient detail to enable simulation of the design approach alternatives. If other projects are reported in the same format, it will be possible to compare projects on a design phase and/or event-by-event basis. The author recommends establishment and maintenance of a knowledge base of specific causes for failed software development projects.
The prisoner's dilemma tournament revisited
Authors: Resler Dan
Published: July 2004

One much-studied method for investigating trust building and cooperation is the
iterative
Prisoner's Dilemma Tournament (iPDT). An iPDT is easily simulated on a computer and is an excellent project in the CS1/CS2 curriculum to introduce students to the concepts of modular programming and information hiding. It is highly motivating, it encourages creative solutions, it allows students with varying abilities to do equally well, and there is no one 'ideal' solution. A software system that allows for the
automatic
generating of tournaments is presented in this paper, as well as information on downloading the software from the author.
Current research directions in software engineering for parallel and distributed systems
Authors: Jelly Innes , Gorton Ian
Published: July 2004

In March 1996, the First IFIP Workshop on Software Engineering for Parallel and Distributed Systems was held in Berlin, Germany. The two day workshop was co-sponsored by the German Computer Society GI (Gesellschaft fur Informatik), and organised in association with the International Software Engineering Conference--- ICSE 18.The aim of the workshop was to provide a forum for exchange of information and publication of the latest technological and theoretical advances in software engineering for parallel and distributed systems. Our previous experience of running short workshop on this topic in Aachen, Germany (1993), Como, Italy (1994) and Hawaii, USA (1995) had indicated that there was a growing need for this specialized event [1], [2], [3]. The International Programme Committee was formed from a group of experts in different countries and application areas, all of whom were enthusiastic to explore and publicize contemporary research in parallel and distributed software engineering.In this report we discuss the rationale for the workshop, detail its outcomes and look at some of the research issues that it highlighted. The proceedings of the workshop are published by Chapman and Hall [4], and full information is available on the PDSE Web page: http://www.dcs.shef.ac.uk/~prc/PDSE.html
MMSD'96
Authors: Mühlhäuser Max
Published: July 2004

Multimedia imposes quite a number of specific issues and requirements on software. While system support for multimedia has been seriously investigated for several years now, the software engineering community has not yet reached a deep understanding of the impacts of multimedia on their field. MMSD'96 brought together a representative spectrum of researchers investigating this issue. Four general observations could be retained from their contributions: 1. distributed multimedia applications exploit both more long-term potential and more persistent research problems than multimedia PC applications; 2. A reference model of multimedia software is not yet in reach; the large number of models proposed, even at MMSD, still lack better rationales, theoretic foundation, and convergence. 3. the MMSD community brings together people with a "document-background" and those with a "software background"; their views and approaches are still far from being harmonized. 4. While the multimedia community struggles for a common understanding among its members, it is in desperate need of a harmonization with approaches to distributed software development. In the remainder of this article, we will review issues to be addressed in the MMSD context, discuss the contributions made at the workshop itself, and draw conclusions for the state of the art.
Analyzing multi-phase searching algorithms
Authors: Bradley Michael J.
Published: July 2004

This paper presents a family of multi-phase searching algorithms that can enrich the discussion of searching algorithms in courses like CS13 Algorithms or CS7 Data Structures and Algorithm Analysis. These algorithms exhibit a natural but subtle relationship between the sequential search and binary search algorithms. They are non-trivial algorithms, yet they are easy to understand. Their complexity analysis is accessible, making use of differential calculus, Lagrange multipliers and base-2 logarithms. They have many practical applications and they appeal to students.
Introducing computer concepts by simulating a simple computer
Authors: Campbell Robert A.
Published: July 2004

The simulated computer consists of (1) main memory, (2) a register known as the accumulator, (3) a central processing unit (CPU), and (4) an instruction counter. This computer recognizes 8 op codes (Halt, Load, Store, Add, Subtract, Read, Write, and Branch On Zero). The computer is simulated by creating a program in Pascal or C++. This program simulates the execution of programs written by students, such as adding two numbers and printing their sum. Student programs are written in machine language and executed by the simulated computer. Students can write programs in assembly language, compile them by hand, and then test them by running them on the simulated computer. This example has been helpful in teaching students what a computer is and what computers can do.
Rethinking the CS-2 course with an object-oriented focus
Authors: Fienup Mark
Published: July 2004

Clearly, switching to the object-oriented paradigm as the first paradigm students learn must be accompanied by curricular changes. After three semesters of experience, this paper addresses the pedagogical problems encountered in switching to the object-oriented programming paradigm in the CS-2 course and our solutions to these problems.
Designing stimulating programming assignments for an algorithms course
Authors: Mitzenmacher Michael
Published: July 2004

The field of random graphs contains many surprising and interesting results. Here we demonstrate how some of these results can be used to develop stimulating, open-ended exercises for courses in algorithms and data structures or graph theory. Specifically, we provide problems for algorithms that compute minimum spanning trees, connected components, maximum flows, and all-pairs shortest paths.
Java as a first language
Authors: Hosch Frederick
Published: July 2004

In this note, we outline some issues raised in considering the use of the programming language Java
TM
to support a first course in software development. The course - essentially CS 1 - is centered on the design and implementation of simple objects, and employs an iterative specify/design/implement/test strategy to introduce data design and traditional procedural concepts. We enumerate some aspects of the Java language that attracted our interest, and identify some areas of the language design that could be modified to better meet our needs in an introductory computer science course.
A sequence of lab exercises for an introductory compiler construction course
Authors: Coon Lawrence A.
Published: July 2004

A sequence of laboratory exercises for an introductory compiler construction course is described. The labs are based on four increasingly complex versions of an imperative language designed so that each version builds on the previous. The third version supports integer and character data types and arrays of integers and characters. The fourth version adds procedures, but has only integer data. The procedures do not nest, but direct recursion is supported.
Evaluating software engineering methods and tool—part 4
Authors: Sadler Chris , Kitchenham Barbara Ann
Published: July 2004

In previous articles, we have described the range of methods available if you want to evaluate a software engineering method/tool and the criteria you need to consider to select a method appropriate to your individual circumstances. In future articles we will describe some guidelines to help you perform quantitative case studies and feature analysis. However, in this article we would like to review some of the human factors issues that can affect an evaluation exercise.
Succeedings of the 8th international workshop on software specification and design
Authors: Kramer Jeff , Wolf Alexander L.
Published: July 2004

The 8th International Workshop on Software Specification and Design (IWSSD-8) was held at Schloss Velen, Germany, in March 1996. In order to foster informed and fruitful discussions, the workshop was an invitation-only event of limited size. Based on formal submissions, approximately 60 people were selected and invited. Like its predecessors, IWSSD-8 maintained the principle that the accepted papers should serve as background material for the workshop. Therefore, the workshop did not include formal paper presentations, but rather provided an opportunity to engage in real work, with intensive discussions focussed around major themes. Each theme was discussed in a separate working group directed by a Working Group Chair who organized their group members so as to discuss the research issues of that particular theme. This year the themes selected were Requirements Engineering, Design Engineering, Software Architecture, and Concurrency/Distribution.IWSSD has established a tradition of using "case studies" as a focus for individual working groups. These case studies, supplied in advance to participants, have proved to be a fruitful way of working. Evidence of this can be seen most clearly in the "succeedings" or workshop reports which have followed previous workshops. It was decided that for IWSSD-8, in order to provide common ground between the themes, a single common case study should be used. The "Report on the Inquiry into the London Ambulance Service" was selected, with each theme drawing on it in a manner appropriate to their own interests and concerns.The London Ambulance Service (LAS) is briefly summarized below and discussed in the first paper appearing in the proceedings. The case study was presented in a plenary session at the beginning of the workshop and the findings of the different working groups presented and discussed at the end of the workshop, again in a plenary session. In order to make best use of the time available, working group members were asked to prepare for the workshop by familiarizing themselves with the case study and the major issues in their area relevant to that case study. We believe that this format made it both attractive and rewarding for people to attend, and was a major reason for the success of this workshop.
Some comments on software methodology versus CASE
Authors: Ying Jing , He Zhijun
Published: July 2004

This paper presents a personal viewpoint on the relationship between software methodology and Computer-aided Software Engineering ( CASE). Also several questions are put forward:
Can CASE technology contribute to the high quality and efficient productivity of software product? Can CASE explore its largest power based on current software methodology? Or need current software methodology be revolutionized to a great degree? How should software researchers deal with the roles, significance and relationships among CASE, software methodology, software re-engineering, and so on?
The answers to these questions will have vital effect on the development of software industry in the next century.
Planning and design of information systems using OODPM
Authors: Drori Offer
Published: July 2004

The process of system analysis and its planning includes various stages. Over the years various methodologies have been defined for this process. The methodologies themselves constitute a method that regulates the various stages in the process of planning and developing the information system. Each methodology has its own advantages and disadvantages but, generally, the correct methodology must be adapted to the required system.The aim of this article is to describe a new methodology, known as OODPM - Object Oriented Design by a Prototype Methodology, that integrates two existing methodologies, namely OOD and Prototype, bringing together many advantages. The principle advantages of this method are as follows: the ability to reduce planning time; to better define user requirements; to plan an enhanced information system; to bridge the gap between the design of the required solution and its development. This article will offer a brief survey of the methodologies currently used in the development and planning of information systems, focusing on the OODPM method and the tools it uses.
Songs and the analysis of algorithms
Authors: Chavey Darrah
Published: July 2004

In teaching a course that includes the analysis of algorithms, songs can be used as teaching examples. Multiple examples can be done at one time, or in one homework set, without the background explanation required to analyze real algorithms. Many components of algorithm analysis can be introduced using an analysis of songs. This is particularly useful at gaining experience extracting summations from "word problems."
Developing the VLSI laboratory for the computer architecture course
Authors: Concepcion Arturo I. , Millican David R.
Published: July 2004

The paper presents an alternative way of having a hardware laboratory for the computer architecture course that is taught in every computer science curricula. For institutions like CSUSB, with no College of Engineering, having an actual hardware laboratory will be cost prohibitive. An alternative way is to have a set of computer-aided design (CAD) tools where students can design hardware and then test their designs using simulation. This has been done at CSUSB. By using MAGIC (a VLSI layout design tool) and IRSIM (a functional logic simulator) the VLSI Design Laboratory was developed for the computer architecture course in the Department of Computer Science. The VLSI Design Laboratory was implemented using the machines obtained from a matching equipment grant from IBM which consists of five IBM RS/6000s and 15 XStations. The paper presents how the laboratory complements the lecture and how the students learn the hierarchical design methodology of VLSI circuits. Future directions of the VLSI Design Laboratory are also presented.
An object-oriented program development environment for the first programming course
Authors: Kölling Michael , Rosenberg John
Published: July 2004

Over the last ten years there has been a major shift in programming language design from procedural languages to object-oriented languages. Most universities have adopted an object-oriented language for their first programming course. However, far less consideration has been given to the program development environment. In this paper we argue that the environment is possibly more important than the language and existing environments fail to fully support the object-oriented paradigm. We describe a new program development environment and show how it has been specifically designed to support object-oriented design and programming.
Preparation for research
Authors: Fekete Alan
Published: July 2004

Traditional curricula have concentrated on teaching students the content of a subject; however, it has recently become apparent that effective education needs to include explicit instruction in many of the auxiliary skills and attitudes needed for the content to be useful. This applies just as much at advanced levels as at introductory ones, though the impact on teaching practice is not yet widespread. This paper describes an innovative module taught to students who are about to commence research, in which these students are given explicit guidance on how to judge the work of others (or their own work). The module is provided to undergraduates intending to perform an "Honours" research project in their final year; however, the material would also be relevant to students in a graduate program or senior seminar.
Teaching computer science
Authors: Daniels Mats , Gal-Ezer Judith , Sanders Ian , Teague G. Joy
Published: July 2004

In this paper we compare and contrast computer science curricula in four universities in four different countries (and continents): Australia; Israel; South Africa and Sweden. Uppsala University in Sweden is a European university founded in 1477 with a long history of tradition. The University of Witwatersrand in South Africa and Deakin University in Australia evolved from 'Schools of Mines' (technical schools) in 1922 and 1977 respectively and have their roots in the British academic system. The Open University of Israel, established in 1974 by the Ministry of Education, began teaching in 1976. As new universities, Deakin University and the Open University of Israel sought to fill needs not met by existing universities, so both have concentrated on distance learning (off-campus) programs. For similar reasons, Deakin University and the Open University of Israel also provide special non-degree short courses and programs. We refer to undergraduate and graduate studies and consider degree requirements, methods of delivery, assessment, and costs. We also briefly mention such issues as programming languages and the development and evolution of programs of study and of individual courses in the four universities.
Internet-accessible information retrieval tools for advanced DB/IR courses
Authors: Cunningham Sally Jo
Published: July 2004

A number of information retrieval tools are now freely available over the Internet, either as full production programs or demos. These programs illustrate a wide variety of IR techniques, and can allow students to gain realistic, hands-on experience with a variety of algorithms that were previously difficult to discuss other than in theory. In addition, many of these programs are associated with computing-related document collections that in and of themselves are useful for computer science students.
Database theory in practice
Authors: Dietrich Suzanne W. , Urban Susan D.
Published: July 2004

This paper describes the use of cooperative group learning concepts in support of an undergraduate database management course that emphasizes the theoretical and practical aspects of database application development. The course project is divided into three main phases, involving requirements analysis and conceptual design, relational database mapping and prototyping, and database system implementation using Microsoft Access. The project deliverables are designed so that students not only develop a database implementation, but also evaluate their design in terms of functional dependencies, normal forms, the lossless join property, and the dependency preservation property, thus establishing the need for sound database design principles. Students are required to actively participate in each phase, with students assuming different roles in each phase to allow them to experience different leadership responsibilities. As part of the grading process, students evaluate their own performance as well as the performance of others in the group. This paper describes our experience with the structure and administration of cooperative groups and provides a discussion of the lessons we have learned, including initial observations of the effectiveness of the approach.
Creating Windows applications using Borland's OWL classes
Authors: Szuecs Laszlo
Published: July 2004

This paper presents a brief overview of Windows programming in C++ with Borland's OWL classes and describes the planning and organization of a course in graphical user interfaces. It may be helpful to instructors who would like to combine the creation of graphical user interfaces with an intermediate or advanced course in object-oriented programming.
A methodology for active, student-controlled learning
Authors: Carver Curtis A. , Howard Richard A. , Lane William D.
Published: July 2004

This paper outlines a methodology to improve the performance of the weakest students through networked hypermedia and in-class exercises. These efforts are an outgrowth of experiments using networked hypermedia in the form of the World Wide Web (WWW) as the basis for networked courseware [1-4]. While initial approaches significantly enhanced the performance of the average and best students, there was no noticeable gain in the performance of the weakest students [4]. They continued to come into class without preparing and expected to somehow condense the learning process into five 55-minute sections every two weeks. In order to enhance the performance of these students, a series of procedures were developed that should increase their performance while minimizing any negative impact on the rest of class. The first procedure uses a networked, Common Gateway Interface (CGI), form-based Student Response System to enhanced communications and expectations between the student and professor. The Student Response System automates the grading of homework assignments, and as a result, facilitates nightly homework assignments without increasing the grading load on the professor. The second component of this methodology involves developing a series of graded, in-class, group exercises that can be easily graded in-class, represents a substantial portion of the final grade, and requires a public presentation of the group's results. Together, these tools and practices form a methodology for reaching the weakest students and enhancing their performance.
Explaining inheritance
Authors: Biddle Robert , Tempero Ewan
Published: July 2004

Programmers new to the object-oriented paradigm often have difficulty learning how to use inheritance properly. In this paper we introduce an approach to explaining inheritance that is based on understanding the nature of reusability. We show how the important aspect of inheritance is
interface conformance
, and explain the role this plays in supporting reusability. We then outline a method for determining when and how to use both single inheritance and multiple inheritance, and discuss the implications of our approach.
Designing closed laboratories for a computer science course
Authors: Fekete Alan , Greening Antony
Published: July 2004

A recent trend has been to accompany Computer Science courses by "closed laboratories" where students carried out tasks with supervision and guidance. This paper presents a methodology for designing a complete sequence of laboratories to support the instruction in a course. The design considers both the technical concepts to be conveyed and the learning experiences through which students learn. We demonstrate the way the methodology has been used to design the lab sequence for a Pascal-based CS1 course.
User-level distributed file systems projects
Authors: McDonald Chris
Published: July 2004

One of the greatest benefits provided by computer networks, in particular local area networks, is the ability to access files served by other computers in a network. Whereas file system concepts are first introduced in
Operating Systems
units, many file system concepts need to be readdressed and generalized in later
Computer Networks
units. Moreover, as students become increasingly familiar with internetworking and programs such as
ftp
, many of the strong links between the
Operating Systems
and
Computer Networks
units may be reinforced. This paper discusses the successes experienced with two strongly related projects offered in our third year
Computer Networks
unit. Each project requires students to support a minimal distributed file system by implementing user-level libraries which redefine a handful of operating system system calls supporting remote file access.
The first programming paradigm and language dilemma
Authors: Brilliant Susan S. , Wiseman Timothy R.
Published: July 2004

In recent years there has been increasing controversy surrounding the choice of a language for introducing programming to computer science majors. The issue has been complicated by the increasing acceptance of the importance of non-procedural paradigms. This paper compares the available vehicles for teaching programming to beginners. These comparisons are based on the results of a survey conducted by the authors in early 1995 and on the published reports and opinions of other workers in this area.
Fork diagrams for teaching selection in CS I
Authors: Kumar Amruth N.
Published: July 2004

We propose a fork diagram as a visual representation of the algorithm for binary selection. Among other things, fork diagrams can be used to teach students how to write correctly nested if-else statements, analyze nested selection code, appreciate the problem of dangling else, and understand short circuit evaluation of conditions with boolean operators (and and or). We have used C code to illustrate concepts, although fork diagrams can be used for any high level language.
Image processing as an exemplar of parallelism applied to graphics
Authors: Smith Harry F. , Plusnick Patrick , Sarojak Mark , Seitz William
Published: July 2004

In surveying the possible applications of parallel computing, computer graphics is singularly attractive. This is because many computer graphics algorithms are so computationally intensive and yet also inherently very parallel in nature. The primary objective of an NSF grant to the University of North Carolina at Wilmington was to establish parallel computing in the undergraduate curriculum. A secondary objective was to address the issue of parallelism for computer graphics; however, curricular constraints made this difficult to do. Our response to this difficulty was twofold. For one, we focused on image processing as a more accessible, but very significant, alternative to ordinary computer graphics. Also, as a means of enabling deeper student involvement, we were able to supplement the original equipment grant (ILI) with one for supporting student research (REU).
Activities to attract high school girls to computer science
Authors: Rodger Susan H. , Walker Ellen L.
Published: July 2004

We present several activities used in the two-week PipeLINK summer program for high school girls. These hands-on activities and interactive talks, presented mostly by female faculty, undergraduates, and graduate students, showed the girls the wide range of opportunities in the field of computer science
The consistent comparison problem in
N
-version software
Authors: Brilliant S S , Knight J C , Leveson N G
Published: July 2004

Multi-version or
N
-version programming [5] has been proposed as a method of providing fault tolerance in software. The approach requires the separate, independent preparation of multiple (
i.e.
"N"
) versions of a piece of software for some application. These versions are executed in parallel in the application environment; each receives identical inputs and each produces its version of the required outputs. The outputs are collected by a voter and, in principle, they should all be the same. In practice there may be some disagreement. If this occurs, the results of the majority (if there is one) are assumed to be the correct output, and this is the output used by the system.
Hereford workshop on software reuse
Authors: Ratcliffe M
Published: July 2004

It is generally acknowledged that one of the most effective means of improving the productivity of software development staff would be to increase the proportion of software which is reused. Not only should this increase productivity but it should also improve the reliability of software and reduce the elapsed time needed for its development. However, there appear to be major technical and organisational problems to be overcome before significant progress can be made in this direction.
GAO report FGMSD-80-4 revisited
Authors: Blum B I
Published: July 2004

The report in this title often is cited as a dramatic illustration of the magnitude of our software crisis. For example, consider this footnote in the
IEEE Trans. S.E.
(SE10, 1984, p 38).
Software development environments
Authors: Henderson P B
Published: July 2004

I just returned from California after attending the Second SIGSOFT/SIGPLAN ACM Symposium on Practical Software Development Environments held December 9-12 in Palo Alto. I feel the meeting was very successful and served its main purposes - to access the current state of the art in the environments area and to help define the important issues which must still be addressed. An objective evaluation of the symposium by Karl Reed is included in this subsection and I will present my overall views shortly.
Essential properties of IPSEs
Authors: Lehman M , Turski W
Published: July 2004

The phrase 'Integrated Project (or Programming) Support Environment' and its acronym IPSE are being increasingly used to describe a class of systems consisting of a collection of tools to be used in program development or evolution (maintenance). If the terms 'Integrated', 'Environment' and 'IPSE' are to be meaningful, their use should be restricted to systems that satisfy appropriate criteria. In particular, a clear distinction must be made between IPSE and, to coin a term, ICSE, where 'C' stands for 'coding'. The latter term is seen as applying to, for example, a collection consisting of an appropriate editor, a compiler, a linkage editor, a loader and a run time system.
Extension of record types
Authors: Wirth Niklaus
Published: July 2004

Software systems represent a hierarchy of modules. Client modules contain sets of procedures that extend the capabilities of imported modules. This concept of extension is here applied to data types. Extended types are related to their ancestor in terms of a set hierarchy. Variables of an extended type form a subset of the variables of the ancestor type. This scheme is easily and efficiently implementable, and is manifest by two new language constructs only: the type test and the type guard.
An interfacing and electronics course for computer science majors
Authors: Henry Michael
Published: July 2004

A course suitable for inclusion in the Curriculum '78 recommendations [1] under Special Topics is described here. The course introduces students to microcomputer interfacing and digital electronics principles via preassembled breadboard projects. For each of the projects, students develop software control and learn circuit design principles. The course covers digital devices without using electronics workstations, but a small microcomputer lab is required.
Teaching oral communication in computer science
Authors: Coté Vianney
Published: July 2004

Software analysts currently spend a large portion of their time communicating with others. Effective communication skills is of extreme importance if one wishes to be an efficient and productive software analyst. This article describes some of the exercises related to oral communications that are imposed on our students. Advantages and difficulties are discussed.
Evolution of object behavior using context relations
Authors: Seiter Linda M. , Palsberg Jens , Lieberherr Karl J.
Published: July 2004

A collection of design patterns was described by Gamma, Helm, Johnson, and Vlissides in 1994. Recognizing that designs change, each pattern ensures that a certain system aspect can vary over time such as the operations that can be applied to an object or the algorithm of a method. The patterns are described by constructs such as the inheritance and reference relations, attempting to emulate more dynamic relationships. As a result, the design patterns demonstrate how awkward it is to program natural concepts of behavioral evolution when using a traditional object-oriented language.In this paper we present a new relation between classes: the context relation. It directly supports behavioral evolution, and it is meaningful at the analysis, design, and implementation level. At the design level we picture a context relation as a new form of arrow between classes. At the implementation level we use a small extension of C++. The basic idea is that if class C is context-related to a base class B, then B-objects can get their functionality dynamically altered by C-objects. Our language construct for doing this is a generalization of the method update in Abadi and Cardelli's imperative object calculus. A C-object may be explicitly attached to a B-object, or it may be implicitly attached to a group of B-objects for the duration of a method invocation. We demonstrate how the context relation can be used to easily model and program the Adapter, Bridge, Chain of Responsibility, Decorator, Iterator, Observer, State, Strategy, and Visitor patterns.
Verification of communication protocols using data flow analysis
Authors: Naumovich Gleb N. , Clarke Lori A. , Osterweil Leon J.
Published: July 2004

In this paper we demonstrate the effectiveness of data flow analysis for verifying requirements of communication protocols. Data flow analysis is a static analysis method for increasing confidence in the correctness of software systems by automatically verifying that a given software artifact (e.g., design or code) must behave consistently with a specified requirement. In this case study, we apply the FLAVERS data flow analysis tool to pseudocode designs of the three way handshake connection establishment protocol and of the alternating bit protocol and prove that the behavior of the pseudocode is consistent with protocol behavioral requirement specifications. We show how FLAVERS is a particularly effective because it is computationally inexpensive, requires minimal human interaction, and is a general approach that can be applied incrementally until the desired accuracy is achieved. In addition, we show how assumptions about the environment in which a software system is executed can be incorporated into the analysis, using message losses as an example. We present experimental results and derive some guidelines about the classes of protocol requirement specifications that may be amenable to verification using FLAVERS.
Specification-based testing of synchronous software
Authors: Parissis Ioannis , Ouabdesselam Farid
Published: July 2004

Synchronous programming makes the implementation of reactive software easier and safer. Automatic formal verification methods based on model-checking have been developed within the synchronous approach to prove the satisfaction by the software of safety properties. But these methods often require huge memory or time amounts. As a solution to that problem we propose a set of formally defined testing techniques allowing for automatic test data generation. These techniques can be used independently or as a complement to formal verification, since they need the same set of specifications.
Model checking large software specifications
Authors: Anderson Richard J. , Beame Paul , Burns Steve , Chan William , Modugno Francesmary , Notkin David , Reese Jon D.
Published: July 2004

In this paper we present our results and experiences of using symbolic model checking to study the specification of an aircraft collision avoidance system. Symbolic model checking has been highly successful when applied to hardware systems. We are interested in the question of whether or not model checking techniques can be applied to large software specifications.To investigate this, we translated a portion of the finite-state requirements specification of TCAS II (Traffic Alert and Collision Avoidance System) into a form accepted by a model checker (SMV). We successfully used the model checker to investigate a number of dynamic properties of the system.We report on our experiences, describing our approach to translating the specification to the SMV language and our methods for achieving acceptable performance in model checking, and giving a summary of the properties that we were able to check. We consider the paper as a data point that provides reason for optimism about the potential for successful application of model checking to software systems. In addition, our experiences provide a basis for characterizing features that would be especially suitable for model checkers built specifically for analyzing software systems.The intent of this paper is to evaluate symbolic model checking of state-machine based specifications, not to evaluate the TCAS II specification. We used a preliminary version of the specification, the version 6.00, dated March, 1993, in our study. We did not have access to later versions, so we do not know if the properties identified here are present in later versions.