bluuebunny/crossref_metadata_2025 huggingface dataset:
Recruiting and retaining women in undergraduate computing majors
Authors: Cohoon J. McGrath
Published: July 2004

This paper recommends methods for increasing female participation in undergraduate computer science. The recommendations are based on recent and on-going research into the gender gap in computer science and related disciplines They are intended to work in tandem with the Computing Research Association's recommendations for graduate programs (see [18] in this issue) to promote a general increase in women's participation in computing professions.Most of the suggestions offered here could improve the educational environment for both male and female students. However, general improvements are likely to be of particular benefit to women because women in our society do not generally receive the same level of support that men receive for entering and persisting in this field. Parents, friends, and classmates seldom encourage women to choose and continue in a computing discipline. Those few women who declare a computing major tend to experience continued lack of support throughout their education. They have few female peers to call on for help. Furthermore, students in their own and other majors may consider them odd. Even faculty can discourage women with unthinking remarks or with expectations based on the assumption that men's behavior and experience are the basis for success in computing majors. This lack of support can block or weaken women's commitment to computing. Moreover, when conditions in a department are generally unfavorable, those with a weakened commitment to the discipline often leave at higher rates than those who have sufficient support to overcome the conditions.
A first course in computational science
Authors: Noyes James L.
Published: July 2004

There is a change underway in the CS curriculum that reflects a renewed emphasis upon solving applications. Computational science applies solution methods to various scientific models. However, following a computational science approach means more than just using formulas out of a math book. It means having a scientific mindset, understanding and using a scientific approach, thoroughly testing both the theoretical models and the specific implementation of these models, knowing when to use analytic methods instead of numerical ones, using graphics to improve understanding, and knowing how to explain the results of these models to others. This paper addresses what has been learned in designing and teaching a first course in computational science at the undergraduate level.
What comes after CS 1 + 2
Authors: Vasiga Troy
Published: July 2004

There has been much discussion of CS1 and CS2 in computer science education circles. This paper presents a proposal for a course subsequent to CS2 that acts as a "springboard" for students diving into more specialized Computer Science courses at the upper year levels.
DrJava
Authors: Allen Eric , Cartwright Robert , Stoler Brian
Published: July 2004

DrJava is a pedagogic programming environment for Java that enables students to focus on designing programs, rather than learning how to use the environment. The environment provides a simple interface based on a "read-eval-print loop" that enables a programmer to develop, test, and debug Java programs in an interactive, incremental fashion. This paper gives an overview of DrJava including its pedagogic rationale, functionality, and implementation.
To teach the unteachable class
Authors: Treu Kevin
Published: July 2004

In the current Web-dominated computing environment, it is increasingly important that students learn the principles of Web-based application design. But this topic is so broad and includes so many different technologies that it is virtually impossible to design an effective class around the traditional lecture-based model. This paper describes a successful approach to teaching the subject that uses a seminar format and features faithful simulation of real world development processes, meaningful case studies and flexibility in terms of coverage as its central themes.
Teaching empirical analysis of algorithms
Authors: Sanders Ian
Published: July 2004

In this paper I argue that empirical analysis of algorithms is important but also difficult and requires a place in our curricula. I discuss how I planned to include coverage of this topic through lectures, discussions and practical work and the approach that I took in the Honours Analysis of Algorithms topic at the University of the Witwatersrand in 2001. I then discuss the results of a survey conducted on the Honours class and suggest some improvements for 2002.
Making compiler design relevant for students who will (most likely) never design a compiler
Authors: Debray Saumya
Published: July 2004

Compiler Design courses are a common component of most modern Computer Science undergraduate curricula. At the same time, however, compiler design has become a highly specialized topic, and it is not clear that a significant number of Computer Science students will find themselves designing compilers professionally. This paper argues that the principles, techniques, and tools discussed in compiler design courses are nevertheless applicable to a wide variety of situations that would generally not be considered to be compiler design. Generalizing the content of compiler design courses to emphasize this broad applicability can make them more relevant to students.
Efficient instrumentation for code coverage testing
Authors: Tikir Mustafa M. , Hollingsworth Jeffrey K.
Published: July 2004

Evaluation of Code Coverage is the problem of identifying the parts of a program that did not execute in one or more runs of a program. The traditional approach for code coverage tools is to use static code instrumentation. In this paper we present a new approach to dynamically insert and remove instrumentation code to reduce the runtime overhead of code coverage. We also explore the use of dominator tree information to reduce the number of instrumentation points needed. Our experiments show that our approach reduces runtime overhead by 38-90% compared with
purecov,
a commercial code coverage tool. Our tool is fully automated and available for download from the Internet.
Current trends in computer science graduate admissions
Authors: Nielsen S. Travis , Campbell Douglas M.
Published: July 2004

This article addresses some questions students have when completing applications to maximize their chances for admission to graduate school. We conducted a survey of the admissions process among the top computer science programs. Our study shows how admission committees weigh different sections of an application and overall trends of admission. The results are of interest to both applicants and computer science graduate faculty.
Graphics for free
Authors: Carlisle Martin C.
Published: July 2004

Students find computer graphics one of the most interesting topics in computer science. Unfortunately, writing programs with graphics requires understanding concepts that are usually beyond the scope of an introductory computer science course. For example, in Windows 95, a program that uses graphics must have an event loop that dispatches messages to the appropriate handler. Event loops, messages, and handlers are well beyond the grasp of someone just learning about variables! Consequently, programming assignments for introductory courses tend to use no graphics, or simple ANSI graphics (see, e.g. Feldman and Koffman [1]). These programs compare unfavorably to the graphics of games most students are accustomed to using, and motivation to program in an introductory course may be lost.Ideally, we would like to be able to have students write programs that have more appealing interfaces, yet do not require a large amount of additional conceptual complexity. In fact, the best case would be to have the student write a program as if it were a simple text-based program, and have the compiler automatically add a graphical interface. Languages that provide overloading, such as Ada 95, allow us to accomplish precisely that.This paper describes a library, Graphics_110 (named in honor of our introductory course, CS 110), which, using overloading, replaces the standard I/O libraries in Ada 95 (Ada.Text_IO, Ada.Float_Text_IO, and Ada.Integer_Tex_IO). By following a simple contract and replacing calls to the standard libraries with calls to Graphics_110, the student obtains a program with a Windows-style interface without ever having to worry about the implementation details. Although we use Ada 95 for this paper, the ideas extend to any programming language that provides subtypes and overloading.The next section describes the "contract" the programmer must follow to use the library and the third section describes the implementation of Graphics_110. In each section, we describe how we used Graphics_110 with a battleship game implemented in our introductory course. The final section presents conclusions and ideas for future work.
What employers want from students
Authors: Pfeiffer Phil
Published: July 2004

Recently, two of our stronger graduate students had trouble finding work as software developers. Both students had done masters-level work in operating systems, networking, software engineering, and various "hot" technologies, including Java, C++, and client-server computing. Both students had also worked as programmers before starting graduate school. Given these credentials, I was surprised when these students, in effect, had to move closer to prospective employers before they gave serious consideration to their resumes.My students' experiences caused me to conduct an informal survey about the perceived value of a computer science degree. In October 1998, I asked employees from 23 exhibitors at OOPSLA '98---software, consulting, and training firms---to assess what their company expected from any applicant with a BS or MS in computer science. What follows are my findings, together with concluding observations regarding what these findings might signify.
Impact of the research community on the field of software configuration management
Authors: Estublier Jacky , Leblang David , Clemm Geoff , Conradi Reidar , Tichy Walter , van der Hoek André , Wiborg-Weber Darcy
Published: July 2004

Software Configuration Management (SCM) is an important discipline in professional software development and maintenance. The importance of SCM has increased as programs have become larger and more complex and mission/life-critical. This paper discusses the evolution of SCM technology from the early days of software development to present and the impact university and industrial research has had along the way. It also includes a survey of the industrial state-of-the-practice and research directions.The paper published here is not intended to be a definitive assessment. Rather, our intention is to solicit comments and corrections from the community to help refine the work. If you would like to provide further information, please contact the first author. A longer version of this report can be found at
http://wwwadele.imag.fr/SCMImpact.pdf.
Tracing the execution of C++ programs
Authors: Warms Tom M.
Published: July 2004

One of the difficulties faced by instructors of introductory courses in computer science is explaining the intricacies of recursion. This article describes a method devised by the author that enables students to follow and understand the step-by-step execution of many basic programs, including recursive programs.
Getting the most from an algorithms design course
Authors: Suraweera Francis
Published: July 2004

The most significant goal of an algorithm design course is to prepare students to solve general problems that they will encounter later in their lives. Departments usually offer such courses at the upper undergraduate and graduate levels. Today, compared to three decades ago, we have numerous texts on this and similar courses. The authors of these textbooks suggest different ways to organize their material to suit a variety of audiences. This paper deals with the following. How can we ensure that our students will acquire the necessary skills and abilities to solve general problems? We do this by tying the assessments to the objectives and aims of the course. We list some of the most desirable outcomes for this course, suggest possible ways to assess them based on our experience, and do assessments in a way to foster the confidence they need to handle general problems.
PCTE Esprit and Pact
Authors: Thomas I.
Published: July 2004

The PCTE initiative has long ago passed beyond the confines of the PCTE Esprit project. It now encompasses a large number of projects, organisations and programmes. This paper is an updated version of one that was given at the Esprit Technical Week 87. It describes the PCTE initiative by discussing the work being done on implementations of the PCTE interfaces, their formalisation and evolution. It goes on to describe current efforts to build integrated environments on the interfaces and describes the Pact project in particular. Finally, there is an attempt to place PCTE in a world context.
Egocentric context-aware programming in ad hoc mobile environments
Authors: Julien Christine , Roman Gruia Catalin
Published: July 2004

Some of the most dynamic systems being built today consist of physically mobile hosts and logically mobile agents. Such systems exhibit frequent configuration changes and a great deal of resource variability. Applications executing under these circumstances need to react continuously and rapidly to changes in operating conditions and must adapt their behavior accordingly. The development of such applications demands a reexamination of the notion of context and the mechanisms used to manage the application's response to contextual changes. This paper introduces EgoSpaces, a coordination model and middleware for ad hoc mobile environments. EgoSpaces focuses on the needs of application development in ad hoc environments by proposing an agent-centered notion of context, called a view, whose scope extends beyond the local host to data and resources associated with hosts and agents within a subnet surrounding the agent of interest. An agent may operate over multiple views whose definitions may change over time. An agent uses declarative specifications to constrain the contents of each view by employing a rich set of constraints that take into consideration properties of the individual data items, the agents that own them, the hosts on which the agents reside, and the physical and logical topology of the ad hoc network. This paper formalizes the concept of view, explores the notion of programming against views, discusses possible implementation strategies for transparent context maintenance, and describes our current prototype of the system. We include examples to illustrate the expressive power of the view abstraction and to relate it to other research on coordination models and middleware.
A micro-economic approach to conflict resolution in mobile computing
Authors: Capra Licia , Emmerich Wolfgang , Mascolo Cecilia
Published: July 2004

Mobile devices, such as mobile phones and personal digital assistants, have gained wide-spread popularity. These devices will increasingly be networked, thus enabling the construction of distributed mobile applications. These have to adapt to changes in context, such as variations in network bandwidth, exhaustion of battery power or reachability of services on other devices. We show how the construction of adaptive and context-aware mobile applications can be supported using a reflective middleware. The middleware provides software engineers with primitives to describe how context changes are handled using policies. These policies may conflict. In this paper, we classify the different types of conflicts that may arise in mobile computing. We argue that conflicts cannot be resolved statically at the time applications are designed, but, rather, need to be resolved at execution time. We demonstrate a method by which these policy conflicts can be treated. This method uses a micro-economic approach that relies on a particular type of sealed-bid auction.
Searching for points-to analysis
Authors: Bruns Glenn , Chandra Satish
Published: July 2004

The complexity of points-to analysis is well understood, but the approximations used to carry out points-to analysis efficiently are less well understood. In this paper we characterize points-to analysis as a reachability problem on a program's state space. Reachability analysis can be performed approximately but more efficiently for a program to which certain basic program transformations have been applied. We show the source of approximation and efficiency in several existing points-to analysis algorithms in terms of these generic program transformations.
Deriving operational software specifications from system goals
Authors: Letier Emmanuel , van Lamsweerde Axel
Published: July 2004

Goal orientation is an increasingly recognized paradigm for eliciting, modeling, specifying and analyzing software requirements. Goals are statements of intent organized in AND/OR refinement structures; they range from high-level, strategic concerns to low-level, technical requirements on the software-to-be and assumptions on its environment. The operationalization of system goals into specifications of software services is a core aspect of the requirements elaboration process for which little systematic and constructive support is available. In particular, most formal methods assume such operational specifications to be given and focus on their a posteriori analysis.The paper considers a formal, constructive approach in which operational software specifications are built incrementally from higher-level goal formulations in a way that guarantees their correctness by construction. The operationalization process is based on formal derivation rules that map goal specifications to specifications of software operations; more specifically, these rules map real-time temporal logic specifications to sets of pre-, post- and trigger conditions. The rules define operationalization patterns that may be used for guiding and documenting the operationalization process while hiding all formal reasoning details; the patterns are formally proved correct once and for all. The catalog of operationalization patterns is structured according to a rich taxonomy of goal specification patterns.Our constructive approach to requirements elaboration requires a multiparadigm specification language that supports incremental reasoning about partial models. The paper also provides a formal semantics for goal operationalization and discusses several semantic features of our language that allow for such incremental reasoning.
Analysis issues for cyclone
Authors: Morrisett Greg
Published: July 2004

Cyclone [1, 2] is an experimental, type-safe programming language based upon the syntax, semantics, and spirit of C. The primary goal of the language is to provide a type-safe environment that is close enough to C in both appearance and functionality, that systems programmers will find it attractive and useful.The most challenging aspect of the design is capturing the spirit of C without compromising type-safety. In particular, systems programmers expect to have good control over data representations, memory management, and performance. Yet, these features are usually absent from high-level, type-safe languages (e.g., Java). Another challenge is validating a sufficiently wide set of idioms that are in fact type-safe, but which conventional type systems reject.To address these issues, we have used a novel combination of typing features in conjunction with some interesting inference and dataflow techniques. The most novel typing feature is the support for region-based memory management which was summarized in an earlier paper [1]. However, this paper did not discuss the inference techniques we use to validate the regions and effects.In this talk, I will briefly summarize the Cyclone type system and then focus on the analysis issues that arise in its implementation, including (a) kind and type inference, (b) region and effect inference, and (c) dataflow analysis for validating initialization, array subscripts, and linear pointers.
COOL (comprehensive object-oriented learning)
Authors: Nygaard Kristen
Published: July 2004

The COOL Project (Comprehensive Object-Oriented Learning) is a 3-year research project proposal launched by by a consortium of four Norwegian research institutions, supported by research institutions in Aarhus in Denmark, and co-operating with test sites around the world.COOL will contribute to a unifying process- and object-oriented platform for informatics, and produce a "Learning Landscape" of pedagogical and organizational components to be used in a modern and system-oriented education in informatics and related fields. It will provide an alternative to the current pedagogical approach used, commonly regarded as unsuccessful. COOL will co-operate with research institutions in Denmark and with a number of test sites (universities and colleges) around the world, representing a number of language/cultural worlds (Spanish/South American, English/North American, Scandinavian, and perhaps others). COOL will produce an introductory course, supported by a textbook and DVD records containing integrated multimedia material. The COOL Learning Landscape shall allow for alternative courses, adapted to local cultures and conditions.
Lecture recording and its use in a traditional university course
Authors: Zupancic Bernd , Horz Holger
Published: July 2004

Recording a lecture in front of a live audience and providing the recorded audio and video stream together with slides over the web is becoming more and more popular. The Authoring on the Fly system (AOF), which has been used in many different courses over the past years, allows us to automatically produce a multimedia document with an HTML overview. In this paper we describe an empirical study of the students' behavior using the AOF recordings for time independent learning in a traditional computer science course. We focus on the questions of how and why students use this tool and if any changes occurred in their learning behavior. For example, did the students work solely at home more often if they used AOF recordings? We explore students' behavior by log file analysis and the results of a detailed questionnaire. As the results show, it is possible to identify different types of user. We conclude that in this scenario lecture recording is also a very good supplement to, but should not replace, the live presentation.
A tutoring system for parameter passing in programming languages
Authors: Shah Harsh , Kumar Amruth N.
Published: July 2004

We have developed a tutoring system for the parameter passing mechanisms discussed in a typical
Comparative Programming Languages
course, viz., value, result, value-result, reference and name. The tutor helps students better understand these parameter passing mechanisms by administering problems for them to solve and providing instant feedback on their solution. In this paper, we will describe the design and features of the tutor. We will also discuss a test that we conducted to evaluate the effectiveness of using the tutor, and present its results. The test confirmed our hypothesis that using the tutor would result in a systematic improvement in the learning of our students. This tutor may be used in the
Comparative Programming Languages
course as well as
Computer Science I
.
What they really do?
Authors: Dagdilelis Vassilios , Satratzemi Maya , Evangelidis Georgios
Published: July 2004

In the last two decades, a large amount of research has been conducted in an effort to form a model of student behavior when they try to solve algorithmic or programming problems. The construction of the model is based on the analysis of many types of data, such as for example: (a) the characteristics of the programming languages the students work with, (b) the strategies of the solution that the students follow, and (c) the characteristics of the proposed problem. However, we must observe that modeling is often not based on long-term observations of actual teaching and the proposed problems are usually quite simple.In this paper we attempt to examine a variety of aspects of students' behavior when they learn to program. More specifically, we study: the strategies students use in order to develop and validate a program; the possible role of students' errors in the development of their programs; and the methods students use to deal with these errors. The study was carried out on 90 second-semester CS students who worked in pairs during the 2-hour lab session. They were given a brief description of the Binary Search algorithm and were asked to implement it using AnimPascal. In this study we present the results we obtained from the analysis of the successive versions of students' programs. Based on these results we propose teaching methods to help students overcome the difficulties they face when they learn programming.
Principles of survey research part 4
Authors: Kitchenham Barbara , Pfleeger Shari Lawrence
Published: July 2004

This article discusses how to avoid biased questions in survey instruments, how to motivate people to complete instruments and how to evaluate instruments. In the context of survey evaluation, we discuss how to assess survey reliability i.e. how reproducible a survey's data is and survey validity i.e. how well a survey instrument measures what it sets out to measure.
Towards software architecture at runtime
Authors: Huang Gang , Mei Hong , Wang Qian-xiang
Published: July 2004

As Internet and wireless network make the runtime environment much more dynamic and open, software becomes more and more complex and difficult to maintain. Software architecture at run-time (RSA) can help maintainers understand and reason the run-time system. Moreover, RSA helps to keep SA consistent in the whole software lifecycle. This paper presents an approach to three fundamental issues of RSA, including making RSA the first-class entity at runtime, maintaining the causal-connection between RSA and the runtime system, and mapping RSA from/into SA at the design phase.
Web application generator by image-oriented design
Authors: Shimomura Takao , Takahashi Muneo , Ikeda Kenji , Mogami Yoshio
Published: July 2004

With the development of the information society, it has become necessary to release software early that satisfies users. Therefore, it has become important to develop software quickly so that users can try it, and give the developers feedback. Developers make the specifications of a program based on users' requirements, and then design, write, test and debug the program. Through this procedure, the program is completed. However, if we can directly use the image that the users have when we design a program, and if the program is completed when the design finishes, the procedure for software development will be made much simpler, and the time required to develop it will be reduced greatly. This paper presents an approach to brain-image oriented programming and describes the BioPro system that implements this method for Web applications. The brain-image oriented programming has the following features; (1) users can develop programs based on their image, (2) they can easily verify the completeness of the components that make up the program and the consistency of those relationships, and (3) they can easily confirm what they have developed, regardless of which stage of development they are currently at.
Architecture-based SW process model
Authors: You-Sheng Zhang , Yu-Yun He
Published: July 2004

Explicit software architecture is principal in the development of a software project. In this paper Architecture-Based Software Process model (ABSP) is presented. ABSP model divides software process based on architecture into six sub processes: requirements, design, documentation, review, implementation, and evolution. Compared with traditional software process model, ABSP model has many advantages such as explicit structure, easy understandability, better portability and large reusable granularity.
An overview of DOD-STD-1838A (proposed) the common APSE interface set: revision
Authors: Munck Robert , Oberndorf Patricia , Ploedereder Erhard , Thall Richard
Published: July 2004

A five-year effort under the Ada Joint Program Office has developed a proposed standard for a host system interface as seen by tools running in an Ada Programming Support Environment (APSE). Standardization of this interface as DOD-STD-1838A will have a number of desirable effects for the Department of Defense, including tool portability, tool integration, data transportability, encouragement of a market in portable tools, and better programmer productivity.

As the capability of tools to communicate with each other is a central requirement in APSEs, the Common APSE Interface Set (CAIS) has paid particular attention to facilitate such communication in a host-independent fashion. CAIS incorporates a well-integrated set of concepts tuned to the needs of writers and users of integrated tool sets.

This paper covers several of these concepts:

• the entity management system used in place of a traditional filing system,

• object typing with inheritance,

• process control including atomic transactions,

• access control and security,

• input/output methods,

• support for distributed resource control, and

• facilities for inter-system data transport.
Progressive project assignments in computer courses
Authors: Leeper Robert
Published: July 2004

This paper presents a method of design for projects in computer courses that tends to enable all students in the class to achieve their maximum potential. Each project is structured at three progressive levels of difficulty corresponding to three prospective grades A, B, and C. The B-level is an extension of the C-level and the A-level is an extension of the B-level. Each student starts at the C-level and progresses as far as possible and is scored accordingly.
What is to become of programming?
Authors: Mitchell William
Published: July 2004

CS1 and CS2 have been revised and currently ACM is exploring the revision of the CS core. General dissatisfaction has been broadly voiced with Curriculum '78 as not being sufficiently mathematical and theoretical. In the same vein the accreditation criteria have been attacked as being too technical and vocational. A strong voice has been raised for a liberal arts view of computer science. Recent texts are incorporating a higher level of abstraction into the freshman year as well as trying to cater to a demand for a survey of the discipline. Does this portend a decline in programming skill? Who will write code in the future? What will be their knowledge and aesthetics? This paper cannot answer all these questions, but it does develop a near-term approach to presenting programming more efficiently in the undergraduate CS curriculum and it suggests that the discipline needs to give some thought to its technology.
Algorithms and proofs: mathematics in the computing curriculum
Authors: Greenleaf Newcomb
Published: July 2004

Computing has supplied mathematics with a new vocabulary of algorithms and is holding out the promise that mathematics can be implemented. Algorithms and proofs can now be seen as the same type of object. This new vision of mathematics as a very high level programming language suggests that mathematics may be transformed so that it is more in harmony with the spirit of computing, and has profound implications for the way in which mathematics is taught. Such harmony would be particularly beneficial for students of computing, who often find little of relevance in their mathematics courses.
Defining educational policy on software usage in the light of copyright law
Authors: Crow Galen B.
Published: July 2004

Accompanying the rapid proliferation of personal computing has been an ambivalent attitude towards the illegal copying of commercially available software. The effects of this software “piracy” are enormous and insidious, and academia ranks as one of the worst abusers. To understand the legitimate as well as illegitimate usage of software, one must have a clear understanding of the letter and intent of the copyright law. If academia is to purge itself of software abuses, educators and administrators must set clear and visible software policies based upon the copyright law.
A first course in program verification and the semantics of programming languages
Authors: Gumb Raymond D.
Published: July 2004

We describe a first course in program verification and the semantics of programming languages developed for advanced undergraduate and beginning graduate students. The course is intended to support other courses in the curriculum that stress a disciplined approach to programming as well as to prepare students for more advanced courses in semantics and other areas such as software engineering and compiler technology. In order of emphasis, the course covers axiomatic, operational, translational, and denotational semantics. We discuss the development of the course, course prerequisites, the rationale for the selection of the topics covered, and the appropriateness of the course in the curriculum.
A parallel processing course for undergraduates
Authors: Hyde D. G.
Published: July 2004

We argue that a parallel processing course should be offered to undergraduate computer science majors. A major component of such a course should be a series of programming laboratories where the student can investigate the strengths and weaknesses of different parallel architectures. The student should design and debug parallel algorithms on the different parallel models.

We propose a cost effective solution to the teaching of the course which uses simulators and Transputer-based parallel accelerators in a personal computer or workstation environment.
A language-only course in LISP with PC scheme
Authors: Lambert K. A.
Published: July 2004

This paper describes a course in LISP that introduces students to conventional software engineering techniques, contemporary programming paradigms, and an artificial intelligence application.
Partial computation as a practical aid in the compiler construction course
Authors: Pagan Frank G.
Published: July 2004

A brief account of the concept of partial computation is given in the context of the Pascal language. The manual conversion of programs into generating extensions is explained using examples of gradually increasing complexity. This culminates in a readily applicable but too-little known technique of converting interpreters into compilers without dealing directly with machine language. Students taking courses in language processing should be taught this technique and perhaps also the general principles underlying it. A simple example of the application of the technique is presented.
Music in computer science courses using inexpensive, exciting technology to teach programming principles
Authors: Foss R.
Published: July 2004

I teach three courses in the Computer Science department at Rhodes University. I lecture computer organization to second year students, operating systems to third year students, and computer music tools to fourth years. Computer control of musical instruments naturally forms an integral part of the fourth year course. However, I have also included elements of musical device control (albeit very simpl e devices) into my other two courses. In all cases, the inclusion of musical device control has served to highlight certain important concepts and programming techniques in a way that has proved to be both fun and insightful. In this article, I will describe how I have gone about this inclusion.
A manager/controller for the software development process
Authors: Fritsch C. A. , Perry D. L.
Published: July 2004

Enhanced management and control of the product realization process is required by today's marketplace. We propose a computer aided facility for such an enhanced realization of switching system products that are largely software based. This facility, called the Manager/Controller, is based on a three layer architecture which consists of a process description layer which reads and writes to a product definition (information) layer and is managed by a control layer that has both broad and detailed knowledge of the realization activity. In this paper, we will sketch the characteristics of processes that we must control and outline the nature of the Manager/Controller.
Limits to the mechanization of the detailing step paradigm
Authors: Koomen C. J.
Published: July 2004

In this paper it is argued that complete formalization of design processes is impossible under the assumption of fully deterministic models of such design processes.

It is argued that non-determinism is needed to allow the designer to come up with solutions for problems which could not have been derived from the initial assumptions using a deterministic problem solving method. Hence, views on the design process should be based on two principles: (1) the use of a formalism to enable a systematic capture and usage of design knowledge, and (2) the assumption of an underlying `noisy` mechanism.
Automated support for the enactment of rigorously described software processes
Authors: Osterweil L.
Published: July 2004

There are many advantages to developing rigorously described software processes. Certainly, they provide the basis for improved project visibility, communication, and coordination. If they are sufficiently rigorous they also provide the basis for effective analysis and error detection which can be used to improve processes. Of the many advantages, however, none strikes me as being more important than the opportunity which rigorous process specifications present for directing the coordination of human and computer resources in support of the effective enactment of software processes.

A number of researchers, both at this Workshop and elsewhere, have recognized this opportunity and have begun to study ways of taking advantage of it. Most of this work has focussed on the development of software environments in which explicit software process representations are used to coordinate the application of software tools. As such, this work is forming an important bridge between our software process research community and the software environments research community.

Most current research seems to be focussing on 1) what language should be used to express the process description, 2) what should the architecture of a process enaction support environment be like, and 3) what object management facilities should the environment have? In each of these three areas, there are important subissues which I believe are not receiving sufficient attention. In addition, it seems to me that the issues of 1) providing adequate user interfaces to such environments and 2) evaluating process descriptions and environments to support their enaction are both not receiving sufficient attention.
Reducing the effects of infeasible paths in branch testing
Authors: Yates D. , Malevris N.
Published: July 2004

Branch testing, which is one of the most widely used methods for program testing, see White [1] for example, involves executing a selected set of program paths in an attempt to exercise all program branches. Criteria for selecting such paths have, to date, received scant attention in the literature and it is the issue of developing a suitable path selection strategy to which this paper is addressed. Specifically, a selection strategy, which aims at reducing the number of infeasible paths generated during the branch testing exercise is proposed. The strategy is founded on an assertion concerning the likely feasibility of program paths. Statistical evidence in support of the assertion is provided, a method implementing the strategy is described, and the results obtained from applying the method to a set of program units are reported and analysed.
Module test case generation
Authors: Hoffman D. , Brealey C.
Published: July 2004

While considerable attention has been given to techniques for developing complex systems as collections of reliable and reusable modules, little is known about testing these modules. In the literature, the special problems of module testing have been largely ignored and few tools or techniques are available to the practicing tester. Without effective testing methods, the development and maintenance of reliable and reusable modules is difficult indeed.

We describe an approach for systematic module regression testing. Test cases are defined formally using a language based on module traces, and a software tool is used to automatically generate test programs that apply the cases. Techniques for test case generation in C and in Prolog are presented and illustrated in detail.
Testing the correctness of tasking supervisors with TSL specifications
Authors: Rosenblum D. , Luckham D.
Published: July 2004

This paper describes the application of behavior specifications to the testing of
tasking supervisors
, an important component of an implementation of a concurrent programming language. The goal of such testing is to determine whether or not a tasking supervisor correctly implements the semantics of its associated language. We have tested a distributed tasking supervisor for the Ada programming language by monitoring the execution behavior of Ada tasking programs that have been compiled and linked with the supervisor. This behavior is checked for consistency with an event-based formalization of the Ada tasking semantics expressed in the TSL specification language. The TSL Runtime System automatically performs all monitoring and consistency checking at runtime. Our approach improves upon other approaches to testing tasking supervisors, particularly the Ada Compiler Validation Capability (ACVC), and also an approach described by Klarund. In contrast with these other approaches, in our approach (1) we test only the behavior of the tasking supervisor, not the behavior of the test programs; and (2)
any
Ada tasking program may be employed as test data, because the TSL specifications we construct describe the semantics of Ada language statements, not the semantics of application programs.
Automatic generation of test scripts from formal test specifications
Authors: Balcer M. , Hasling W. , Ostrand T.
Published: July 2004

TSL is a language for writing formal test specifications of the functions of a software system. The test specifications are compiled into executable test scripts that establish test environments, assign values to input variables, perform necessary setup and cleanup operations, run the test cases, and check the correctness of test results. TSL is a working system that has been used to test commercial software in a production environment.
Integrating testing techniques through process programming
Authors: Richardson D. , Aha S. , Osterweil L.
Published: July 2004

Integration of multiple testing techniques is required to demonstrate high quality of software. Technique integration has four basic goals: reduced development costs, incremental testing capabilities, extensive error detection, and cost-effective application. We are experimenting with the use of process programming as a mechanism for integrating testing techniques. Having set out to develop a process that provides adequate coverage and comprehensive fault detection, we proposed synergistic use of DATA FLOW testing and RELAY to achieve all four goals. We developed a testing process program much as we would develop a software product from requirements through design to implementation and evaluation. We found process programming to be effective for explicitly integrating the techniques and achieving the desired synergism. Used in this way, process programming also mitigates many of the other problems that plague testing in the software development process.
Information technology fluency in practice
Authors: Dougherty John P. , Dececchi Tom , Clear Tony , Richards Brad , Cooper Stephen , Wilusz Tadeusz
Published: July 2004

Recent work has stressed the importance of fluency with information technology (IT) in the modern world. This report presents a set of context profiles that detail courses and programs to realize increased IT fluency across a small sampling of academic institutions. The goal is to provide some representative examples for other schools interested in addressing the issues associated with IT fluency.
Unlocking the clubhouse
Authors: Fisher Allan , Margolis Jane
Published: July 2004

We recount some of the most significant and colorful findings of our four-year study of gender issues in the undergraduate computer science program at Carnegie Mellon. We also discuss the subsequent dramatic increase in the number of women in the program. We conclude with recommendations for the most generally useful and effective actions departments can take to attract and retain female students.
Transfer to/from computing science education
Authors: Almstrum Vicki L. , Ginat David , Hazzan Orit , Clement John M.
Published: July 2004

During the ITiCSE 2002 conference in Århus, Denmark, a panel presentation on the topic of import to and export from Computing Science Education and other fields focused on the case of Mathematics Education Research. The outcome was very successful, with the panelists' presentations giving rise to active audience participation.Continuing with the theme from the earlier panel, this proposal suggests a similar format with the expanded theme of transfer into Computing Science Education from Science Education Research. This panel will look at how research theories developed in the context of various areas of science education can be applied to Computing Science Education as well as ways in which computing science educational theories may be used in those areas. Because Computing Science Education is a young discipline, it is still in search of its research framework [2]. In formulating such a framework, it can be practical and productive to adapt approaches from research in other disciplines, both educational and related areas. At the same time, the younger discipline can offer innovative new approaches to the older discipline.The panelists will examine possibilities and difficulties in some import and export attempts between several areas of Science Education Research and Computing Science Education. For this context, science is considered to include mathematics.
Bubble sort
Authors: Astrachan Owen
Published: July 2004

Text books, including books for general audiences, invariably mention
bubble sort
in discussions of elementary sorting algorithms. We trace the history of bubble sort, its popularity, and its endurance in the face of pedagogical assertions that code and algorithmic examples used in early courses should be of high quality and adhere to established best practices. This paper is more an historical analysis than a philosophical treatise for the exclusion of bubble sort from books and courses. However, sentiments for exclusion are supported by Knuth [17], "In short, the bubble sort seems to have nothing to recommend it, except a catchy name and the fact that it leads to some interesting theoretical problems." Although bubble sort may not be a
best practice
sort, perhaps the weight of history is more than enough to compensate and provide for its longevity.
Integrating XML into a database systems course
Authors: Wagner Paul J. , Moore Thomas K.
Published: July 2004

eXtensible Markup Language (XML) is becoming a standard tool for data storage and transmission. Integrating XML into current database systems courses provides students with an understanding of the growing role of XML in data management and manipulation. We have successfully designed and implemented several exercises for a database systems course in the context of a real-world software project that educate students as to how XML relates to current Database Systems course topics.