bluuebunny/crossref_metadata_2025 huggingface dataset:
Summary of the Dagstuhl workshop on future directions in software engineering
Authors: Tichy Walter F. , Habermann Nico , Prechelt Lutz
Published: July 2004

The intent of the workshop was to bring together leading scientists for identifying promising directions for future research in Software Engineering. The motivation for the workshop was the realization that Software Engineering research was not in good shape, with the present emphasis on management and risk control diverting attention from hard, technical subjects.After week-long, intensive discussions of a great number of issues, the following topics were seen as most crucial for progress:1. Developing the area of software architecture as a foundation of Software Engineering;2. Learning to master evolving systems;3. Building a scientific basis for Software Engineering;4. Emphasizing science and engineering know-how when educating practitioners.Formal methods, domain specific knowledge, special purpose languages, and reuse were seen as important approaches, but not as solutions or ends in themselves. There was also a fair amount of introspection on proper method, evaluation, and experimentation in Software Engineering research.This report contains participants' position statements and a record of the discussions. The editors hope that it may help make research in Software Engineering an exciting and thriving endeavor once again.
Database conversion planning
Authors: Saradhi Motamarri
Published: July 2004

In conventional approaches to Systems Development the crucial task of the exercise,
deployment
figures almost, at the end! The performance of the developed software can only be realized if and only if, there is a database to interact with. Surprisingly, this slips the attention of system developers! The challenge of converting the existing manual system, of all, the database maintained in paper volumes to that of computerized version, is not well accounted for. However, mundane this task,
Database Conversion Planning (DBCP)
, has a definite and dominant role to play in systems development. While handling several complex turnkey computerization projects, we are compelled to realize the criticality of DBCP. A careful consideration of these issues in the early stages of systems development has shown a multitude of benefits. As a result, we were able to deploy projects amidst several constraining and conflicting factors. The projects have won the appreciation of customers, of all, end-users. We would like to share the vision that had lead to the creation of these systems, where
software
and
quality
have only synonymous meaning! We finally wish that these thoughts will influence the practice of systems development or in general, software engineering.
Toward tools to support the Gries/Dijkstra design process
Authors: Terwilliger Robert B.
Published: July 2004

We are investigating software design processes using a three part approach. For a design method of interest, we first perform walkthroughs on a number of small problems. Second, we construct a simulation program which duplicates the designs produced by the walkthroughs, and third, we construct a process program that supports human application of the method. We have been pursuing this program for the formal design process developed by Dijkstra and Gries. In this paper, we describe our first step towards process programming this method: ISLET, a language-oriented program/proof editor. ISLET supports simple stepwise refinement with proof by automatically generating and mechanically certifying verification conditions. In addition, through ISLET the programmer has access to a library of pre-verified cliches that can be used to create programs more easily. We have constructed a prototype implementation in Prolog and used it to generate a number of example designs.
Does CASE make the customer happier
Authors: McLaughlin Robert
Published: July 2004

CASE technology is and will change the nature of software development. It is often haled as the thing that will save our industry. It is however just another tool. Just as a good hammer in the hands of a bad carpenter will make a house that collapses, CASE in the hands of a fool will save no one.
The Cobbler's children
Authors: Hefley William E.
Published: July 2004

This paper describes an approach to, and the relationship among, Business Process Improvement, Business Case Analysis, Information Engineering, and Total Quality Management. This approach is shown to not only complement existing software engineering approaches; but to also provide a framework for implementing continuous improvement processes focused on improving the quality of the organization's processes, services and products.
A simple straightforward method for software development
Authors: Steward Donald V.
Published: July 2004

This article presents a method that greatly simplifies software development even while providing a richer description of the system being developed. One tree like structure captures the configuration of the product throughout the whole development process. This avoids the much criticized 'chasm' between analysis and design [2] and gives complete traceability and measurability from requirements to code. It provides for the rich description of interfaces particularly important for large systems. Although the system is documented as a tree structure. it can be used with top-down, bottom-up, object oriented and formal styles of development. It can be tried and evaluated quite easily using a conventional outline processor, which allows one to show just the level of detail of whatever part one wishes to see. This article will start out by showing how you can use the basic method, then successively add more features to demonstrate the ramifications of this simple idea.
Gender imbalances in computer science at the University of the Witwatersrand
Authors: Galpin Vashti , Sanders Ian
Published: July 2004

This paper presents figures which describe the current situation with respect to male and female entry, persistence and success rates in Computer Science at the University of the Witwatersrand (Wits). The figures indicate that the situation at Wits is similar to that observed at universities in other countries where only a small number of the students are women. The figures also show that persistence and success rates for men and women are comparable. The paper ends by discussing our ideas for the next stage of this research --- an attitudinal survey directed at new first year science students at the University of the Witwatersrand.
Object-oriented programming for numerical methods
Authors: Shiau Lie June
Published: July 2004

This article introduces the merits of employing a new technique, Object-Oriented programming, in Numerical Methods courses. Object-Oriented programs interpret mathematical concepts more closely to their definitions. They are also easier to implement and maintain. More importantly, Object-Oriented techniques avoid many human errors. C++, an Object-Oriented extension to the popular C programming language, is chosen as the programming language for the demonstrated examples. We also include comparative examples to show that C++ is more suitable than the traditional scientific computer language FORTRAN for numerical programming.
Hopfield networks, neural data structures and the nine flies problem
Authors: Keating John G.
Published: July 2004

This paper describes two neural network programming projects suitable for undergraduate students who have already completed introductory courses in Programming and Data Structures. It briefly outlines the structure and operation of Hopfield Networks from a data structure stand-point and demonstrates how these type of neural networks may be used to solve interesting problems like Perelman's Nine Flies Problem. Although the Hopfield model is well defined mathematically, students do not have to be very familiar with the mathematics of the model in order to use it to solve problems. Students are actively encouraged to design modifications to their implementations in order to obtain faster or more accurate solutions. Additionally, students are also expected to compare the neural network's performance with traditional approaches, in order that they may appreciate the subtleties of both approaches. Sample results are provided from projects which have been completed during the last three-year period.
Clever programming languages exercises
Authors: Guimarães José de Oliveira
Published: July 2004

Books about programming languages usually propose exercises and questions requiring little creativity from students. Most exercises do not induce deeper thoughts about characteristics of languages and constructions. The paper proposes some exercises showing new constructions under unusual viewpoints, stimulating creativity.
Clarifying 'C'
Authors: Homkes Rick , Ross John Minor
Published: July 2004

In the classroom of today, students learning C often have experience in one or more languages such as BASIC, COBOL or Pascal. With the possible exception of students with Assembler skills, many of these individuals stumble when making the change to C. This review of the teaching and learning processes surrounding C highlights areas where students either face misunderstandings or will predictably under-use new features.
Using style to understand descriptions of software architecture
Authors: Abowd Gregory , Allen Robert , Garlan David
Published: July 2004

The software architecture of most systems is described informally and diagrammatically. In order for these descriptions to be meaningful at all, figures are understood by interpreting the boxes and lines in specific, conventionalized ways[5]. The imprecision of these interpretations has a number of limitations. In this paper we consider these conventionalized interpretations as architectural styles and provide a formal framework for their uniform definition. In addition to providing a template for precisely defining new architectural styles, this framework allows for the proof that the notational constraints on a style are sufficient to guarantee the meanings of all described systems and provides a unified semantic base through which different stylistic interpretations can be compared.
Towards increased productivity of algorithm implementation
Authors: Cai Jiazhen , Paige Robert
Published: July 2004

This paper reports experimental results that support the feasibility of a new transformational approach developed by the authors for implementing complex algorithms correctly and efficiently. The class of algorithms amenable to our methods includes nonnumerical graph algorithms. Experiments were performed to measure how this approach affects productivity (in terms of the number of source lines in the implementation divided by manual programming time) and running times. Comparative benchmarks showed that productivity can be increased over a conventional ad hoc approach by factors ranging from 5.1 to 9.9 Preliminary results also showed that the running time of C code produced by this new approach can be as fast as 1.5 times that of tightly coded high quality Fortran.
Targeting safety-related errors during software requirements analysis
Authors: Lutz Robyn R.
Published: July 2004

This paper provides a Safety Checklist for use during the analysis of software requirements for spacecraft and others safety-critical, embedded systems. The checklist specifically targets the two most common causes of safety-related software errors: (1) inadequate interface requirements and (2) discrepancies between the documented requirements and the requirements actually needed for correct functioning of the system. The analysis criteria represented in the checklist are evaluated by application to two spacecraft projects. Use of the checklist to enhance the software-requirements analysis is shown to reduce the number of safety-related software errors.
Software measure specification
Authors: Gustafson David A. , Tan Joo T. , Weaver Perla
Published: July 2004

This paper introduces the model-order-mapping (MOM) approach for specifying software/document measures. A MOM specification requires that the important attributes of the document be identified, a model that captures the attributes be chosen, and a mapping from the document to the model be specified. A partial ordering on the model must be developed as well as an order-preserving mapping from the model to an answer set. The relationship of the approach to measurement theory is shown. Validation of the MOM specification is presented.Properties of software measures that are guaranteed by a validated MOM specification and those that can be proved from a validated specification are described.
A practical technique for bounding the time between events in concurrent real-time systems
Authors: Corbett J. , Avrunin G.
Published: July 2004

Showing that concurrent systems satisfy timing constraints on their behavior is difficult, but may be essential for critical applications. Most methods are based on some form of reachability analysis and require construction of a state space of size that is, in general, exponential in the number of components in the concurrent system. In an earlier paper with L. K. Dillon and J. E. Wileden, we described a technique for finding bounds on the time between events without enumerating the state space, but the technique applies chiefly to the case of logically concurrent systems executing on a uniprocessor, in which events do not overlap in time. In this paper, we extend that technique to obtain upper bounds on the time between events in maximally parallel concurrent systems. Our method does not require construction of the state space and the results of preliminary experiments show that, for at least some systems with large state spaces, it is quite tractable. We also briefly describe the application of our method to the case in which there are multiple processors, but several processes run on each processor.
Dynamic impact analysis
Authors: Goradia Tarak
Published: July 2004

This paper introduces
dynamic impact analysis
as a cost-effective technique to enforce the error-propagation condition for detecting a fault. The intuition behind dynamic impact analysis is as follows. In a specific test-case, if an execution of a syntactic component has a
strong impact
on the program output and if the output is correct, then the value of that component-execution is not likely to be erroneous. To capture this intuition in a theoretical framework the notion of
impact
is formally defined and the concept of
impact strength
is proposed as a quantitative measure of the impact. In order to provide an infrastructure supporting the computation of impact strengths, program impact graphs and execution impact graphs are introduced. An empirical study validating the computation of impact strengths is presented. It is shown that the impact strengths computed by dynamic impact analysis provide reasonable estimates for the error-sensitivity with respect to the output except when the impact is via one or more error-tolerant components of the program. Potential applications of dynamic impact analysis in the area of mutation testing and dynamic program slicing are discussed.
Framework to define CASE tool requirements for distributed environment
Authors: Sharma Anil
Published: July 2004

In this paper we develop a framework for requirements definition for a CASE tool which cover all phases of software development life cycle. The resulting requirements are driven through set objectives. Since trend is toward distributed workstation based CASE tools, we would specifically focus on CASE tool requirements for heterogeneous network. These requirement are illustrative and require fine tuning for a specific organisation. But these can be used as a general framework to develop detailed requirement definition. These requirements become the part of general process of evaluating a CASE tool and can be used for example to develop 'Evaluation Check List'. Moreover requirements definitions is not aimed at conceiving a new CASE tool but addresses the issue of what to look for when selecting a CASE tool among many existing.
Guidelines for embedded software documentation
Authors: Marovac Nenad
Published: July 2004

Embedded program documentation, i.e. documentation included in computer programs within program comments, typically does not follow any formal standards or conventions with regards to its contents and structure.Software development organizations do not enforce any standards covering the information content or format of the embedded documentation. At best they may encourage the use of some proprietary rules. It is very common in such organizations that individual programmers have their own individual documentation styles.This is unfortunate since embedded documentation, containing proper information and being properly structured, can greatly assist us in reading and understanding software programs and their individual components during the maintenance of these programs or reuse of their components. Furthermore, the use of embedded documentation can assist in functional decomposition and design of computer programs and in ensuring the consistency of interfaces within programs.The purpose of this document is to report on the schema we use at San Diego State University in software projects and to propose guidelines regarding documentation embedded in computer programs and related documents. We believe that these guidelines will help us to maintain conformity in software documentation in programs developed at SDSU in Software Engineering and MultiMedia Labs.Furthermore, we have developed tools that are based on the proposed embedded documentation and that are used in four areas:1. interactive functional decomposition and design of programs2. automatic incorporation of submitted software into reuse libraries3. conversion of developed software into hypertext like structures that are used to maintain all material related to a software project in a form suitable for inspection, browsing, and updating4. automatic generation of software documentation on demand
A concurrent process model of software development
Authors: Davis Alan M. , Sitaram Pradip
Published: July 2004

Most published software development models present software engineering as a series of discrete phases. They often capture the "inevitable intertwining" of pairs of phases and they often capture the need to return to earlier phases when new information is ascertained. However, in actual software development projects, activities typically associated with multiple phases are performed concurrently. This paper presents a new model of the software development process that effectively captures the concurrency among activities that is in berent in all non-trivial software development. Statecharts are used to present the model.
A reusability-based software development environment
Authors: Cheng Jingwen
Published: July 2004

Software reuse has great potential to improve software development productivity. However, it has had only limited success in practice. This is because that there are non technical factors as well technical ones affecting software reusability. This paper discusses some problems related to software reuse, analyzes some technical supports for software reuse, and introduces a reusability-based software development system which has been prototyped and is under further improvement. The prominent features of the system include: allowing programmers dynamically to put tested working program components (including data objects created at run-times) into the reusable software library, helping programmers produce software specifications, automatically searching for the required components according to users' queries, assisting users to make a query, and allowing users to select the retrieved components and browse their specifications.
Data structures
Authors: Jarc Duane J.
Published: July 2004

Whether teaching data structures at the elementary or advanced level, it is helpful for students to see the various data structures as parts of a unified whole. The unified view discussed in this paper categorizes data structures into four levels of increasing abstraction. It emphasizes the relative nature of abstraction and representation---what is an abstraction at one level can also be viewed as the representation for another abstraction at a higher level.
The Dutch national flag problem revisited as an introductory abstract data type
Authors: Yerion Kathie A.
Published: July 2004

In Computer Science 2 or Data Structures courses, a major topic is the concept of an abstract data type (ADT). Students often have difficulty grasping this concept in the beginning because of the abstractness of "a data object with operations performed on the object." [2] An abstract data type based on a robot sorting pebbles gives students much needed concreteness for their initial exposure.
A modified form of software science measures
Authors: Aggarwal K. K. , Singh Yogesh
Published: July 2004

In attempting to describe the quality of computer software, one of the most frequently mentioned measurable attributes is the complexity of the flow of control. During the past several years, there have been many attempts to quantify this aspect of computer program, approaching the problem from such diverse points of view as graph theory and software science. Existing software science provides a general measure of program complexity, but it fails to adequately quantify program control flow complexity except for the linearization issue. In this paper, weights are assigned to the operators and operands which are part of the control structures. Although similar type of approach was used by Ramamurthy & Melton for few control structures, there was a need for a generalized approach and this paper is an attempt in this direction.
The
F
3
reuse environment for requirements engineering
Authors: Castano Silvana , De Antonellis Valeria
Published: July 2004

The F
3
reuse environment for supporting the Requirements Engineering process is illustrated and discussed in the paper. In particular, an overview of our approach for building reusable components from existing requirements and for exploiting them in the development of new applications is presented. The approach is based on classification techniques to facilitate extraction of reusable components, and on transformation techniques to support composition of reusable components

.
Do students test their software?
Authors: Freeman Geoffrey
Published: July 2004

Testing of computer systems, including software is an important basic skill of any Computer Science graduate. In this paper we look at how well a group of final year Computer Science undergraduates tested a single routine within a large programming project. We found that most students adequately performed the testing for which they were asked. However a significant number did not fully test the "obscure" cases.
A graduate diploma in computing
Authors: Shinners-Kennedy Dermot
Published: July 2004

In 1979 the Irish Government identified areas of manpower shortages. One of the areas identified was computing. The University of Limerick (UL) responded by providing a one year full-time programme aimed at honours graduates from all disciplines. The programme has been running for more than a decade and has achieved a high degree of success. This paper describes the programme content and structure; provides some statistics about the output and discusses other issues regarding the provision of such programmes.
Information systems curriculum—a status report
Authors: Gorgone J. T. , Couger J. D. , Davis G. , Feinstein D. , Kasper G. , Little J. , Longenecker H. E.
Published: July 2004

This paper provides a status report of the joint curriculum task force effort to develop a new model curriculum for undergraduate programs in Information Systems. The curriculum work is the first collaborative effort between ACM, AIS and DPMA. After a brief description of the background and current task force activities are presented, the recommended courses are briefly listed and described.
An alternative computer architecture course
Authors: Enright Aaron Garth , Wilkens Linda M. , Canning James T.
Published: July 2004

Most computer architecture courses are geared toward the classical von Neumann style of computer architectures, mentioning only in passing other models such as data flow computation. This is unfortunate, due to the high degree of parallelism possible using data flow. We present an alternative course, designed as an elective in computer architecture for upper level undergraduate or graduate students, that presents a side-by-side comparison of von Neumann and data flow architectures.Our teaching environment is based on Simple Arithmetic SISAL (SAS), a subset of the applicative programming language SISAL, which we designed for both teaching about and research into data flow architectures. SAS runs in a highly integrated environment, allowing students to implement their program on a von Neumann architecture, then observe its execution through a data flow simulator. The environment runs on a standard IBM-style personal computer, providing a cost-effective platform for presenting the course.
A motivating example problem for teaching adaptive systems design
Authors: Prechelt Lutz
Published: July 2004

There are some general lessons to be learned about the design of adaptive systems and the best method to learn them is an appropriate exercise. This paper lists these lessons, discusses why it is difficult to use examples from real applications for the exercise, and suggests a game to be used as an alternative example problem.
Inexpensive teaching techniques with rich rewards
Authors: Becker Byron Weber
Published: July 2004

A brief report on several teaching techniques that have rewards that far outweigh their costs. Experiences with four techniques are discussed: a "Pause" during lectures, student submission of exam questions, group projects, and a technique for learning students' names. These experiences are largely in the context of a Data Structures class, but are applicable to most lecture-oriented classes.
Experience using the ASA algorithm teaching system
Authors: Guimarães Mário André Mayerhofer , de Lucena Carlos José Pereira , Cavalcanti Maurício Roma
Published: July 2004

This paper describes the experience gained while using a computer based algorithm system called ASA, and explains why the evaluation motivated the need for high level structures to represent student and algorithmic knowledge. The system has been used in classrooms at SENAC, a Brazilian company associated with the Brazilian National Commerce Confederation, which promotes technical education. SENAC has a branch in every state of Brazil (26) and every year trains approximately one million students.
A repository that supports teaching and cooperation in the introductory AI course
Authors: Ingargiola Giorgio , Hoskin Nathan , Aiken Robert , Dubey Rajeev , Wilson Judith , Papalaskari Mary-Angela , Christensen Margaret , Webster Roger
Published: July 2004

This paper describes the development of FLAIR (Flexible Learning with an Artificial Intelligence Repository), a repository of educational material and of a highly visual computing environment for use in laboratories associated with the introductory undergraduate Artificial Intelligence (AI) course. This repository supports sharing of pedagogic material and of development tools, and cooperation in their use, while allowing diversity in content and in use at different institutions. Thus the development of the repository has stressed the production of system tools, extensible object-oriented libraries, and strong programming frameworks. Some modules currently available are on Search and Automated Reasoning. Examples of the presentation techniques used are conceptual maps, hypertext, and graphic animations of algorithms. Initial experience in the use of the repository in teaching the introductory AI course is taking place in the 1993/94 academic year.
The philosophy of artificial intelligence
Authors: Luker Paul A. , Rothermel Dennis
Published: July 2004

Over four years ago, we developed and implemented an upper division general studies course. “The Philosophy of Artificial Intelligence.” The course has since been team taught every semester by a computer scientist and a philosopher. Here, we draw on our four years' experience with the course to discuss its impact on computer science majors, for whom we feel that it fulfills two main purposes. First, having technical material presented within the coherent framework provided by this course offers students an accessible and consistent context. Secondly, an examination of the philosophical aspects of this material enables the students to look at their own discipline from without for the first time. We contend that a course of this nature neatly rounds off the education of computer scientists.
Instructional uses of demonstration disks
Authors: Myers William
Published: July 2004

Demonstration programs distributed by software publishers are an inexpensive source of software examples for student use. These programs can be used in a variety of computer classes and for a variety of assignments. They provide examples of different software types and of different approaches to interfaces and integration.
A new perspective on teaching computer literacy
Authors: Goldweber Michael , Barr John , Leska Chuck
Published: July 2004

The first step in designing a college level computer literacy course is to define what is meant by computer literacy. Unfortunately no consensus exists as to what the label “computer literate” should imply. The difficulty in both defining computer literacy and designing a satisfactory computer literacy course is evident by both the frequency of change and experimentation occurring at many institutions and by the forests of textbooks that exist for such a course. In this paper we present a definition of computer literacy that is independent of any specific application or application genre and introduce the notion of application literacy as distinct from that of computer literacy. Finally we describe a course implementation strategy commensurate with our philosophy.
Computer science needs an insight-based curriculum
Authors: Scragg Greg , Baldwin Doug , Koomen Hans
Published: July 2004

Computer science is a fundamentally creative endeavour. The creativity necessary for science is not produced through a knowledge of many facts, but through deep insight into the relationships between facts and the methods of inquiry through which they are discovered. The goal of computer science education should be the development of insight into the methods and nature of the discipline, not simply exposure to its current factual content. Unfortunately, few aspects of insight are explicitly addressed in any standard curricula. We call for, and present an outline for, a curricula based on insight rather than topics.
Reprogrammable hardware for educational purposes
Authors: Gschwind Michael
Published: July 2004

This paper presents a novel idea in teaching computer architecture by using programmable hardware. Current teaching models for computer architecture today are either mostly theory-only or implementation oriented. Theory-based architecture courses lack the feedback to show students the effects of their decisions. Implementation-oriented instruction emphasizes the implementation aspects, that is, very low-level implementation strategies, over CPU architecture and forces the usage of very limited CPU designs to reduce complexity. High cost and long manufacturing times are other problems associated with this approach.

We propose to use field programmable gate arrays (FPGAs) to allow fast implementation of chip designs. This allows for a fast debug cycle, as designs can be altered and downloaded in a matter of hours. As FPGAs are pretested, only logic functionality has to be validated, reducing the time to get a workable implementation of a chip considerably.
Intractability
Authors: Khuri Sami
Published: July 2004

This paper introduces a geometric representation that can be applied to illustrate the complexity of some combinatorial optimization problems. In this work, it is applied to the 0/1 knapsack problem and to a special case of a scheduling problem. This representation gives insight into the difference between tractable and intractable problems. It can therefore be used as a stepping stone to compare polynomial (P) and nondeterministic polynomial (NP) problems, before venturing into the world of NP-completeness.
Collaborative learning in an introductory computer science course
Authors: Sabin Roberta Evans , Sabin Edward P.
Published: July 2004

An experiment in collaborative learning was conducted in two introductory programming courses at Loyola College in Maryland. Data collected included background information on students; course evaluations; and before and after measures on programming knowledge and attitudes. The collaborative learning class showed more improvement pre-test to post-test than did the control class and rated the course somewhat higher. Attitudes of both groups towards the field of computing and towards the value of group discussion in class were more resistant to change.
The development of a multi-processor personal computer in a senior computer design laboratory
Authors: Katsinis Constantine
Published: July 2004

This paper describes the development of a senior computer design laboratory, the purpose of which is to provide an environment where the computer design experience is as realistic and complete as possible for each student. In this laboratory, which is required for the whole senior year, students undertake the design of a CPU-based system that may be stand-alone or a part of another system. The design effort is as complete as possible, starting with a development proposal, including the hardware design and construction, and development of all necessary software in the C language, and concluding with extensive documentation. Thus, the students are encouraged to put to use a considerable amount of knowledge acquired in previous courses including computer architecture and interfacing, algorithm, languages and operating systems. They become members in groups that design components, with complexity approaching levels found in commercial products and are well prepared to become computer engineers.
AAA and CS 1
Authors: Astrachan Owen , Reed David
Published: July 2004

We have developed an application-based approach to introductory courses in computer science. This approach follows an
apprenticeship
model of learning, where students begin by reading, studying, and extending programs written by experienced and expert programmers. Applications play a central role since programming constructs are motivated and introduced in the context of applications, not the other way around as is the tradition in most texts and courses. Under our applied approach, (1) students are able to learn from interesting real-world examples, (2) the synthesis of different programming constructs is supported using incremental examples, and (3) good design is stressed vis code and concept reuse. In this paper, we provide several examples of our method as well as pointers to all the material we have developed which is freely available electronically. The philosophy underlying this method transcends a particular programming language, but we present our examples using C++ since that is the language used in the CS 1 and CS 2 courses at Duke. This method has been used with equal success using ISETL at Dickinson.
A top-down approach to teaching programming
Authors: Reek Margaret M.
Published: July 2004

Programming is traditionally taught using a bottom-up approach, where details of syntax and implementation of data structures are the predominant concepts. The top-down approach proposed focuses instead on understanding the abstractions represented by the classical data structures without regard to their physical implementation. Only after the students are comfortable with the behavior and applications of the major data structures do they learn about their implementations or the basic data types like arrays and pointers that are used. This paper discusses the benefits of such an approach and how it is being used in a Computer Science curriculum.
Training computer science teaching assistants
Authors: Kay David G.
Published: July 2004

We describe a one-quarter seminar required of first-time teaching assistants in computer science. The seminar acclimates TAs to teaching undergraduates in the university, to departmental policies and to special problems and issues in teaching computer science. In addition to coverage of general issues surrounding teaching, the seminar includes many participatory exercises that relate specifically to the teaching of computer science. Participants in the seminar perform much better on student evaluations than non-participants.
Loop invariants and mathematical games
Authors: Ginat David
Published: July 2004

The concept of combining loop invariants with algorithm analysis and design is a significant programming tool. However, teaching this concept is not easy. One way of motivating and supporting the introduction of such a concept, is by illustrating it with attractive examples. In this paper we describe how to illustrate it with mathematical games. In our description, we emphasize the links between heuristic search strategies, pattern exploration, induction, and invariant construction.
Computer science projects with music
Authors: Rubinstein Roy S.
Published: July 2004

One important way to teach Computer Science is by getting students involved in projects that interest them. In order to demonstrate the value of music related computer projects, this paper describes some of the projects that I have advised and discusses my experience with them. These experiences show that students are very enthusiastic about music projects, enjoy working hard at them and learn a lot in the process.

This paper also serves as a brief introduction to MIDI, the standard interface for electronic music.
Rigorous proofs of program correctness without formal logic
Authors: Wadkins J. R. Jefferson
Published: July 2004

Three fundamental principles of static reasoning used to write imperative program code with built-in proof of its correctness are presented and explained in operational terms. It is argued that, although the traditional use of formal logic in the Hoare-Dijkstra-Gries methodology is probably the most efficient way to write code with built-in proofs of correctness, the ideas underlying that methodology are much simpler than commonly perceived through the veil of formal logic and axiomatic semantics. Examples are given illustrating principles and techniques for deriving code from specifications, using the informal reasoning of the mathematician without either the terminology or notation of formal logic.
On using C++ and object-orientation in CS1
Authors: Wick Michael R.
Published: July 2004

Most current approaches to modernizing CS1 revolve around the use of C++ and/or object-orientation. Although the two are not exclusively tied to one another, it is important to pause and consider the potential pitfalls of current approaches. Having identified those pitfalls, this paper presents an approach to CS1 that avoids those pitfalls while focusing students' attention on the real message: software reusability.
Parser visualizations for developing grammars with yacc
Authors: Lovato Mona E. , Kleyn Michael F.
Published: July 2004

This paper describes
Gyacc (graphical yacc)
, a tool we have developed to support a graphical approach to developing languages with parser generators such as yacc. Gyacc is an interactive environment which supports the construction of context-free grammars, and provides the user with the ability to study yacc-generated parsers. We are strongly convinced that to fully teach and understand the details of a generated parser, the user or student must see it in operation. Gyacc accomplishes this by providing a set of animations which the user can select to observe different aspects of the parser as it executes.
Classroom presentation of memory usage with constants, variables, and subprograms in Pascal
Authors: O'Neill Edward J.
Published: July 2004

An essential part of the CS 1 course based on Pascal is the idea of random access memory usage when structured programs are executed. A survey of several texts reveals that the view of both variables and constants as memory locations for data is in many cases not systematically carried over and developed further when procedures and functions are presented. This paper presents a systematic method for understanding memory usage when dealing with subprograms in Pascal and presents a survey of current approaches.
Umbriel—imperative programming for unsophisticated students
Authors: Terry P. D.
Published: July 2004

This article discusses an experiment in designing and using Umbriel, a minimal imperative programming language in the Pascal tradition, for teaching the rudiments of programming in situations where the overwhelming complexities of many modern language implementations have become intolerable.
An experience teaching formal methods in discrete mathematics
Authors: Warford J. Stanley
Published: July 2004

In spite of recent calls to incorporate formal methods into the computer science curriculum, the effort is still controversial and proceeding slowly. This paper presents our experience in restructuring the undergraduate Discrete Mathematics course to include formal methods. It concludes with some philosophical ruminations about the place of formal methods in the computer science curriculum in general.
An introduction to research and the CS/IS professional literature for undergraduates
Authors: Cunningham Sally Jo
Published: July 2004

One of the more difficult aspects of computing to incorporate into the undergraduate curriculum is an authentic research experience. This paper describes a successful third year project in which computing students designed, conducted, and wrote up bibliometric experiments. This project gives students a flavor of the scientific method, and has the added benefit of encouraging familiarity with the scientific publishing process and with the computing and information systems professional literature.
An analysis of algorithms laboratory utilizing the maximum segment sum problem
Authors: McCloskey Robert , Beidler John
Published: July 2004

This paper describes a laboratory/homework exercise, appropriate for the traditional CS 2 or Data Structures & Algorithms course (CS 7) [1], that gives students practice in analyzing algorithms to determine their asymptotic running times as well as in recognizing the relationship between an algorithm's asymptotic running time and the execution time of a program implementing it. The exercise utilizes the maximum segment sum problem, which, we argue, is a good alternative to sorting, the problem that is probably most often used in exercises of this kind.
Automatic submission and administration of programming assignments
Authors: Dawson-Howe Kenneth M.
Published: July 2004

This paper details a system to assist with the evaluation and administration of student assignments. In order to help with the evaluation of program execution, the system automatically compiles and executes the program while logging a copy of the session. This log, together with the code and documentation is then bundled into an e-mail which is sent to the course controller.The course controller automatically processes the e-mail, verifying it's authenticity, and sends an acknowledgement back to the student. The controller also automatically logs the submission in a database which is used to monitor student performance throughout the year. Additional facilities are provided to allow grades for the assignments to be entered into the database, to allow students to be excused from assignments if appropriate and to allow summary reports to be generated.
Design reuse
Authors: Kogut Paul
Published: July 2004

The evolution of software engineering to a mature engineering discipline can be accelerated by adopting practices from other mature engineering disciplines. Mature engineering disciplines such as a chemical engineering have extensive systematic design reuse practices. In this paper, design reuse in chemical engineering is compared to current and emerging design reuse in software engineering. This comparison is based on the analogy that a chemical process that is implemented as a chemical plant is comparable to a software architecture that is implemented as a software system. The goal is to gain some insights on how engineering models are used to support systematic design reuse. These insights will help form the basis of model based software engineering.
A visual requirements validation environment for the reverse engineering of formal specifications from rapid prototypes
Authors: Ozcan M. B. , Morrey I.
Published: July 2004

This paper describes a research project whose aim is the use of requirements visualisation techniques in the construction of an environment for the reverse engineering of validated formal specifications from rapid prototypes. The work will build on established research by the proposers in the animation of model-based and algebraic formal specifications.The report examines the current problems with requirements engineering and looks at solutions based on software prototyping and executable formal specifications. It is argued that prototypes built in this way can be too "formal", in the sense that the customer viewing the prototype cannot easily comprehend the results of execution. For these types of prototypes to be useful, the output must be transformed into a representation which is more amenable for comprehension, namely graphical visualisations and animation instead of cryptic mathematical expressions. In this context, the term "animation" normally refers to an executable version of a formal specification which can be used to demonstrate to the user that the specification is doing what it should. In other words, the animation is a program whose behaviour can be explored with a view to confirming the user's expectations. Our aim is to investigate techniques and a methodology for building this program prior to the specification, based on some initial informal requirements, and reverse engineering a formal specification from it. The product of the research programme will be a software environment to support this requirements visualisation, animation and reverse engineering approach.
The complexity gap
Authors: Raccoon L. B. S.
Published: July 2004

The Complexity Gap defines a new way to think about software development. We have all heard that developers need to be more productive and to work harder. But what does this mean exactly? The Complexity Gap defines a structure in which to explore concepts of process and productivity and to show how these concepts relate to conventional software development issues of tools and training.Software development is complex. This paper expands on the principles of the Chaos model that suggest that the top-level user requirements and bottom-level hacking are connected through many intermediate levels, and that every level of software development affects quality and productivity to the same degree. In The Chaos Model and the Chaos Life Cycle, I make these points.To clarify the possibilities and limitations of software development, I compare software development to assembly-line work. In the software engineering community, we compare software development to assembly lines for a variety of reasons. Some managers want to acquire the same sense of control over software development as factory managers have over assembly lines. Other managers want to apply assembly-line techniques, such as Statistical Quality Control, to software development. I use both the definition of the Complexity Gap and the assembly-line analogy to suggest ways to improve the software development process.