bluuebunny/crossref_metadata_2025 huggingface dataset:
Metaphorical representation in collaborative software engineering
Authors: Herbsleb James D.
Published: July 2004

Finding a useful abstract representation is fundamental to solving many difficult problems in software engineering. In order to better understand how representations are actually used in key collaborative software engineering tasks, this empirical study examined all of the spoken representations of software behavior in 9 domain analysis sessions. It found that about 70% of them were metaphorical, representing system behavior as physical movement of objects, as perceptual processes, or in anthropomorphic terms ascribing beliefs and desires to the system. The pattern of use of these representations indicates 1) that they were not merely temporary placeholders, but rather their use persisted even when a specialized and more formal vocabulary had been developed, and 2) the metaphoric descriptions appear to reflect actual use of metaphor, rather than just a choice of vocabulary. The use of metaphor is explained in terms of how well they serve human cognitive abilities and collaborative needs. The predominance of metaphorical representations in synchronous collaborative sessions raises important issues about the possible misleading effects of metaphorical thinking. It also raises questions about the compatibility of the spoken representations with other representations (e.g., diagrams, specification languages) that trigger, and capture the results of, the verbal collaborative work.
Coordinating agent activities in knowledge discovery processes
Authors: Jensen David , Dong Yulin , Staudt Legner Barbara , McCall Eric K. , Osterweil Leon J. , Sutton Stanley M. , Wise Alexander
Published: July 2004

Knowledge discovery in databases (KDD) is an increasingly widespread activity. KDD processes may entail the use of a large number of data manipulation and analysis techniques, and new techniques are being developed on an ongoing basis. A challenge for the effective use of KDD is coordinating the use of these techniques, which may be highly specialized, conditional and contingent. Additionally, the understanding and validity of KDD results can depend critically on the processes by which they were derived. We propose to use process programming to address the coordination of agents in the use of KDD techniques. We illustrate this approach using the process language Little-JIL to program a representative bivariate regression process. With Little-JIL programs we can clearly capture the coordination of KDD activities, including control flow, pre- and post-requisites, exception handling, and resource usage.
Moksha
Authors: Ramloll Rameshsharma , Mariani John A.
Published: July 2004

Collaborative systems need to provide some means for users to be aware of peer activities. Common approaches involve broadcasting events generated as a result of a particular user's actions at the interface to others. Rather than flooding users with information about all activities occurring in the shared environment, filtration techniques allow each user to be exposed to relevant awareness information. Such techniques are often based on user configurable agents. Unfortunately, these so far do not support satisfactorily the improvisational nature of collaborative activities. This is because user configuration is effective mainly in cases where interactions can be anticipated and where configuration plans can be drawn. It is also difficult for a configurable agent to capture the diversity and the complex interrelationships between collaborative activities. In highly dynamic collaborative environments, the need to synchronise configurations with rapidly evolving needs imposes a heavy task load on participants. In Moksha, our prototypical multi-user desktop, this problem is addressed by extending the desktop metaphor and automating the filtration control process so that it becomes ubiquitous to the user. The cross-client linkage of the desktop interface elements, the use of multi-media and its browsing techniques are the main components underlying our strategy.
Why do electronic conversations seem less polite? the costs and benefits of hedging
Authors: Brennan Susan E. , Ohaeri Justina O.
Published: July 2004

Electronic conversations often seem less polite than spoken conversations. The usual explanation for this is that people who are not physically copresent become depersonalized and less inhibited by social norms. While this explanation is intuitively appealing, we consider another possibility, based on the costs of producing "polite" utterances when speaking versus when typing. We examined a corpus of conversations generated by 26 three-person groups who interacted either face-to-face or electronically to do a collaborative memory task. We coded hedges (which mark an utterance as provisional) and questions (which display doubt or invite input from others), as people presented their own recollections, accepted, modified, or rejected those of others, and tried to reach consensus. Both of these devices are associated with politeness. For most people, hedging is more difficult when typing than when speaking because additional words are required, while marking an utterance as a question is equally easy in both media. The two groups made somewhat different use of these devices: Face-to-face groups hedged more than electronic groups, but both groups used questions just as often. We discuss how these and other differences emerge from the costs and affordances of communication media.
Machines invented for WW II code breaking
Authors: Plimmer Beryl
Published: July 2004

In 1944 a computer was commissioned at Bletchley Park in England. This computer was designed specifically to find the settings used by German cipher machines to encrypt messages, which it did very effectively. Before "Colossus" the Polish and British military had developed mechanical machines to aid with cryptography. All of this work was top secret and only with the recent release of documents has the true significance of these machines and the people who created them been appreciated.
A Web site to promote CS education as a research area
Authors: Almstrum Vicki L.
Published: July 2004

This paper introduces a Web site designed as a tool for anyone wanting to carry out research in the area of CS education. The paper describes the motivation behind the various parts of the site and invites participation from the SIGCSE community in using the site and helping it evolve. The Web site highlights many possibilities for solid educational research and thus publicizes the field as a legitimate academic endeavor.
An overview of regression testing
Authors: Wahl Nancy J.
Published: July 2004

Regression testing is an important part of the software development life cycle. Many articles have been published lately detailing the different approaches. This article is an overview of regression testing in the following areas: types of regression testing; unit, integration and system level testing, regression testing of global variables, regression testing of object-oriented software, comparisons of selective regression techniques, and cost comparisons of the types of regression testing.
A survey of software inspection checklists
Authors: Brykczynski Bill
Published: July 2004

Software inspection processes call for a checklist to provide reviewers with hints and recommendations for finding defects during the examination of a workproduct. Many checklists have been published since Michael Fagan created the inspection process in the mid-1970's. This paper surveys 117 checklists from 24 sources. Different categories of checklist items are discussed and examples are provided of good checklist items as well as those that should be avoided.
9
th
workshop on institutionalizing software reuse (WISR '9) workshop summary
Authors: Poulin Jeffrey S. , Batory Don , Latour Larry
Published: July 2004

What has the field of reuse accomplished? Where can we declare success? Where should we take the blame for failure? The invitees to WISR recently met in Austin, Texas to address these questions and to help determine the direction of future reuse research and practice.
On the use of naming and binding in early courses
Authors: Smotherman Mark
Published: July 2004

In most computer science curricula, the concepts of naming and binding are explicitly treated only in a small number of the later courses, such as operating systems and programming language foundations. However, these concepts are fundamental and underlie the whole of computer science. In this paper, a proposal is made to explicitly introduce these concepts in the second or third course so that they may be used in the analysis of ideas encountered throughout a student's program of study. The benefit of this earlier introduction is demonstrated by detailing how a computer organization course can explicitly incorporate these concepts. These concepts can also be used to advantage in other early courses, such as data structures.
A course project to design and implement the kernel of a real-time operating system
Authors: Kurtz Barry L. , Pfeiffer Joseph J.
Published: July 2004

There is a desperate lack of training in real-time programming in the computer science curriculum. At best, students may write an interrupt driven program in an assembly language course. As a result, a majority of real-time programming in industry is done by enginers who understand hardware but have little training in program development for complex software systems. This paper describes a course project that can be used in an operating systems course or a course in real-time software design. The project development proceeds from the core of a real-time kernel outward to user calls to the kernel. The major components of this project are: the underlying data structures, the scheduler, input and output device drivers, programmer's interfaces to the system, and a series of user programs exercising the system. The original course was developed for an industrial environment where it proved to be quite successful. The project has been adapted for for use both in an operating systems course and a special topics course in real-time programming.
Participatory teaching methods in computer science
Authors: Jones James S.
Published: July 2004

This paper discusses the role of participatory teaching methods in the computer science classroom. The list of these methods includes brainstorming, directed dialogues, small discussion groups, role playing, games, debates, panel discussions, and Socratic dialogues. The author has used such methods in Computers and Society classes and to a limited degree in Compiler Design, Computer Architecture and Operating Systems classes and believes that such techniques have a place in the computer science classroom. It is the aim of this paper to provide an overview of participatory teaching methods and their use in computer science education.
A course in computer systems planning
Authors: Rehmer Karl
Published: July 2004

Those aspects of computer science dealing with the selection of computer hardware, the selection of computer software, the tradeoffs between in-house development and purchase, the transition to a new system, computer performance evaluation, and computer center management are not covered or are covered very lightly in an undergraduate curriculum. This paper presents the evolution and content of a senior-level course on these subjects taught at Indiana-Purdue at Fort Wayne.
Algorithm animator: a tool for programming learning
Authors: Giannotti Elena
Published: July 2004

A primary and most important problem in computer science education at the undergraduate level lies in providing students with interactive tools to favor learning, to stimulate a more effective laboratory activity, and to facilitate the development and debugging of programs. Toward this end, we have designed VISAL, a tool for animating the execution of a program, and a library of fundamental algorithms instrumented for visualization. Visualizing the execution of a given program should enable the students to better understand the dynamic aspects of programming. We also describe the experimental work carried out by undergraduates of a programming course, in order to verify both the effectiveness of VISAL implementation and the role played by VISAL as an aid in learning activities.
A logic programming model of the game of sprouts
Authors: Butler Ralph M. , Trimble Selden Y. , Wilkerson Ralph W.
Published: July 2004

The game of Sprouts has intrigued mathematicians for nearly twenty years. This paper describes a representation scheme which simplifies much of the geometry of the game. Using this representation, we develop a Prolog program which will play Sprouts. It is hoped that the program will prove to be a useful research tool in finding the key to a winning strategy for Sprouts and that the representation will serve as a useful model for studying planar graphs.
Networking elements in a files course
Authors: Cassel Lillian N.
Published: July 2004

Courses in Computer Science and Information Systems are constantly in need of revision to remain relevant. Often entire new courses become needed as an area develops. These can be the most challenging alterations to a curriculum. In some cases, while provisions are being made to introduce a new course, key components of the course can be introduced as modules of already existing courses. An example is considered in which seemingly dissimilar courses meet, and new material is given a forum in a standard curriculum. An extension to a standard file processing course to include the files-affecting impact of computer networks is proposed.
On-campus cooperative education
Authors: Woodfield Scott N. , Stokes Gordon E. , Crandall Vern J.
Published: July 2004

In the past, on-site cooperative education has been the primary means of providing practical experience for computer science students. On-campus cooperative education is proposed as a viable alternative. This paper describes on-campus cooperative education as practiced at BYU. Advantages and disadvantages for the sponsoring company, university, students, faculty, and company personnel involved are also presented. The last part of the paper describes several guidelines which, if followed, should improve the educational experience.
Student file management under Primos
Authors: Uram Michael , McGlinn Robert J.
Published: July 2004

This paper describes SFM, a software package designed to manage student programming assignments on the PRIMOS operating system. In addition to providing a mechanism for the paperless submission of programming assignments, SFM affords the users increased file security, exact enforcement of due dates, thorough testing of programs, better machine utilization, reduced student frustration, and detailed reports.
Conference grading of computer programs
Authors: Ferguson Ernest
Published: July 2004

Two methods of grading computer science programs in a CSI course were evaluated in terms of (1) benefit to the student, (2) advantages for the instructor and (3) plagiarism. The two methods compared were conference grading and grading using written comments.

Results indicate that students thought the grading was more fair when graded by one-on-one conference than when graded with written comments. The time required by the instructor was nearly the same. More was communicated orally in this time than in writing. There was less plagiarism in programs graded by conference, and the students whose programs had been graded by conference performed better on a programming test than those who had their programs graded by written comments. There was no significant difference between the two groups on the written examinations.
Evaluating students in systems development group projects
Authors: Chrisman Carol , Beccue Barbara
Published: July 2004

Evaluating students in group projects is difficult. Both the end products of the group and the individual contributions of each group member must be evaluated in a fair manner. This paper will describe a set of evaluation procedures for a systems development group project. The procedures have three main features. First, the procedures structure the evaluation by partitioning the project grading into small components. Second the procedures incorporate the use of grading sheets for the group documentation at each project milestone. Third, the procedures provide for an interaction between the performance of the group and the performance of individual students in determining each individual's project grade. These procedures provide periodic feedback, allow students to clearly see how the project evaluation will be done, and encourage some objectivity and consistency in the grading process.
Computer science as the focus of a secondary school magnet program
Authors: Monahan Brian D.
Published: July 2004

The “Magnet Program” is a concept that has received a great deal of attention, especially in urban school districts. A magnet program is one which is made available to students who live outside of the area which is usually served by the school in which the program is housed. A key requirement of any magnet program is that participation be voluntary. Students attend magnet programs to take advantage of what those programs offer. In many cases, students in magnet programs spend up to an hour traveling to school each day.
A content analysis of six introduction to computer science textbooks
Authors: Means H. Willis
Published: July 2004

A content analysis was conducted on three pairs of introduction to computer science textbooks to determine if there were any significant differences in their content. The results of the analysis seem to indicate that the content of major topics in earlier computer science texts is not signficantly different from more recent textbooks.
Efficient points-to analysis for whole-program analysis
Authors: Liang Donglin , Harrold Mary Jean
Published: July 2004

To function on programs written in languages such as C that make extensive use of pointers, automated software engineering tools require safe alias information. Existing alias-analysis techniques that are sufficiently efficient for analysis on large software systems may provide alias information that is too imprecise for tools that use it: the imprecision of the alias information may (1) reduce the precision of the information provided by the tools and (2) increase the cost of the tools. This paper presents a flow-insensitive, context-sensitive points-to analysis algorithm that computes alias information that is almost as precise as that computed by Andersen's algorithm — the most precise flow- and context-insensitive algorithm — and almost as efficient as Steensgaard's algorithm — the most efficient flow- and context-insensitive algorithm. Our empirical studies show that our algorithm scales to large programs better than Andersen's algorithm and show that flow-insensitive alias analysis algorithms, such as our algorithm and Andersen's algorithm, can compute alias information that is close in precision to that computed by the more expensive flow- and context-sensitive alias analysis algorithms.
The concept of dynamic analysis
Authors: Ball Thoms
Published: July 2004

Dynamic analysis is the analysis of the properties of a running program. In this paper, we explore two new dynamic analyses based on program profiling:

Frequency Spectrum Analysis
. We show how analyzing the frequencies of program entities in a single execution can help programmers to decompose a program, identify related computations, and find computations related to specific input and output characteristics of a program.

Coverage Concept Analysis
. Concept analysis of test coverage data computes dynamic analogs to static control flow relationships such as domination, postdomination, and regions. Comparison of these dynamically computed relationships to their static counterparts can point to areas of code requiring more testing and can aid programmers in understanding how a program and its test sets relate to one another.
ROSATEA
Authors: Richardson Debra , Inverardi Paola
Published: July 2004

This article reports on the International Workshop on the Role of Software Architecture in Analysis and Testing, which was sponsored jointly by U.S. and Italian government agencies. We begin by providing an overview of the workshop organization but focus the technical program. We conclude with the research agenda set forth by the workshop.
Directions for the NSF software engineering and languages program
Authors: Anger Frank D.
Published: July 2004

PITAC, IT, and 50 years of history suggest changes in the way we "do" software engineering research. NSF's Software Engineering and Languages Program plans new emphases in the coming year that intend to help the field progress.
Teaching database management systems with Java
Authors: Merzbacher Matthew
Published: July 2004

We present a multi-phase programming project, in Java, for an upper-division database course. The project parallels a modest reordering of the traditional classroom presentation of database management. In addition to illuminating theoretical concepts, the lab provides a capstone experience for an undergraduate computer science degree.
Enhancing the value of a project in the database course
Authors: Robbert Mary Ann
Published: July 2004

Data management is a crucial issue for the new millennium. A database course can reflect current issues and new technologies plus teach the basic concepts through the use of a multiple component project and reflection. This paper describes a methodology to expose students to the dynamics of a database environment and teach them to tract theoretical principles from their experiences.
Conservatively radical Java in CS1
Authors: Reges Stuart
Published: July 2004

Java is fast becoming the language of choice in CSI, but we have yet to figure out how to take full advantage of it's special features. The conservatives teach the old course in Java syntax. The radicals restructure the course to include Graphical User Interfaces (GUIs) and concurrency. I prefer a “conservatively radical” middle ground where I use modern GUI programs to teach the old course concepts. I write GUI/concurrent code and ask my students to complete the program by supplying a particular class or two. Thus, they work on interesting problems without having to understand the details of how my code works. And in the process, they get a practical introduction to the modern programming experience of writing a small piece of a much larger program, allowing me to emphasize abstraction early.
Application of security tot he computing science classroom
Authors: Vaughn Rayford B.
Published: July 2004

The author of this paper was a practicing security professional for over ten years in government and industry before accepting a position in academia where he now teaches software engineering and computer security topics in graduate and undergraduate level programs. Lessons learned in the transition are presented along with some insights with respect to the depth and breath that today's computer science student is exposed to with respect to INFOSEC topics. A recommendation for incorporating computer security training into modern day computer science programs is provided
JHAVÉ—an environment to actively engage students in Web-based algorithm visualizations
Authors: Naps Thomas L. , Eagan James R. , Norton Laura L.
Published: July 2004

In this paper, we describe JHAVÉ (Java-hosted Algorithm Visualization Environment), a client-server environment for delivering algorithm visualizations over the Web. The first section of the paper briefly summarizes prior research by a variety of investigators into the pedagogical effectiveness of algorithm visualization (AV). The design goals of JHAVÉ are then placed in the context of this research. After a discussion of some technical details of the JHAVÉ architecture, we present two examples of algorithms depicted in JHAVÉ. The results of students' exploring these algorithms with JHAVÉ are analyzed. We close with a discussion of the general conclusions reached from our current work and future directions in which it may lead.
Algorithma 99
Authors: Concepcion Arturo I. , Leach Nathan , Knight Allan
Published: July 2004

This paper reports on our experience in achieving reusability and using component-based software engineering in the Algorithma 99 (Algorithm Animation) Project. We show how we extended and reused Algorithma 98 [2] into Algorithma 99 and how we prepared Algorithma 99 to be reused in Algorithma 2000 (to be implemented in Winter 2000). Component-based software engineering is not only confined to binary components, such as COM and CORBA, but is also applicable to software processes, architectures and design, and object-oriented libraries.
Introducing computer science using a breadth-first approach and functional programming
Authors: Vandenberg Scott , Wollowski Michael
Published: July 2004

We present a breadth-first, lecture- and lab-based approach to introducing Computer Science that uses functional programming. Functional programming provides a low-overhead introduction to programming (no types, few constructs, and little syntax), enabling students to write, in their first semester, programs sophisticated enough to exemplify important concepts of Computer Science. It also encourages good programming style (modular design and testing, e.g.) and serves as an introduction to an important problem-solving paradigm. The course gives the students a broad overview of Computer Science and helps them gauge their interest in the field.
A Bachelor of Science in information technology
Authors: Spooner David L.
Published: July 2004

Rensselaer has launched a new Bachelor of Science degree program in Information Technology [4,5]. This degree is an alternative to the more traditional computer science or computer systems degrees that Rensselaer continues to offer. It focuses on the application of computing and communications technologies in a student-chosen application area called a second discipline. The expectation is that a company doing business in the second discipline or closely related area will employ a student completing this degree.

This paper describes the motivation behind the new degree program and its interdisciplinary approach. It also presents the organization of the curriculum and its requirements.
Yet, more Web exercises for learning C++
Authors: Elenbogen Bruce S. , Maxim Bruce R. , McDonald Chris
Published: July 2004

This paper describes a set of author developed interactive web exercises and a development environment designed to facilitate language acquisition in a beginning course in C++. The exercises test the students' understanding of several C++ language constructs as well as general programming concepts such as scope of variables. The environment allows students to write and test sections of code in a instructor controlled setting. Together the exercises and environment can be used to enhance computer science education for both traditional and distance learning students. The paradigm of generalization and automation of standard exercises can be extended to facilitate web education in other courses.
Strategies for encouraging individual achievement in introductory computer science courses
Authors: Roberts Eric
Published: July 2004

Students in introductory computer science courses often vary widely in background and ability. As a result, some students are bored by the pace of presentation, while others struggle to keep up. This paper describes our experience using open-ended assignments and programming contests to capture the interest of our strongest students without adversely affecting the educational experience for the other students in the class. This approach has been markedly successful, particularly for highly motivated students, who are often able to work well beyond the level of the class. The paper also includes a survey of student reactions to the various extra-credit opportunities, which indicates that many student value this component of the class even if they do not participate directly in these activities.
EROSI—visualising recursion and discovering new errors
Authors: George Carlisle E.
Published: July 2004

This paper introduces a novel software visualisation aid, the EROSI (Explicit Representer Of Subprogram Invocations) tutor, hypothesised to support the acquisition (by novice programmers) of a mental model to facilitate the comprehension and use of recursion as a problem solving technique. Novices found the EROSI tutor easy to use, interesting and a valuable visualisation aid to forming correct mental models of recursive processes. Studies concluded that although novices many have a correct mental model of recursion, various errors and misconceptions (identified) due to exogenous factors affect their ability to complete recursive tasks.
Distance education
Authors: Gerhardt-Powals Jill , Powals Matthew H.
Published: July 2004

Late last year President Clinton signed into law the Digital Millenium Copyright Act. It was a far reaching attempt to update copyright law in order to keep pace with the digital environment by providing new rules for downloading, sharing, or simply viewing copyrighted material on-line Some cheered the passage of The Act and others lamented it. For the software and entertainment industries it was a triumph because now they can market their products on-line without fear of piracy. However many, including academics, educators, and researchers, view The Act as a set back, even an assault, on their traditional access to and use of information. The balancing of conflicting needs of the copyright owners and the users of copyrighted materials, while applying the copyright law to the emerging technology of today, is truly an evolving and a daunting process.

Included in The Act was a mandate to the Register of Copyrights to consult with representatives of copyright owners, nonprofit educational institutions, and nonprofit libraries and archives, and submit to Congress recommendations on how to promote distance education through digital technologies, including interactive digital networks, while maintaining an appropriate balance between the rights of copyright owners and the needs of users of copyrighted works. The purpose of this paper is to place The Register of Copyrights Study in its historical environment and describe the recommendations of The Study concerning how to promote distance education through digital technologies.
CS1 and CS2 (panel session)
Authors: Baldwin Doug , Smith Carl H. , Hendersen Peter B. , Vadisigi Venu , Tomer D. S.
Published: July 2004

Over a period of thirty years there have been many curriculum reforms in the Undergraduate Computer Science curriculum. The ACM/IEEE-CS task force is currently working on the Curriculum 2001. In this struggle to define and develop this dynamic field of computer science, we have the opportunity to identify the foundations and related concepts of mathematics we would like to see in the new CS curriculum and introduce these in CS1 and CS2. Many standard topics of discrete mathematics can encourage the use of mathematical thinking when taught along with the CS courses. The more complex foundations and other theoretical topics may be introduced later in the curriculum. This session will present some of the views and examples in this direction. Our goal is not to eliminate the need of discrete math but to integrate it into the basics of CS so that the student will experience mathematical reasoning in the early stages of the development of CS topics. Currently discrete math is taught as one of the early math requirements and many students do not see the relationship between the programming concepts and these mathematical concepts. An early blend of these ideas of will provide a richer experience to CS majors and the new topics can be learned more quickly if the underlying theoretical concepts are well understood. The programming languages of choice can be introduced in separate laboratory components taken parallel to CS1 and CS2.

We hope that we all can agree that CS is not just programming and we have a new discipline that must develop its basic theory rather than depending on other disciplines to do it for us. Someday, the courses we know now as CS1 and CS2 maybe known as University Computing I and II as we now have in some of the other sciences.
IT programs and CS departments (panel session)
Authors: Deremer Dorothy , McDonald Chris , Rhodes Loren , Thomas Rebecca , Turner A. Joe , White Curt , Koffman Elliot
Published: July 2004

Computer Science departments are experiencing increases in enrollments that rival the expansion in the early '80s. At the same time, many of these students do not seem interested in or equipped to handle the rigor of a traditional computer science program. They are coming into computer science with expectations about computer science education that are significantly different from what they are finding on campus. Instead of courses on data structures and algorithms, automata, and operating systems, they want to learn Visual BASIC, linux, and obtain Microsoft certification.

CS departments responses to these pressures differ widely. Some take the approach that this is a temporary aberration and should have no affect whatsoever on degree programs in computer science. Some provide one-credit courses or seminars to discuss practical aspects of IT not covered in the curriculum. Others have started information technology programs to provide these students with an alternative program. In some cases, outside pressures (i.e., the university administration or external funding) has mandated that CS departments provide such programs.

This panel will discuss these issues from varying perspectives. It will also provide some examples of IT programs in CS departments to give us some idea of what is currently being done at other institutions.
Debugging via run-time type checking
Authors: Horwitz Susan
Published: July 2004

Java programmers have the security of knowing that errors like out-of-bounds array indexes or attempts to dereference a null pointer will be detected and reported at run time. C and C++ programmers count on tools like Purify to achieve a similar level of confidence. The run-time checks provided by Purify have proved to be extremely useful to programmers in debugging their programs.Java also provides security via its strong type system. For example:• There are no union types in Java, so it is not possible for a program to write into a field of one type and then access that value via a field of a different type.• Only very restricted kinds of casting are allowed; for example, it is not possible to treat a pointer as if it were an integer or vice versa.• When an object is down-cast to a subtype, a run-time check will be performed to ensure that the actual type of the object is consistent with the cast.However, tools like Purify do not provide similar checks for C/C++ programs. This research involves the design and implementation of a tool to provide new kinds of run-time checks based on type information. That is, the goal of the tool is to help C/C++ programmers find errors in their programs that manifest themselves as bad run-time types, in the same way that Purify helps programmers find errors in their programs that manifest themselves as bad run-time memory accesses.The basic idea is to associate a run-time type with every piece of data. Whenever data is used by some operation, a check is performed to ensure that its run-time type is consistent with the type expected by the operation. For example, when a pointer is dereferenced, its run-time type must be "pointer" (not "int", "float", "uninitialized", etc). When an integer multiplication is performed, the operands' run-time types must be "int" (not "pointer", "float", "uninitialized", etc).
Integrating legacy systems in distributed object architecture
Authors: Juric Matjaz B. , Rozman Ivan , Hericko Marjan , Domajnko Tomaz
Published: July 2004

The ability of a new technology to reuse legacy systems is very important for its economic success. This paper presents a method for integrating legacy systems within distributed object architectures. The necessary steps required for integration are defined. It is explained how to define object interfaces. A detailed overview of how to implement the wrappers is given. The paper also answers the question which distributed object model is most suitable for legacy integration. Therefore a decision model is defined and the evaluation results are presented.
Putting static analysis to work for verification
Authors: Lev-Ami Tal , Reps Thomas , Sagiv Mooly , Wilhelm Reinhard
Published: July 2004

A method for finding bugs in code is presented. For given small numbers j and k, the code of a procedure is translated into a rela-tional formula whose models represent all execution traces that involve at most j heap cells and k loop iterations. This formula is conjoined with the negation of the procedure's specification. The models of the resulting formula, obtained using a constraint solver, are counterexamples: executions of the code that violate the specification.

The method can analyze millions of executions in seconds, and thus rapidly expose quite subtle flaws. It can accommodate calls to procedures for which specifications but no code is avail-able. A range of standard properties (such as absence of null pointer dereferences) can also be easily checked, using prede-fined specifications.
OMEN: A strategy for testing object-oriented software
Authors: Souter Amie L. , Pollock Lori L.
Published: July 2004

This paper presents a strategy for structural testing of object-oriented software systems with possibly unknown clients and unknown information about invoked methods. By exploiting the combined points-to and escape analysis developed for compiler optimization, our testing paradigm does not require a whole program representation to be in memory simultaneously for testing analysis. Potential effects from outside the component under test are easily identified and reported to the tester. As client and server methods become known, the graph representation of object relationships is easily extended, allowing the computation of test tuples to be performed in a demand-driven manner, without requiring unnecessary computation of test tuples based on predictions of potential clients.
On subdomains
Authors: Hamlet Dick
Published: July 2004

Subdomains of a program's input space are a concept around which ideas about testing can be organized. This paper considers the questions, ``What are the best subdomains for:

testing to detecting failures

defining operational profiles

measuring component reliability?
Verifying properties of process definitions
Authors: Cobleigh Jamieson M. , Clark Lori A. , Osterweil Leon J.
Published: July 2004

It seems important that the complex processes that synergize humans and computers to solve widening classes of societal problems be subjected to rigorous analysis. One approach is to use a process definition language to specify these processes and to then use analysis techniques to evaluate these definitions for important correctness properties. Because humans demand flexibility in their participation in complex processes, process definition languages must incorporate complicated control structures, such as various concurrency, choice, reactive control, and exception mechanisms. The underlying complexity of these control abstractions, however, often confounds the users' intuitions as well as complicates any analysis.

Thus, the control abstraction complexity in process definition languages presents analysis challenges beyond those posed by traditional programming languages. This paper explores some of the difficulties of analyzing process definitions. We explore issues arising when applying the FLAVERS finite state verification system to processes written in the Little-JIL process definition language and illustrate these issues using a realistic auction example. Although we employ a particular process definition language and analysis technique, our results seem more generally applicable.
Prioritizing test cases for regression testing
Authors: Elbaum Sebastian , Malishevsky Alexey G. , Rothermel Gregg
Published: July 2004

Test case prioritization techniques
schedule test cases in an order that increases their effectiveness in meeting some performance goal. One performance goal,
rate of fault detection
, is a measure of how quickly faults are detected within the testing process; an improved rate of fault detection can provide faster feedback on the system under test, and let software engineers begin locating and correcting faults earlier than might otherwise be possible. In previous work, we reported the results of studies that showed that prioritization techniques can significantly improve rate of fault detection. Those studies, however, raised several additional questions: (1) can prioritization techniques be effective when aimed at specific modified versions; (2) what tradeoffs exist between fine granularity and coarse granularity prioritization techniques; (3) can the incorporation of measures of fault proneness into prioritization techniques improve their effectiveness? This paper reports the results of new experiments addressing these questions.
A thread-aware debugger with an open interface
Authors: Schulz Daniel , Mueller Frank
Published: July 2004

While threads have become an accepted and standardized model for expressing concurrency and exploiting parallelism for the shared-memory model, debugging threads is still poorly supported. This paper identifies challenges in debugging threads and offers solutions to them. The contributions of this paper are threefold. First, an open interface for debugging as an extension to thread implementations is proposed. Second, extensions for thread-aware debugging are identified and implemented within the Gnu Debugger to provide additional features beyond the scope of existing debuggers. Third, an active debugging framework is proposed that includes a language-independent protocol to communicate between debugger and application via relational queries ensuring that the enhancements of the debugger are independent of actual thread implementations. Partial or complete implementations of the interface for debugging can be added to thread implementations to work in unison with the enhanced debugger without any modifications to the debugger itself. Sample implementations of the interface for debugging have shown its adequacy for user-level threads, kernel threads and mixed thread implementations while providing extended debugging functionality at improved efficiency and portability at the same time.
Conserving the seed corn
Authors: Roberts Eric
Published: July 2004

Computer science departments today face a serious staffing crisis, as faculty and graduate students abandon academia for industry while undergraduate enrollments rise. The current crisis is similar to one that occurred in the early 1980s, which gives us the opportunity to learn from that experience. This article reviews the history of the earlier crisis and proposes strategies for mitigating the effects of the current one.
Distance teaching at Uppsala
Authors: Dale Nell B.
Published: July 2004

This is not a research paper about distance learning or teaching, but rather a chronicle of the author's two-month visit to a department in another country where she taught a course similar to CS2 as a distance learning course. Hence, the title.
Elucidate
Authors: Exton Chris
Published: July 2004

The adoption of concurrent programming techniques into mainstream system development has brought with it a problem in software comprehension. Stepping through the code is no longer adequate to ensure a student's understanding of how a concurrent program will execute.
Elucidate
attempts to rectify this inadequacy by giving the student the ability to dynamically explore the various threads of execution and event order of an executing concurrent program. The student can gain an understanding of the threads of control and how they relate to classes, object instantiation, destruction and method invocation.
Elucidate
adds a layer of abstraction that is capable of clearly exhibiting to the student many of the underlying problems associated with concurrent programming.
The ANIMAL algorithm animation tool
Authors: Rößling Guido , Schüler Markus , Freisleben Bernd
Published: July 2004

In this paper, we present
Animal
, a new tool for developing animations to be used in lectures.
Animal
offers a small but powerful set of graphical operators. Animations are generated using a visual editor, by scripting or via API calls. All animations can be edited visually.
Animal
supports source and pseudo code inclusion and highlighting as well as precise user-defined delays between actions. The paper evaluates the functionality of
Animal
in comparison to other animation tools.
A suite of WWW-based tools for advanced course management
Authors: Nørmark Kurt
Published: July 2004

A collection of tools for creation of advanced and comprehensive course home pages is presented. The tools cover the spectrum from course overview pages and hypertext teaching materials to interactive services that support the teaching activities during the course. From the teacher's perspective the tools allow for abstraction from details and automation of routine work in the authoring process. Seen from a student's perspective the comprehensive linking of course plans, teaching material, and interactive services provides for a valuable organization of a large body of information.
The Internet-based lecture
Authors: Pullen J. Mark
Published: July 2004

Network-based distributed education is a reality today. At George Mason University, we have been pursuing a capability beyond the widespread practice of supporting courses with webpages: delivering lectures and seminars in real time, over the Internet. This paper describes the range of distributed education technologies available today, focusing on issues of instructor presentation, student participation, and temporal qualities of response to student questions. The analysis supports our selection of desktop audiographics for synchronous Internet-based course delivery. Courses that have been presented in this mode are described, along with factors influencing their success and factors in student participation.
Distance tutorials in a systems design course
Authors: von Wright Joakim
Published: July 2004

An experiment with distance technology in a second-year Object-Oriented Systems Design course is described. Video and computer conferencing were used in tutorial sessions where a teacher and a student group developed and discussed solutions (both textual and graphical) to systems design problems. The experiment is evaluated, both from a technical, an economic and an educational point of view.
Agent technology in computer science and engineering curriculum
Authors: Shang Yi , Shi Hongchi , Chen Su-Shing
Published: July 2004

In recent years, agent technology has been used increasingly in information management and distributed computing. A CSE curriculum that cultivates the knowledge of agent technology will increase the likelihood that the next generation of IT professionals have the background needed to design and develop software systems that are scalable, reliable, adaptable, and secure. In this paper, we present the rationale and our practice in incorporating agent technology into the CSE curriculum. We develop agent-based teaching materials and software modules and apply them to existing CSE courses including artificial intelligence, parallel and distributed processing, networking, and software engineering. Promising results have been obtained in teaching two graduate level courses using agent components.
Student well-being in a computing department
Authors: Davy J. R. , Audin K. , Barkham M. , Joyner C.
Published: July 2004

We describe a project exploring the relationships between factors in the learning environment, student well-being and learning outcomes, in the context of a Computing department. A range of established psychometric tests identified areas of unhelpful stress in the working environment and measures were implemented to rectify these. A significant improvement in measured student well-being followed.