bluuebunny/crossref_metadata_2025 huggingface dataset:
A Web-based lab manual for CS 1
Authors: Cheatham Thomas J.
Published: July 2004

No one can deny the impact the web is having on education. Computer Science education is no exception. Computer literacy classes now include units on web surfing and personal web page creation [6]. Data structures students have web tools for viewing algorithms and dynamic data structures [2, 4-5]. Computer graphics students have 2D and 3D visualization tools [7], and database students learn to access remote databases using ODBC or JDBC over the web [1]. Special courses in web technologies are being added to the curriculum in many departments [3]. It is only natural for a laboratory manual for Computer Science 1 to be presented as an interactive web document. Pedagogically, how does such a laboratory manual compare with the traditional hard-copy manual? What are its strengths and weaknesses? Which approach do students prefer? We sought to answer these and other questions from our empirical study of Computer Science I students. The results of the study and the lessons learned will be described in this article.
Remote logging in Java using Jeli
Authors: Robbins Steven
Published: July 2004

The combination of Java and the World Wide Web has opened up new opportunities for teaching at all levels. It is now possible to assume that all students in a class have access to the web through a browser that supports the Java language and a standard subset of the GUI API. One of the drawbacks of using Java through a browser is the lack of a standardized safe way for a Java applet to access resources on the local machine. Security measures prevent the applet from storing information generated by the applet on the local machine. The Jeli package contains a logging facility that allows an applet to store files either locally (if permitted) or on the server from which the applet was loaded. Jeli logging makes it significantly easier for instructors to develop applets that can permanently store information generated by user interaction with the application. The log can then be used by the student for study or the instructor for grading.
Fostering and assessing communication skills in the computer science context
Authors: Michael Mark
Published: July 2004

In accord with a college-wide assessment program at the author's institution, a required major course approximately midway through a student's college career forms the matrix for an intensive project which both develops and evaluates the student's communication skills in discipline-specific ways. For Computer Science majors, the project is a component of a junior-level Advanced Object-Oriented Programming course. Though centered about a semester-long programming project, it involves expectations, guidance, and feedback beyond what is traditional. This assessment instrument has a minimal impact on class time and course content, substantial impact on faculty and student effort, and tremendous impact on learning.
Experiments with the use of popular press in the computer science curriculum
Authors: Gabbert Paula , Treu Kevin
Published: July 2004

With the objective of encouraging and supporting more critical thinking about broad issues of computer science throughout the curriculum, we propose the widespread use of popular press (non-academic) books as supplemental texts for a variety of courses. Our hypothesis is that such books, which address topics including the history, current issues, and future implications of computing technology, as well as ethical issues, technical details and even fictional treatments, can greatly contribute to a student's education in a variety of courses.
Getting participation through discussion
Authors: Clark Martyn
Published: July 2004

Student participation is a vital component of any taught course. Where the course is concerned with the learning and teaching of theories and concepts, as opposed to skills and experiences, the key activity in which students can participate is discussion. In large classes it is impossible for teachers to engage every student in discussion but they can talk to each other. This paper relates one teacher's experience over two years of trying to encourage students to discuss concepts such as systems and information using electronic bulletin boards. The paper focuses on how the exercise has evolved over time in response to reflection on experience and suggests some guidelines for making a success of this type of exercise.
PILOT
Authors: Bridgeman Stina , Goodrich Michael T. , Kobourov Stephen G. , Tamassia Roberto
Published: July 2004

We describe a Web-based interactive system, called PILOT, for testing computer science concepts. The strengths of PILOT are its universal access and platform independence, its use as an algorithm visualization tool, its ability to test algorithmic concepts, its support for graph generation and layout, its automated grading mechanism, and its ability to award partial credit to proposed solutions.
Empirical results of a software engineering curriculum incorporating formal methods
Authors: Sobel Ann E. Kelley
Published: July 2004

A three year study of integrating formal methods into the undergraduate software engineering curriculum of the Systems Analysis Department of Miami University was recently completed (NSF Educational Innovation Program CDA-9522257). Formal analysis skills were added to the curriculum to address the concern that the discipline of software engineering education lacks sufficient emphasis on mathematics and engineering science. A presentation of the six courses chosen for integration of formal analysis is given. The empirical data which directly compares the problem solving skills of the formal methods and control student groups shows that the formal methods students possess an increased level of complex problem solving skills as well as a greater ability to perform problem abstraction.
Software quality
Authors: Hilburn Thomas B. , Townhidnejad Massood
Published: July 2004

This paper addresses a central and critical issue in the development of computer software - its quality. The main thesis of the paper is that computer science faculty, in their design and implementation of curricula, do not devote sufficient attention to teaching their students how to develop high-quality software. As in industry, the most common and popular way of assuring the quality of programs is through software testing. In other words, quality is treated as an afterthought or as postscript in program development. The paper presents and discusses a quality model that can be used to incorporate a wide variety of quality assurance techniques within a curriculum. The model also presents a structured approach for introducing software testing into the educational environment. Finally, there is a discussion of how the model has been implemented using two current software process technologies, the PSP and the TSP.
The effect of a constructivist learning environment for field-dependent/independent students on achievement in introductory computer programming
Authors: Gibbs David C.
Published: July 2004

Research was conducted to determine the effect of a constructivist learning environment upon field dependent (FD) and field independent (FI) students' achievement in an introductory computer programming course. Prior research in traditional environments had established a correlation between field dependence / independence (FD/I) and the design stage of programming.

A correlational design was followed, using introductory computer science students in their first programming course. A pretest of BASIC programming ability was given to assess baseline proficiency. The Group Embedded Figures Test (GEFT) was given to assess each subject's measure of FD/I. A constructivist model for learning programming was implemented. Achievement tests in two of the stages of programming, design and coding were administered. As additional dependent variables, student construction of programming elements — the design (semantic) elements, and the language-specific coding (syntax) elements - were collected in a portfolio and examined for both qualitative and quantitative differences.

No significant correlations were found between FD/I and the achievement scores of design and coding. No correlation was expected between FD/I and coding. There was no interaction between FD/I and design versus coding. The correlation between FD/I and the quantity of reconstructed programming elements was not significant. The correlation between FD/I and the quality of reconstructed programming elements was not significant. No interaction was found between FD/I and the quantity or quality of semantic versus syntactic elements. Stepwise multiple regression identified two predictors, for design, the predictor was the pretest. Coding was predicted by the quantity of syntactic programming elements.

The principal finding of this research, in contrast to findings in traditional environments is that within this constructivist environment, the cognitive style of FD/I was not found to influence programming achievement.
Aristotle and object-oriented programming
Authors: Rayside Derek , Campbell Gerard T.
Published: July 2004

Classifying is a central activity in object-oriented programming and distinguishes it from procedural programming. Traditional logic, initiated by Aristotle, assigns classification to our first activity in reasoning, whereby
we come to know what a thing is
. Such a grasp of the thing's
whatness
is the foundation for all further reasoning about it.

This connection between Aristotle's way of classifying and object-oriented programming is sometimes acknowledged, but rarely explored in depth.
1
We explore this relation more closely and more carefully, in the hope that a better understanding of classification and programming can be gained from a study of philosophy than from many current text books on object-oriented programming.
E-commerce and computer science education
Authors: Ge Yuzhen , Sun Jiangeng
Published: July 2004

Electronic commerce is gradually changing the way the commerce is conducted. Computer science graduates will need to be prepared for the challenge posed by the increasing demand for professionals who can develop and maintain electronic commerce systems. By examining the standard computer science curriculum, some suggestions are proposed.
Bugs as features
Authors: Richards Brad
Published: July 2004

Being exposed to well-written code is a valuable experience for students—especially when the code is larger or more complex than they are currently capable of writing. In addition to the mechanics of a particular computation, students learn organization and documentation skills, and general concepts illustrated by the specific program. However, to obtain these benefits, students must thoroughly familiarize themselves with the code. This paper describes recent successes using software bugs as a means to force familiarization with network protocol code. The bugs become tools by which the students learn the inner workings of network protocols. As a side benefit, the approach provides a concrete basis for the discussion of debugging approaches and techniques. The technique is appropriate for any course involving programming, and is especially good for upper-level courses like networks, operating systems, and parallel and distributed programming, where difficult concepts can be illustrated via sample programs.
Interdisciplinary capstone group project
Authors: Mosiman Steve , Hiemcke Christoph
Published: July 2004

We, the authors, have each managed group projects for our respective senior majors for some time. Three years ago we combined the senior courses and each project team is now composed of both computer science and engineering majors. We were motivated by the desire to broaden the senior experience in both disciplines as well as to use the projects to attract prospective majors. The most recent project was to build autonomous line-tracking vehicles for racing. Since the computer scientists do not necessarily have any exposure to analog circuits and the engineers have only limited knowledge, it was necessary to provide an environment that required little analog design. The Handy Board [7] proved to be a useful part of that environment. This paper discusses our experience teaching an interdisciplinary group project-oriented course, discusses strengths and weaknesses of using the Handy Board in this context, and draws some conclusions based on our experience.
SAIL
Authors: Bridgeman Stina , Goodrich Michael T. , Kobourov Stephen G. , Tamassia Roberto
Published: July 2004

In this paper we present a package for the creation of Specialized Assignments In L
A
T
E
X, SAIL. We describe several features which allow an instructor to create sufficiently different instances of the “same” problem so as to encourage student cooperation without fear of plagiarism. The SAIL package also provides support for grading aids and grading automation. In addition, we describe an on-line system for archiving homework problems in a database that can be easily searched and to which new parametrized problems can be easily added. Together, the SAIL package and the searchable database of problems offer a powerful tool for generating, archiving, and retrieving homework assignments (as well as tests and quizzes).
A study of common pitfalls in simple multi-threaded programs
Authors: Choi Sung-Eun , Lewis E. Christopher
Published: July 2004

It is generally acknowledged that developing correct multi-threaded codes is difficult, because threads may interact with each other in unpredictable ways. The goal of this work is to discover common multi-threaded programming pitfalls, the knowledge of which will be useful in instructing new programmers and in developing tools to aid in multi-threaded programming. To this end, we study multi-threaded applications written by students from introductory operating systems courses. Although the applications are simple, careful inspection and the use of an automatic race detection tool reveal a surprising quantity and variety of synchronization errors. We describe and discuss these errors, evaluate the role of automated tools, and propose new tools for use in the instruction of multi-threaded programming.
Experimentation with bounded buffer synchronization
Authors: Robbins Steven
Published: July 2004

Undergraduates are usually introduced to synchronization in operating systems through a discussion of classical problems such as reader-writer or producers-consumers. The traditional approach to teaching these topics is not effective in conveying to students how programs with incorrect synchronization actually behave. This paper introduces a simple probabilistic model for synchronization failure and shows how students can empirically study these issues. These activities are supported by a simulator that students can use to explore synchronization in the context of the bounded buffer problem. The simulator is written in Java and can be used either standalone or from a standard browser. Students can save the data and graphs generated by the simulator in a log file in HTML format.
Distance teaching workloads
Authors: Doube Wendy
Published: July 2004

In this paper, we describe a formula for calculating the teaching workload for students who are studying off campus both on and off-line. Initially the faculty of information technology developed a proposal for calculating academic workloads. This proposal reflected the rigid teacher centred learning structures of traditional on-campus delivery and made no allowance for the services required by off-campus students. In response, teachers of off-campus students developed a complementary proposal, based on actual time logs, which reflected their student centred approach to learning. Contrary to popular wisdom, off-campus teaching was found to be more time-consuming than on-campus.
Object-orientation in Java for scientific programmers
Authors: Bishop Judith , Bishop Nigel
Published: July 2004

Scientific programmers have traditionally programmed in entirely sequential languages such as Fortran, C or Pascal and it could be argued that object-orientation is not a concept that they would need. Yet computer science departments that give courses to scientists and engineers would like to consider teaching them in Java, rather than in one of the older languages. This paper addresses the dual issues of how Java can best supply everything that the older languages do, and then what it can meaningfully give in added value, especially in the networking and parallel area. Experience with developing solutions in Java to some fifty typical numerical problems has led to a coherent object-oriented approach and a couple of essential support classes for teaching and production work.
An object-oriented view of backtracking
Authors: Noonan Robert E.
Published: July 2004

In this paper we explore Wirth's[11]
backtracking algorithm
from the perspective of algorithm reuse and separation of concerns. We explore treatment of this problem in object-oriented data structures and algorithms texts. Finally, we present a reusable backtracking (or depth-first search) class.
Do visualizations improve program comprehensibility? experiments with control structure diagrams for Java
Authors: Hendrix T. Dean , Cross James H. , Maghsoodloo Saeed , McKinney Matthew L.
Published: July 2004

Recently, the first in a series of planned comprehension experiments was performed to measure the effect of the control structure diagram (CSD) on program comprehensibility. Upper-division computer science students were asked to respond to questions regarding the structure and execution of a source code module written in Java. Statistical analysis of the data collected from this experiment revealed that the CSD was highly significant in enhancing the subjects' performance in this program comprehension task. The results of this initial experiment along with the planned follow-on experiments promise to shed light on fundamental questions regarding the effect of software visualizations on program comprehensibility.
Experiences with the Webware, interfaces and networking experimental laboratory
Authors: Brown David C. , Cruz Isabel F. , Finkel David , Kinicki Robert E. , Wills Craig E.
Published: July 2004

This paper describes our experiences with the Webware, Interfaces and Networking Experimental (WINE) Laboratory. The WINE Lab was created to assist in teaching the topics of computer networks, user interfaces and webware. The goal of the lab is to provide students the opportunity to complete projects, experiment with relevant techniques and make connections between topics with resources not available in a general purpose Unix-based computing environment. The results from offering courses with the lab show success in meeting these goals.
Teaching Software Psychology
Authors: Vat Kam Hou
Published: July 2004

This paper describes the curriculum development and teaching experience of a junior core course entitled
Software Psychology
, offered in the undergraduate Software Engineering program at the author's affiliated university. In particular, the pedagogy of problem-based learning is introduced, together with the evolution of the course content. It will also address issues such as resources and facilities needed for the course, and the students' perceived learning as well as the author's lessons learned therein.
Student outcomes assessment (panel session)
Authors: McDonald Merry , Kubilus Norbert J. , Fienup Mark , Lopez Dian , Fitzgerald Sue
Published: July 2004

Panelists will describe their schools' approaches to outcomes assessment for computer science students. Both successful and failed approaches will be discussed. Approaches to assessment start with the identification of program goals and selection of appropriate measures. Measurable results include student performance on standardized and locally developed tests, placement statistics, alumni interviews, employer perceptions, and other skills assessment. Pitfalls will be discussed. Results of outcomes assessment at each institution will be presented, including the management of collected data, interpretation of results, and integration of the results into the curriculum development process.
Proposed information systems accreditation criteria (panel session)
Authors: King Willis , Gorgone John , Yaverbaum Gayle , Lidtke Doris K.
Published: July 2004

This panel will discuss the background leading to the decision to develop a Draft Criteria for accreditation of Information Systems programs, the current status of the Draft Criteria, feedback received from presentations at a number of conferences and on a web-based survey, and a brief description of future plans for the project. Time will be allotted for questions from the audience.
Curriculum 2001 (panel session)
Authors: Cover C. Fay , Engel Gerald , Chang Carl , Cross James H. , Shackelford Russ , Roberts Eric
Published: July 2004

In the fall of 1998, the ACM Education Board and the Educational Activities Board of the IEEE Computer Society appointed representatives to a joint task force to prepare Curriculum 2001, the next installment in a series of reports on the undergraduate computer science curriculum that began in 1968 and was then updated in 1978 and 1991. Interim reports on the initial planning of the curriculum were presented at the SIGCSE symposium in March 1999 and at the IEEE Frontiers in Education Conference in November 1999. In February 2000, the Curriculum 2001 Task Force will release a preliminary version of its report, in the hope of gaining feedback from a wider audience. The purpose of this panel is to give attenders at the SIGCSE conference to review the current state of the preliminary draft and offer their comments to the members of the Curriculum 2001 steering committee on the panel.
What's new with ABET/CSAB integration (panel session)
Authors: Saperstein Lee , Martin Kenneth , Bonnette Della , Lidtke Doris K.
Published: July 2004

The Accreditation Board for Engineering and Technology, Inc. (ABET) and the Computing Sciences Accreditation Board (CSAB) signed a Memorandum of Agreement in November 1998 to integrate CSAB's accreditation services with ABET, with a transition time of approximately two years. During the interim period, the operations of the Computer Science Accreditation Commission (CSAC) are contracted by CSAB to ABET. A committee with CSAC, CSAB, and ABET representation is working to set up the new commission for accrediting programs in the computing sciences. This new commission will probably be called the Computing Accreditation Commission (CAC). Other activities are underway to try to assure that this integration goes as smoothly as possible.

The panel members will discuss from various points of view the current status of the integration and plans for the completion of the integration. Kenneth Martin is a Past Chair of CSAC. Lee Saperstein is past Chair of EAC. Della Bonnette is a Past CSAC Chair and current Team Chair. Doris Lidtke is serving as Adjunct Accreditation Director for Computing at ABET and a Past President of CSAB.
Teaching advice and support for new and adjunct faculty (panel session)
Authors: Congdon Clare Bates , Fitzgerald Sue , King Merle S. , Semmes Pat , Kay David G.
Published: July 2004

The demand for computer science faculty is growing rapidly, along with the demand for seats in computer science courses. The problem of finding, recruiting, and retaining computer science faculty may have reached crisis proportions[1]. Meeting this demand means an influx of new faculty, including perhaps nontraditional faculty such as adjuncts from industry, emeriti, graduate students, or faculty from other disciplines.

Such diversity is valuable but brings its own challenges. One of these is acclimating new faculty, particularly those from different academic or industrial environments, to the norms, practices, and expectations of a particular school and department. These may vary considerably among institutions, and some may be subtle and unrecognized, not always identified in existing orientation materials.

For the new faculty's experience to be successful (for themselves, for their students, and for the institution), we must identify these issues. But we must also make that information available in an effective form: A comprehensive “policies and procedures” manual may be left unread amid the more immediate demands of meeting the first class or starting a research program. Experienced colleagues will have some answers, at least idiosyncratic ones, and likely are willing to share them when they have a free moment; even so, the new instructor may hesitate to call on the same person too often.

The panelists will describe their experiences as new or adjunct faculty or as those orienting such faculty; thereafter, we will solicit experiences from the audience. We expect to generate and disseminate a list of teaching issues new faculty must address and a range of strategies for helping those faculty address them. This could serve as a “Prototype FAQ,” one that institutions (or their new-faculty coordinators) could adapt to local practices.
Recommendations for changes in advanced placement computer science (panel session)
Authors: Cartwight Robert , Kick Rich , Horstmann Cay , Trees Fran , Chapman Gail , Gries David , Walkers Henry , Wolz Ursula , Astrachan Owen
Published: July 2004

In 1981 the APCS Development Committee recommended the use of Pascal in an AP course whose first exam was given in 1984. This decision was controversial; BASIC was in widespread use and serious consideration was given to a language-neutral exam and course. In 1985 an ad-hoc committee made recommendations on changing the exam format, essentially creating two courses that correspond roughly to CS1 and CS2. In 1995 an ad-hoc committee was convened to make recommendations on how best to incorporate C++ into the AP course and exam. The decision to adopt C++, made in 1994, was decidedly controversial. The ad-hoc committee made recommendations on a subset of C++ and on classes similar to those in the standard library, but which were safe for novice programmers to use.
Intellectual property law basics for computer science instructors (seminar session)
Authors: Kay David G.
Published: July 2004

Increasingly the practice of computing involves legal issues. Patenting algorithms, domain name poaching, and “re-using” HTML and graphics from web sites all raise questions in the domain of intellectual property law (which includes patents, copyrights, trade secrets, and trademarks). In the classroom, computer science educators often confront questions that have legal ramifications.

To many computer scientists, the legal system seems arbitrary and impenetrable, just as software development is obscure to many lawyers. But each discipline has its own axioms and goals, its own culture and approach to solving problems. Moreover, each discipline has been largely successful in meeting its goals, despite such problems as frivolous, costly lawsuits on one side and unstable, bloated software on the other.

The goal of this seminar is to give computer science faculty a framework for answering students' questions and debunking the most egregious misconceptions about intellectual property issues.
Introduction to the marine biology case study (seminar session)
Authors: Brady Alyce , Clancy Michael J. , Larson Kathleen
Published: July 2004

A new case study for the AP curriculum, based on a marine biology simulation program will be released for the 2000-2001 academic year. The case study highlights linear and two-dimensional data structures, object interaction, object-oriented design, and discrete simulation. This seminar will introduce the new case study to AP teachers and other interested CS educators, and will discuss how it can be integrated into the AP (or CS 1 and CS 2) curricula.
A model for designing adaptable software components
Authors: Heineman George T.
Published: July 2004

An important aim of software engineering is to produce reliable and robust software systems. As software systems grow in size, however, it becomes infeasible to design and construct software systems from scratch. Most software developers are familiar with reusing code from component libraries to speed up tedious programming tasks, such as constructing graphical user interfaces. However, it is still an elusive goal to construct applications entirely from pre-existing, independently developed components. We believe that such component-based development will only occur when application builders can adapt software components to suit their needs.The goal of this research is to develop novel techniques for designing software components that provide a mechanism for adapting their behavior. We aim to achieve higher levels of component use/reuse than existing approaches for reusing software components. The Active Interface technique we propose enables software components to provide two interfaces --- one for behavior and one for adapting that behavior as needed.We make a distinction between software evolution, where the component designer modifies the software component, and adaptation, where an application builder adapts the component for a different use. We also differentiate adaptation from customization; an end-user customizes a software component by choosing from a fixed set of options. An end-user adapts a software component by writing new code to alter existing functionality.
The optimization of class hierarchy in object-oriented design
Authors: Yuan Xiaodong , Feng Ying
Published: July 2004

Constructing class hierarchies is an important step in object-oriented design, but no formal and effective methods of optimizing class hierarchies were previously established. In this paper, we first divide the relationship between object sets into four categories: inclusion, superposition, separation, and cross. Then the genres of inheritance are discussed from the point of view of object set. Following that, we introduce the concept of maximal uncrossed set used to optimize a class hierarchy. Through finding all of these maximal uncrossed sets, we present the method and steps of constructing a reasonable, clear, and complete class hierarchy. Various representations of inheritance relationship in a class hierarchy diagram and a recursion algorithm to get all the maximal uncrossed sets are also provided in this paper.
Constraint specification for object model of access control based on role
Authors: Han Yan , Chun-Gen Xu , Gong-Xuan Zhang , Feng-Yu Liu
Published: July 2004

Constraint specifications for access control organize a set of constraints to control human-computer interaction for users to perform their duties securely and efficiently. Constraint specifications are imperative for the access control and security management of large and complex multi-user interactive applications. Existing specifications of Role-based Access Control are incomplete and complicated. This paper proposes a framework of well-defined constraint specifications for developers to build application-level access control based on users' roles. They ensure that each role is configured with consistent privileges, each actor is authorized to proper roles and then each actor can activate and play his authorized roles without interest conflicts. These formal specifications are consistent and inferable, complete and simplified, abundant and scalable for diversified multi-user applications.
UML-Based integration testing
Authors: Hartmann Jean , Imoberdorf Claudio , Meisinger Michael
Published: July 2004

Increasing numbers of software developers are using the Unified Modeling Language (UML) and associated visual modeling tools as a basis for the design and implementation of their distributed, component-based applications. At the same time, it is necessary to test these components, especially during unit and integration testing.

At Siemens Corporate Research, we have addressed the issue of testing components by integrating test generation and test execution technology with commercial UML modeling tools such as Rational Rose; the goal being a design-based testing environment.

In order to generate test cases automatically, developers first define the dynamic behavior of their components via UML Statecharts, specify the interactions amongst them and finally annotate them with test requirements. Test cases are then derived from these annotated Statecharts using our test generation engine and executed with the help of our test execution tool. The latter tool was developed specifically for interfacing to components based on COM/DCOM and CORBA middleware.

In this paper, we present our approach to modeling components and their interactions, describe how test cases are derived from these component models and then executed to verify their conformant behavior. We outline the implementation strategy of our TnT environment and use it to evaluate our approach by means of a simple example.
Requirements-based monitors for real-time systems
Authors: Peters Dennis K. , Parnas David L.
Published: July 2004

Before designing safety- or mission-critical real-time systems, a specification of the required behaviour of the system should be produced and reviewed by domain experts. After the system has been implemented, it should be thoroughly tested to ensure that it behaves correctly. This is best done using a monitor, a system that observes the behaviour of a target system and reports if that behaviour is consistent with the requirements. Such a monitor can be used both as an oracle during testing and as a supervisor during operation. Monitors should be based on the documented requirements of the system.

If the target system is required to monitor or control real-valued quantities, then the requirements, which are expressed in terms of the monitored and controlled quantities, will allow a range of behaviours to account for errors and imprecision in observation and control of these quantities. Even if the controlled variables are discrete valued, the requirements must specify the timing tolerance. Because of the limitations of the devices used by the monitor to observe the environmental quantities, there is unavoidable potential for false reports, both negative and positive.

This paper discusses design of monitors for real-time systems, and examines the conditions under which a monitor will produce false reports. We describe the conclusions that can be drawn when using a monitor to observe system behaviour.
Comparison of delivered reliability of branch, data flow and operational testing
Authors: Frankl Phyllis G. , Deng Yuetang
Published: July 2004

Many analytical and empirical studies of software testing effectiveness have used the probability that a test set exposes at least one fault as the measure of effectiveness. That measure is useful for evaluating testing techniques when the goal of testing is to gain confidence that the program is free from faults. However, if the goal of testing is to improve the reliability of the program (by discovering and removing those faults that are most likely to cause failures when the software is in the field) then the measure of test effectiveness must distinguish between those faults that are likely to cause failures and those that are unlikely to do so.
Delivered reliability
was previously introduced as a means of comparing testing techniques in that setting. This paper empirically compares reliability delivered by three testing techniques, branch testing, the all-uses data flow testing criterion, and operational testing. The subject program is a moderate-sized C-program (about 10,000 LOC) produced by professional programmers and containing naturally occurring faults.
A framework for testing database applications
Authors: Chays David , Dan Saikat , Frankl Phyllis G. , Vokolos Filippos I. , Weyuker Elaine J.
Published: July 2004

Database systems play an important role in nearly every modern organization, yet relatively little research effort has focused on how to test them. This paper discusses issues arising in testing database systems and presents an approach to testing database applications. In testing such applications, the state of the database before and after the user's operation plays an important role, along with the user's input and the system output. A tool for populating the database with meaningful data that satisfy database constraints has been prototyped. Its design and its role in a larger database application testing tool set are discussed.
Testability, fault size and the domain-to-range ratio
Authors: Woodward Martin R. , Al-Khanjari Zuhoor A.
Published: July 2004

A number of different concepts have been proposed that, loosely speaking, revolve around the notion of software testability. Indeed, the concept of testability itself has been interpreted in a variety of ways by the software community. One interpretation is concerned with the extent of the modifications a program component requires, in terms of its input and output variables, so that the entire behaviour of the component is observable and controllable. Another interpretation is the ease with which faults, if present in a program, can be revealed by the testing process and the propagation, infection and execution (PIE) model has been proposed as a method of estimating this. It has been suggested that this particular interpretation of testability might be linked with the metric domain-to-range ratio (DRR), i.e. the ratio of the cardinality of the set of all inputs (the domain) to the cardinality of the set of all outputs (the range). This paper reports work in progress exploring some of the connections between the concepts mentioned. In particular, a simple mathematical link is established between domain-to-range ratio and the observability and controllability aspects of testability. In addition, the PIE model is re-considered and a relationship with fault size is observed. This leads to the suggestion that it might be more straightforward to estimate PIE testability by an adaptation of traditional mutation analysis. The latter suggestion exemplifies the main goals of the work described here, namely to seek greater understanding of testability in general and, ultimately, to find easier ways of determining it.
Model checking Java programs (abstract only)
Authors: Dill David
Published: July 2004

Automatic state exploration tools (model checkers) have had some success when applied to protocols and hardware designs, but there are fewer success stories about software. This is unfortunate, since the software problem is worsening even faster than the hardware and protocol problems. Model checking of concurrent programs is especially interesting, because they are notoriously difficult to test, analyze, and debug by other methods.

This talk will be a description of our initial efforts to check Java programs using a model checker. The model checker supports dynamic allocation, thread creation, and recursive procedures (features that are not necessary for hardware verification), and has some special optimizations and checks tailored to multi-threaded Java program. I will also discuss some of the challenges for future efforts in this area.
Improving the precision of INCA by preventing spurious cycles
Authors: Siegel Stephen F. , Avrunin George S.
Published: July 2004

The Inequality Necessary Condition Analyzer (INCA) is a finite-state verification tool that has been able to check properties of some very large concurrent systems. INCA checks a property of a concurrent system by generating a system of inequalities that must have integer solutions if the property can be violated. There may, however, be integer solutions to the inequalities that do not correspond to an execution violating the property. INCA thus accepts the possibility of an inconclusive result in exchange for greater tractability. We describe here a method for eliminating one of the two main sources of these inconclusive results.
CS1
Authors: Marion William
Published: July 2004

At the 1998 SIGCSE Technical Symposium a paper, entitled "Providing Intellectual Focus to CS1/CS2," was presented in which the authors argued for a more intellectually-focused approach to the first-year sequence in an undergraduate computer science program. The central intellectual role in CS1 and CS2 should be: "The study and application of languages and methods for making precise and understandable descriptions of software for human beings and the approach is built around the concepts of systems thinking and mathematical modeling as these principles are manifested in a component-based software paradigm" [12]. Following up on these ideas, the author of the current paper stakes out a particular position concerning one of the two courses, the CS1 course: no matter which software methodology is developed, no matter under which paradigm ideas are presented, no matter which programming language is used there are certain fundamental concepts that ought to be introduced in a first course in a computer science major. Toward this end the author raises and addresses three questions, articulates some goals that are based on answers to the questions and describes the fundamental concepts. In addition, the author indicates how these concepts can be developed in CS 1 irrespective of the methodology, paradigm and language presented.
Teaching computer graphics using Java
Authors: Mukundan R.
Published: July 2004

Java provides most of the primitive functions necessary for implementing advanced graphics algorithms. Being a language that is highly portable and concurrent, Java also has all the capabilities of a powerful general purpose programming language suitable for a wide range of graphics applications. This paper addresses the main issues pertaining to teaching theoretical computer graphics courses, using Java as the language for implementation and project development. The paper also gives a framework of Java classes that can cater to the modeling of three-dimensional objects, transformations, and rendering algorithms.
Curriculum 2001
Authors: Chang Carl , Engel Gerald , King Willis , Roberts Eric , Shackelford Russ , Sloan Robert H. , Srimani Pradip K.
Published: July 2004

The discipline of computing encompasses the understanding, design, and use of computers and computational processes. The breadth of the discipline is emphasized in the following quotation from a report issued by the Computing Sciences Accreditation Board. [1]The discipline ranges from theoretical studies of algorithms and computability to practical problems of implementations in terms of computational hardware and software. Thus, the discipline spans both advancing the fundamental understanding of algorithms and information processes in general as well as the practical design of efficient reliable software and hardware to meet given specification[s] …. [I]t includes theoretical studies, experimental methods and engineering design in all disciplines.Computing draws on the methodologies of both science and engineering. Theoretical work has done much to advance the state of the art. At the same time, computing does not separate the discovery of new scientific knowledge from the application of that knowledge to solve practical problems. The intimate relationship between theory and practice endows the discipline with much of its strength and vitality. This same connection between theory and practice, however, also means that the body of knowledge associated with computing changes very quickly as technology evolves.
A Skeptic Assesses the Net as a Resource for Teaching
Authors: Aiken Robert M.
Published: July 2004

The purpose of the talk (and this paper) is to explore the advantages and disadvantages of providing courses, programs and degrees using On-Line Learning (OLL). It is the author's thesis that, yes, OLL does provide new opportunities for the delivery of education. However, we need to be very careful as to how we use this medium in order not to "reshape" courses which are more effectively taught in other (possibly more traditional) ways nor to embrace this mode of delivery simply for perceived economic gains.The rush of higher education institutions to place courses and programs on the Internet for distance education students raises some very interesting questions concerning their quality and value. The initial development of courses for online learning has been based on text based delivery --- for the most part using traditional lecture notes. The rapid sophistication brought about by html programming, advanced browsers, and template authorware on the one hand, and more sophisticated and powerful hardware and multimedia devices on the other, have permitted great strides in resource integration. Yet, for all of these technological advances, a number of problems still exist. The rest of this paper will explore some of these problems and offer some suggestions for solving them..
Resources for Next Generation Introductory CS Courses
Authors: Bergin Joseph , Kumar Amruth , Proulx Viera K. , McNally Myles , Faulstich Brady Alyce , Mutchler David , Hartley Stephen , Rasala Richard , Kelemen Charles , Ross Rocky , Klassner Frank
Published: July 2004

The ongoing purpose of this working group is to collect, evaluate, and foster the development of resources that might be used in next generation introductory CS courses. Such courses will integrate elements of object-oriented programming and design, program design patterns, concurrency, and event-driven programming. The product of the working group is a web repository that provides resources that might be used in such a course. The site will include sample syllabi, pedagogical patterns, programming and design patterns, course modules, projects, tools and techniques.The URL for the web site is:
http://csis.pace.edu/ ~bergin/iticse99/
Integrating Professionalism and Workplace
Authors: Currie Little Joyce , Granger Mary J. , Boyle Roger , Gerhardt-Powals Jill , Impagliazzo John , Janik Carol , Kubilus Norbert J. , Lippert Susan K. , McCracken W. Michael , Paliwoda Grazyna , Soja Piotr
Published: July 2004

Educators in computing and information technology (CIT) suggest a need for graduates going into the workplace to have a better understanding of professionalism and workplace issues. It is not enough for graduates to have technical capabilities. They must understand many aspects of CIT as a discipline. They should be aware of the various types of CIT educational programs, different job titles and functions, and some aspects of the employment supply and demand. They should be aware of the need for each computing worker to have professional responsibility for their work, and an awareness of the importance of appropriate ethical behavior in the group. They must also have an awareness of the impact of information technology on society as a whole and on individuals, and be prepared to handle a variety of issues arising in the workplace. This paper provides a rationale for the inclusion of professionalism in the CIT curriculum. It focuses on the responsibilities of CIT instructors and provides material to assist carrying out this obligation.
Metrics based asset assessment
Authors: Schmietendorf Andreas , Dumke Reiner , Foltin Erik
Published: July 2004

The re-use of software components during the software development is considered to be an important factor to improve the quality and productivity and thus to reduce the time to market of the final product. In this paper we will present a proposal for a description model for re-usable components. We will also present the results of case studies concerned with both telecom specific and ,,generic" IT-components. These components have been examined using the description model and a further set of (empirical) criterions. Based on the results a model concept for the empirical assessment of JavaBeans, which is currently under development, is presented..