bluuebunny/crossref_metadata_2025 huggingface dataset:
The conversational classroom
Authors: Waite William M. , Jackson Michele H. , Diwan Amer
Published: July 2004

Concepts taught in large, lower-division computer science courses are carefully explained in standard textbooks. Thus we hypothesized that the classroom experience should not consist primarily of a restatement of those explanations by the professor. Instead, it should provide an opportunity for the students to learn through a process of conversation among themselves and with the professor. We were able to establish such a process in a sophomore-level course with an enrollment of 116 students. This change led to a doubling of the percentage of A and A- grades compared to historical values.
JAWAA
Authors: Akingbade Ayonike , Finley Thomas , Jackson Diana , Patel Pretesh , Rodger Susan H.
Published: July 2004

We present JAWAA 2.0, a scripting language for creating animations easily over the web. JAWAA includes primitives, easy creation of data structures and operations on these structures, and an editor for easy creation of complex objects. We show how to use JAWAA in a range of computer science courses including CS 0, CS 1, CS 2 and advanced courses. Instructors can quickly build animations for demos in lecture, and students can enhance their programming projects with an animation.
Puzzles and games
Authors: Hill John M. D. , Ray Clark K. , Blair Jean R. S. , Carver Curtis A.
Published: July 2004

Because students have different learning styles, it's important to incorporate multiple teaching techniques into the classroom experience. One such technique is the use of puzzles and games in the classroom to reinforce the learning objectives. Many topics in Computer Science are well suited for coverage in such a game. Several in-class puzzles and games have been used in the Computer Science program at this institution in recent years. In basic and advanced courses, simple crossword puzzles reinforce terminology and
Jeopardy!
®-style games help students master material with short answers. In the most recent iteration of the
Operating Systems
course, a
BattleThreads
game and a
Process State
Transition game helped students appreciate different approaches to process and thread management. The latter two games have been assessed for their effectiveness, providing several insights into what makes a good in-class game for teaching operating systems concepts, and how the existing games can be improved.
Teaching objects-first in introductory computer science
Authors: Cooper Stephen , Dann Wanda , Pausch Randy
Published: July 2004

An objects-first strategy for teaching introductory computer science courses is receiving increased attention from CS educators. In this paper, we discuss the challenge of the objects-first strategy and present a new approach that attempts to meet this challenge. The new approach is centered on the visualization of objects and their behaviors using a 3D animation environment. Statistical data as well as informal observations are summarized to show evidence of student performance as a result of this approach. A comparison is made of the pedagogical aspects of this new approach with that of other relevant work.
Jeroo
Authors: Sanders Dean , Dorn Brian
Published: July 2004

Jeroo is a tool that has been developed to help students in beginning programming courses learn the semantics of fundamental control structures, learn the basic notions of using objects to solve problems, and learn to write methods that support a functional decomposition of the task. Jeroo is similar to Karel the Robot and its descendants, but has a narrower scope than Karel's descendants and has a syntax that provides a smoother transition to either Java or C++. Jeroo has been class tested at Northwest Missouri State University, and has proven to be an effective tool for working with students in a beginning programming class. Jeroo and user documentation are available at http://www.nwmissouri.edu/~sanders/Jeroo/Jeroo.html.
Language-independent interactive data visualization
Authors: Campbell Alistair E. R. , Catto Geoffrey L. , Hansen Eric E.
Published: July 2004

We introduce the
Language-Independent Visualization Environment (LIVE)
as a system for the visualization and manipulation of data structures and the computer programs that create and operate on them.LIVE interprets arbitrary programs containing arbitrary data structure definitions, showing diagrammatically the data that the process generates.It is language-independent in that a single program can be visualized in the syntax of multiple languages. LIVE is interactive in that not only does it show the effects of statements immediately as they occur at runtime, but it also generates new program source code automatically when the user manipulates the data on the screen. We anticipate that this tool will be most useful in a pedagogical setting such as a CS2 or data structures course, particularly with the introduction of pointers and linked structures.
CS girls rock
Authors: Graham Sandy , Latulipe Celine
Published: July 2004

Declining female enrollment in undergraduate Computer Science programs is a serious problem. Part of the solution lies in retaining more of the female students currently enrolled; even more important, however, is increasing initial enrollment. Many believe lack of interest to be rooted in stereotypes of computer science formed early in high school: that it is a boring subject, devoid of interesting applications and stimulating only to 'geeks'. To attract high school females to CS, and to determine whether early exposure to the interesting breadth of CS and its applications might ameliorate such attitudes, a week-long Computer Science Seminar for Grade 9 and 10 girls was held at the University of Waterloo. The seminar consisted of lectures, labs and activities chosen to demonstrate the breadth of CS and to dispel the negative stereotypes. Pre- and post-seminar surveys indicate a substantial increase in interest, translating directly into increased desire to take high school CS courses.
Mental models of recursion
Authors: Götschi Tina , Sanders Ian , Galpin Vashti
Published: July 2004

Recursion is a fundamental concept in Computer Science. A student's knowledge of recursion can be termed their
mental model
of recursion. A student's mental model is
viable
if it allows them to accurately and consistently represent the mechanics of recursion. Non-viable mental models are constructed if students have misconceptions about the mechanisms of recursion or have misconceptions about concepts fundamental to recursion. This paper presents a study of the mental models of recursion that first year students at the University of the Witwatersrand have constructed in 2000, 2001 and 2002. It was found that while the majority of students constructed the viable
copies
model, many non-viable models such as the
looping
,
active
,
step
,
magic
,
return-value
and various
odd
models were also constructed. Identifying the models that students have can allow lecturers to target individual students' specific problems and analysis of the models can provide insight into learning.
Work experience vs. co-operative education program
Authors: Surakka Sami , Malmi Lauri
Published: July 2004

In this paper, we describe a typical Finnish work experience program in computer science and engineering. The program is compulsory for all students. It is cheap, moderately controlled, and unstructured. The feedback from the program is compared to the feedback from a highly structured and competition-based co-operative education program in the USA, which can be seen as a kind of opposite to the Finnish program. One might expect the feedback from a cheap and unstructured program not to be very good. However, the feedback from both programs was positive.
Why computer science students need math
Authors: Beaubouef Theresa
Published: July 2004

Too many students enter the field of computer science with high aspirations but poor math skills. These students often do not realize the significance of mathematics in computer science. This paper discusses several relevant areas of computer science and explains why computer science students need math in order to master the material taught in these courses and to eventually find success as a computing professional.
Binomial coefficient computation
Authors: Manolopoulos Yannis
Published: July 2004

Binomial coefficient computation, i.e. the calculation of the number of combinations of n objects taken k at a time, C(n,k), can be performed either by using recursion or by iteration. Here, we elaborate on a previous report [6], which presented recursive methods on binomial coefficient calculation and propose alternative efficient iterative methods for this purpose.
LL parsing, LR parsing, complexity, and automata
Authors: Taylor R. Gregory
Published: July 2004

It is well known that pushdown-stack automata find application within the syntactic analysis phase of compilation. Nonetheless, in most compiler design textbooks the relation between popular parsing algorithms and the theory of deterministic pushdown-stack automata remains implicit. We show that it is not difficult to implement these algorithms as deterministic automata. These implementations in turn yield instructive time/space analyses of the implemented algorithms.
Towards an integrated learning laboratory environment for first-year computer science students
Authors: Riordan Denis
Published: July 2004

This paper describes an evolving attempt to provide an integrated learning laboratory environment (ILLE) to enhance the learning goals and strategies for first-year computer science students using Java as a first language. The proposed ILLE models a real computer-learning laboratory in which instructors walk around watching and helping students on request. In essence, the system consists of a Java development environment centered round a live communicator with a facility for an instructor to focus and work on the desk top of a particular student. The system is written in 4000 lines of Java and runs in exactly the same way on Windows, UNIX and MacOS. The ILLE gathers usage information that is being used to improve the learning for first year students. It has been used twice with large first year classes. Examples show how extracts from dialogue files enhanced the ILLE.
Predictors of success and failure in a CS1 course
Authors: Rountree Nathan , Rountree Janet , Robins Anthony
Published: July 2004

We present the results of a survey that focuses on the backgrounds and expectations of a group of CS1 students in the first weeks of semester. When comparing their survey answers to their final grades on the course, we saw some surprising things: the group which indicated an intention to continue in computer science did no better than any other, and the strongest single indicator of success seems to be "expecting to get an A from the course."
An experience in integrating automated unit testing practices in an introductory programming course
Authors: Barriocanal Elena García , Urbán Miguel-Ángel Sicilia , Cuevas Ignacio Aedo , Pérez Paloma Díaz
Published: July 2004

Unit testing is one of the core practices in the Extreme Programming lightweight software development method, and it is usually carried out with the help of software frameworks that ease the construction of test cases as an integral part of programming tasks. This work describes our first results in studying the integration of automated unit testing practices in conventional 'introduction to programming' laboratories. Since the work used a classical procedural language in the course's assignments, we had to design a specific testing framework called tpUnit. The results of the experiment points out that a straightforward approach for the integration of unit testing in first-semester courses do not result in the expected outcomes in terms of student's engagement in the practice.
Implications of MBTI in software engineering education
Authors: Capretz L. F.
Published: July 2004

A number of approaches exist to aid the understanding of individual differences and their effects on teaching and learning. Educators have been using the Myers-Briggs Type Indicator (MBTI) to understand differences in learning styles and to develop teaching methods that cater for the various personality styles. Inspired by the MBTI, we developed a range of practices for effective teaching and learning in a software engineering course. Our aim is to reach every student, but in different ways, by devising various teaching approaches.
Gender and information technology
Authors: Cukier Wendy , Shortt Denise , Devine Irene
Published: July 2004

This paper examines implications of definitions of information technology to women's participation in the industry and in academe. It is exploratory only, based on a review of selected government and industry reports and data related to IT education and the profession. However, it argues that there is evidence to suggest that discourse related to information technology has the effect of excluding women and multi-disciplinary perspectives. On the one hand, there is considerable evidence that the IT industry and skills it demands are multi-disciplinary and that many people working in the industry, particularly women, come from a variety of disciplines. On the other hand, despite the evidence of the multidimensional nature of IT, the impact of convergence, the importance of matching IT solutions to user needs and so on, a very narrow definition of IT dominates the discourse. This definition equates IT and IT professionals with computer science and engineering, disciplines which are predominately male. The result, then of this narrow definition is to marginalize women and their contributions. This is a pattern that has been observed with the development of other disciplines such as medicine. Not only does the narrowing of the definition of Information Technology tend to exclude and devalue the contribution of women but it also results in marginalization of other disciplines that would bring more "neutral" or "critical" perspectives to bear on technology. Thus the exclusion of multiple disciplines and women may contribute to poor technology decision-making at the societal and organizational level.
A complete package for introducing computer science
Authors: Brillinger P. C. , Cowan D. D.
Published: July 2004

Faced with the challenge of teaching large numbers of students without sacrificing quality, we have developed a complete "package" for teaching introductory computer science. This package consists of textbooks, notes, problem sets, labtutorial arrangements, instructional software, and visual aids for lectures, all developed at the University of Waterloo.The textbooks are "FORTRAN IV WITH WATFOR AND WATFIV" and "AN INTRODUCTION TO THE SPECTRE COMPUTER". The first text provides a thorough introduction to FORTRAN programming, whereas the second describes a hypothetical computer used for teaching purposes to introduce concepts in assembly language programming and machine organization. Notes supplement the texts by covering elementary ideas from boolean algebra, switching and automata theory, and hardware design. Consequently, we endeavour in this course to introduce students to various aspects of computer science, not just programming.Nevertheless, programming is a major part of computer science, and we feel that considerable hands-on experience is essential to a student's education. We provide unlimited access to the computer for all students with a turnaround time between one and two minutes for small jobs. This service is made possible by our fast FORTRAN compiler, WATFOR, which permits the computing centre to process between 3000 and 7000 undergraduate jobs daily on an IBM S/360 model 75. In addition, we simulate the SPECTRE machine via an interpreter, also with unlimited access to students.For lectures, we have prepared substantial lecture material in a set of 35 mm slides. We feel that this mode of presentation has numerous advantages for a large multi-section course, some of which are better visibility for students, easy review possibilities, lecturer cues, uniformity throughout the various sections, and improvement of presentation by new and inexperienced lecturers.This course is offered to approximately 1300 students yearly at Waterloo. Each student has two hours of lectures per week, as well as biweekly tests and problem sessions in alternate weeks. In order to assist us in the development of our package, we try to obtain as much student feedback as possible through the distribution of an extensive questionnaire to all students taking the course.
Course and program descriptions
Authors: Nartker T. A.
Published: July 2004

At the current time, there is intense interest in Computer Science Education within the academic community. Symposia have been and are being held (4), recommendations for degree programs have been made (1, 3), a special interest group within ACM (SIGCSE) is growing and discussion at national meetings is lively. Little information is available, however, on what specific curriculum are being offered. This report presents the curriculum leading to a Bachelor of Science degree in Computer Science which is currently offered at the New Mexico Institute of Mining and Technology. The curriculum reflects our prejudices and local constraints. Because Computer Science involves such a wide spectrum of subject matter and because New Mexico Tech is a small college (total enrollment is about 800 students), the report specifically addresses the problem of building a viable curriculum within constraints imposed by the small college environment. The author invites any questions, comments or criticism from readers concerned about Computer Science Education.
Report on the 2
nd
international summit on software engineering education, co-located with ICSE2003
Authors: Thompson J. Barrie , Edwards Helen M.
Published: July 2004

Work is being undertaken to produce the Software Engineering volume for the ACM/IEEE-CS Computing Curriculum. The prime aim of this Summit was to provide a forum in which early draft chapters of the Software Engineering volume could be used and evaluated by a peer group of academics and industrialists. The objectives and expected outputs for the Summit are outlined and an overview of the presentations that were made is given. The operation and results of a series of participative activities are then described. These were concerned with evaluating the draft chapters and in particular the proposed guidelines for developing Software Engineering academic programmes. Information is also presented on a proposal to restructure the guidelines. Finally some general conclusions are presented.
An XML vocabulary for error message documentation
Authors: Cowan Charles
Published: July 2004

The documentation of software error messages has traditionally been a laborious and error-prone process. The documentation has been produced in a variety of file formats, either manually, or using special software to extract the desired information. Now that Extensible Markup Language (XML) has become a standard data format, it makes sense to store error messages and all related data in an XML source document. You can author the documents using standard tools, and software applications can extract the messages and other information from the document. Also, you can use standard XML technologies and tools to validate the XML documents and transform them into appropriate formats. Using the XML approach, you ensure consistency between your error message documentation and information displayed by software applications. This article describes an XML vocabulary for error message documentation defined by an XML Schema document. It illustrates how the use of an XML Schema document provides great flexibility for error message documentation, and powerful mechanisms for constraining document content. The article also gives examples from instance documents, and discusses how internationalized versions of error message documents can be handled.
Understanding process and the quest for deeper questions in software engineering research
Authors: Osterweil Leon J.
Published: July 2004

This paper provides a brief summary of some overall currents and directions in my research with a particular emphasis on my work in the area of process. Using this perspective as a basis, the paper suggests the importance of using the challenge of grappling with hard technical problems as a basis for searching for deeper questions. The search for deep and enduring problems at the core of our discipline is rewarding for individual researchers and could provide substance, direction, purpose, and credibility for the community.
Behaviour model elaboration using partial labelled transition systems
Authors: Uchitel Sebastian , Kramer Jeff , Magee Jeff
Published: July 2004

State machine based formalisms such as labelled transition systems (LTS) are generally assumed to be complete descriptions of system behaviour at some level of abstraction: if a labelled transition system cannot exhibit a certain sequence of actions, it is assumed that the system or component it models cannot or should not exhibit that sequence. This assumption is a valid one at the end of the modelling effort when reasoning about properties of the completed model. However, it is not a valid assumption when behaviour models are in the process of being developed. In this setting, the distinction between proscribed behaviour and behaviour that has not yet been defined is an important one. Knowing where the gaps are in a behaviour model permits the presentation of meaningful questions to stakeholders, which in turn can lead to model exploration and thus more comprehensive descriptions of the system behaviour. In this paper we propose using partial labelled transition systems (PLTS) to capture what remains to be defined of the system behaviour. In the context of scenario synthesis, we show that PLTSs can be used to support the iterative incremental elaboration of behaviour models.
Designing and implementing a family of intrusion detection systems
Authors: Vigna Giovanni , Valeur Fredrik , Kemmerer Richard A.
Published: July 2004

Intrusion detection systems are distributed applications that analyze the events in a networked system to identify malicious behavior. The analysis is performed using a number of attack models (or signatures) that are matched against a specific event stream. Intrusion detection systems may operate in heterogeneous environments, analyzing different types of event streams. Currently, intrusion detection systems and the corresponding attack modeling languages are developed following an
ad hoc
approach to match the characteristics of specific target environments. As the number of systems that have to be protected increases, this approach results in increased development effort. To overcome this limitation, we developed a framework, called STAT, that supports the development of new intrusion detection functionality in a modular fashion. The STAT framework can be extended following a well-defined process to implement intrusion detection systems tailored to specific environments, platforms, and event streams. The STAT framework is novel in the fact that the extension process also includes the extension of the attack modeling language. The resulting intrusion detection systems represent a software family whose members share common attack modeling features and the ability to reconfigure their behavior dynamically.
A family of test adequacy criteria for database-driven applications
Authors: Kapfhammer Gregory M. , Soffa Mary Lou
Published: July 2004

Although a software application always executes within a particular environment, current testing methods have largely ignored these environmental factors. Many applications execute in an environment that contains a database. In this paper, we propose a family of test adequacy criteria that can be used to assess the quality of test suites for database-driven applications. Our test adequacy criteria use dataflow information that is associated with the entities in a relational database. Furthermore, we develop a unique representation of a database-driven application that facilitates the enumeration of database interaction associations. These associations can reflect an application's definition and use of database entities at multiple levels of granularity. The usage of a tool to calculate intraprocedural database interaction associations for two case study applications indicates that our adequacy criteria can be computed with an acceptable time and space overhead.
Consistency techniques for interprocedural test data generation
Authors: Sy Nguyen Tran , Deville Yves
Published: July 2004

This paper presents a novel approach for automated test data generation of imperative programs containing
integer
,
boolean
and/or
float
variables. It extends our previous work to programs with procedure calls and arrays. A test program (with procedure calls) is represented by an Interprocedural Control Flow Graph (ICFG). The classical testing criteria (statement, branch, and path coverage), widely used in unit testing, are extended to the ICFG. For path coverage, the specified path is transformed into a
path constraint
. Our previous consistency techniques, the core idea behind the solving of path constraints, have been extended to handle procedural calls and operations with arrays. For statement (and branch) coverage, paths reaching the specified node or branch are dynamically constructed. The search for suitable paths is guided by the interprocedural control dependences of the program. The search is also pruned by a new specialized consistency filter. Finally, test data are generated by the application of the proposed path coverage algorithm. A prototype has been implemented. Experiments show the feasibility of the approach.
Regression testing of GUIs
Authors: Memon Atif M. , Soffa Mary Lou
Published: July 2004

Although graphical user interfaces (GUIs) constitute a large part of the software being developed today and are typically created using rapid prototyping, there are no effective regression testing techniques for GUIs. The needs of GUI regression testing differ from those of traditional software. When the structure of a GUI is modified, test cases from the original GUI are either reusable or unusable on the modified GUI. Since GUI test case generation is expensive, our goal is to make the unusable test cases usable. The idea of reusing these unusable (
a.k.a. obsolete
) test cases has not been explored before. In this paper, we show that for GUIs, the unusability of a large number of test cases is a serious problem. We present a novel GUI regression testing technique that first automatically determines the usable and unusable test cases from a test suite after a GUI modification. It then determines which of the unusable test cases can be repaired so they can execute on the modified GUI. The last step is to repair the test cases. Our technique is integrated into a GUI testing framework that, given a test case, automatically executes it on the GUI. We implemented our regression testing technique and demonstrate for two case studies that our approach is effective in that many of the test cases can be repaired, and is practical in terms of its time performance.
Context-sensitive slicing of concurrent programs
Authors: Krinke Jens
Published: July 2004

Program slicing is a technique to identify statements that may influence the computations at other statements. Precise slicing has been shown to be undecidable for concurrent programs. This work presents the first context-sensitive approach to slice concurrent programs accurately. It extends the well known structures of the control flow graph and the (interprocedural) program dependence graph for concurrent programs with interference. This new technique does not require serialization or inlining.
Fluent model checking for event-based systems
Authors: Giannakopoulou Dimitra , Magee Jeff
Published: July 2004

Model checking is an automated technique for verifying that a system satisfies a set of required properties. Such properties are typically expressed as temporal logic formulas, in which atomic propositions are predicates over state variables of the system. In event-based system descriptions, states are not characterized by state variables, but rather by the behavior that originates in these states in terms of actions. In this context, it is natural for temporal formulas to be built from atomic propositions that are predicates on the occurrence of actions. The paper identifies limitations in this approach and introduces "fluent" propositions that permit formulas to naturally express properties that combine state and action. A fluent is a property of the world that holds after it is initiated by an action and ceases to hold when terminated by another action. The paper describes an approach to model checking fluent-based linear-temporal logic properties, with its implementation and application in the LTSA tool.
Bogor
Authors: Robby  , Dwyer Matthew B. , Hatcliff John
Published: July 2004

Model checking is emerging as a popular technology for reasoning about behavioral properties of a wide variety of software artifacts including: requirements models, architectural descriptions, designs, implementations, and process models. The complexity of model checking is well-known, yet cost-effective analyses have been achieved by exploiting, for example, naturally occurring abstractions and semantic properties of a target software artifact. semantic properties of target software artifacts. Adapting a model checking tool to exploit this kind of
domain knowledge
often requires in-depth knowledge of the tool's implementation.We believe that with appropriate tool support, domain experts will be able to develop efficient model checking-based analyses for a variety of software-related models. To explore this hypothesis, we have developed Bogor, a model checking framework with an extensible input language for defining domain-specific constructs and a modular interface design to ease the optimization of domain-specific state-space encodings, reductions and search algorithms. We present the pattern-oriented design of Bogor and discuss our experiences adapting it to efficiently model check Java programs and event-driven component-based designs.
Protecting C programs from attacks via invalid pointer dereferences
Authors: Yong Suan Hsi , Horwitz Susan
Published: July 2004

Writes via unchecked pointer dereferences rank high among vulnerabilities most often exploited by malicious code. The most common attacks use an unchecked string copy to cause a buffer overrun, thereby overwriting the return address in the function's activation record. Then, when the function "returns", control is actually transferred to the attacker's code. Other attacks may overwrite function pointers, setjmp buffers, system-call arguments, or simply corrupt data to cause a denial of service.A number of techniques have been proposed to address such attacks. Some are limited to protecting the return address only; others are more general, but have undesirable properties such as having a high runtime overhead, requiring manual changes to the source code, or forcing programmers to give up control of data representations and memory management.This paper describes the design and implementation of a security tool for C programs that addresses all these issues: it has a low runtime overhead, does not require source code modification by the programmer, does not report false positives, and provides protection against a wide range of attacks via bad pointer dereferences, including but not limited to buffer overruns and attempts to access previously freed memory. The tool uses static analysis to identify potentially dangerous pointer dereferences, and memory locations that are legitimate targets of these pointers. Dynamic checks are then inserted; if at runtime the target of an unsafe dereference is not in the legitimate set, a potential security violation is reported, and the program is halted.
Tracking pointers with path and context sensitivity for bug detection in C programs
Authors: Livshits V. Benjamin , Lam Monica S.
Published: July 2004

This paper proposes a pointer alias analysis for automatic error detection. State-of-the-art pointer alias analyses are either too slow or too imprecise for finding errors in real-life programs. We propose a hybrid pointer analysis that tracks actively manipulated pointers held in local variables and parameters accurately with path and context sensitivity and handles pointers stored in recursive data structures less precisely but efficiently. We make the unsound assumption that pointers passed into a procedure, in parameters, global variables, and locations reached by applying simple access paths to parameters and global variables, are all distinct from each other and from any other locations. This assumption matches the semantics of many functions, reduces spurious aliases and speeds up the analysis.We present a program representation, called IPSSA, which captures intraprocedural and interprocedural definition-use relationships of directly and indirectly accessed memory locations. This representation makes it easy to create demand-driven path-sensitive and context-sensitive analyses.We demonstrate how a program checker based on IPSSA can be used to find security violations. Our checker, when applied to 10 programs, found 6 new violations and 8 previously reported ones. The checker generated only one false warning, suggesting that our approach is effective in creating practical and easy-to-use bug detection tools.
EFFICIENT
Authors: Eshuis Rik , Brimont Pierre , Dubois Eric , Grégoire Bertrand , Ramel Sophie
Published: July 2004

ebXML is becoming the new international standard for the specification and deployment of complex B2B transactions over the internet. ebXML transactions are inherently distributed, involving many actors exchanging XML messages with each other according to complex flows and rules. This complexity hampers validation of the correctness of a modelled business transaction by business experts. To alleviate this problem, we have developed a tool set, consisting of a CASE tool for modelling ebXML transactions and an animator for validating the modelled transactions. At the specification level, the main UML models used are class diagrams to model messages and an activity diagram to model the global flow of the messages that are exchanged by the actors (companies). The animator is internet-based, thus supporting distributed animation of an ebXML transaction. The animator checks business rules on the messages exchanged during animation. Moreover, the animator annotates messages with possible responses. Heart of the animator is a workflow engine that can read workflow descriptions in XPDL. The animator is configured automatically from the UML specification models. We illustrate the whole approach on a real-life example.
Gravity
Authors: Hall Richard S. , Cervantes Humberto
Published: July 2004

This paper describes a project, called Gravity, that is providing support for building client-side applications out of dynamically available building blocks. The purpose behind this work is not only to deal with real-world issues already facing developers and end-users, but to also work toward a grander vision. In this vision, applications are built using context-aware architectures, meaning that context (e.g., location, environment, user task) is used as a filter to determine which building blocks are relevant to the application at any given time. The main concept underlying this vision is dynamically available building blocks, i.e., building blocks that can appear or disappear at any time. The Gravity technology described in this paper is a starting point for such research.
Accreditation in the computing sciences (Panel Session)
Authors: Cain Tom , Davida George , Engel Gerald L. , Frederick Terry J. , Gibbs Norman E. , Dalphin John F. , Mulder Michael C.
Published: July 2004

A joint task force of the ACM and the IEEE Computer Society is meeting regularly to discuss issues relating to accreditation or approval in the computing sciences. In addition to considering various mechanisms to implement the important qualitative review and certification, the Joint Committee is developing a preliminary set of Computer Science Program requirements.

Increasing requests are being made to the professional societies to provide guidance in computer science programs. While certain guidance and evaluation mechanisms exists, and agencies to administer them, these tend to be directed to specialized programs and the field is so broad that a wider view must be taken. It is estimated that as many as 500 programs not presently served by existing mechanisms and agencies would benefit from such guidance.

This panel will discuss some of the issues relating to implementation of accreditation/approval as well as quantitative criteria for computer science programs that provide competency in the profession. Audience participation and discussion will be encouraged.
An upper level computer science curriculum
Authors: Chua Y. S. , Winton C. N.
Published: July 2004

In response to national curricular trends, the computer science curriculum at the University of North Florida has undergone three iterations since its inception in 1972. Experiences with the development of the North Florida curriculum coupled with recent exposure to the current thinking of the IEEE-CS Curriculum Committee motivate this paper.

The curriculum as outlined in this paper owes its origins to the earlier ACM and IEEE-CS model curricula.
A master's degree in school computer studies
Authors: Heeler Phillip J.
Published: July 2004

Several papers have been written about the shortage of knowledgeable computer science teachers at the secondary and junior college level. Additional reports have been written describing workshops, courses, and various other methods to help reduce this shortage. See for example papers by Moursund, Dennis, Piorot and others in various publications by ACM and the proceedings of recent National Educational Computing Conferences.(l,2)

Very few papers have reported on the existence of degree programs for teachers who are interested in developing the necessary background to teach computer science. Even fewer master's degree programs exist to help train teachers in computer science education. Moursund has described the master's degree at Oregon(3), Lykos has established a degree at Illinois Institute of Technology, and the University of Illinois has a degree for teachers.(2)

This paper describes a unique master's degree program at Northwest Missouri State University. Details are given on the development and present status of the program. Also, several suggestions are indicated for possible future directions for such a program.
Crisis in computer education
Authors: Chand Donald
Published: July 2004

(This paper has been accepted for publication in the Proceedings, but the photo-ready form was not delivered in time. Copies of the paper should be available upon request at the presentation.)
An interactive system for teaching input processes in simulation
Authors: Nygard Kendall E. , Iyengar Ashok K.
Published: July 2004

In this paper a fully interactive software system(SAGIPIS), which carries out data analysis, parameter estimation and process generation is discussed.
Database courses with realistic student projects (Panel Session)
Authors: Driscoll James R. , Honkonen Pentti A. , Shay William , Peck John C.
Published: July 2004

This session will consist of a panel discussion of courses in DBMS which involve student projects using commercially available database management systems. A list of panelists and a synopsis of their topics follows.

John C. Peck, Chairman

Clemson University has used IDMS (a network model by Cullinane Database Systems, Inc.) for the last 8 years in the senior level introductory course in database management. Although all three popular models (network, hierarchical, and relational) are covered in the course a team project (3 or 4 member teams) using IDMS in an online environment is assigned to reinforce the ideas central to all three models. The pros and cons of using large mainframes for such a course are discussed.

James R. Driscoll

The University of Central Florida has undertaken a project to implement fundamental versions of all three popular DBMS models on low-end microcomputer configurations. Dr. Driscoll will discuss the development of RQL (Relational Query Language) and RMS (Relational Menu Systems) which are used at UCF.

Pentti A. Honkonen

Georgia State University has access to three database management systems for its course in DBMS. Dr. Honkonen will compare the Instructional Information Management System, Univac's DMS/90 and The Relational Information Management Systems (RIMS) as they pertain to instructional use in a university environment.

William Shay

The University of Wisconsin at Green Bay offers a project-oriented course in DBMS utilizing a CODASYL type DBMS from Xerox called the Extended Data Management System (EDMS). In this course each student designs, loads, and processes against a real database. The nature of the project and the experiences encountered during the past 4 years the course has been taught will be discussed.
Using generalized programs in the teaching of computer science
Authors: Peterson Gerald
Published: July 2004

Courses in Computer Science have undergone significant improvement during the last few years. This improvement has resulted from the introduction of guiding principles such as structured programming and top-down design. Unfortunately, even with the use of these principles, buggy programs are commonplace. More guiding principles are needed.

This paper introduces the concept of generalized programs and described how they may be used as a guide in the creation of correct computer programs. The method is discussed as it relates to a first course in Computer Science, but the idea could be applicable elsewhere in the curriculum. Basically, the idea is to partition the problems usually solved in the first course into groups such that the programs for solving the problems in each group will have common features. It was not found possible to find such a group for
every
problem, but a majority of the problems in the first course could be grouped in this manner. For each group a generalized program is written which captures the common features of the group. When given a problem to solve, if the student can ascertain the group to which it belongs, then the generalized program for this group will give guidance for programming the solution.
Organization of programming languages for business information systems majors
Authors: Cassel Lillian N.
Published: July 2004

The course CS8 “Organization of Programming Languages” of Curriculum '78 is presented in the context of a program for Business Information Systems at a small business college. The applicability of this course to the Information Systems curriculum is considered. It is asserted that the successful inclusion of this course suggests the desirability of including the other core computer science material, as defined in Curriculum '78, in a program for Information Systems.
A proposed secondary education computer science curriculum
Authors: Thorpe Stephen W. , Amer Paul D.
Published: July 2004

(This paper has been accepted for publication in the Proceedings, but the photo-ready form was not delivered in time. Copies of the paper should be available upon request at the presentation.)
Personal computer networks and graphical animation
Authors: Brown Marc , Meyrowitz Norman
Published: July 2004

This paper examines how progress in computer hardware and software may be applied to solve several serious problems in teaching computer science courses. It is concerned primarily with two such problems: 1) the lack of immediate reinforcement of computing concepts because of long delays between learning and practice, and 2) the difficulty instructors have motivating and explaining complex topics with currently available instruction tools and techniques. The paper first reviews the involvement of educational institutions in the evolution of computing. It then briefly surveys recent experiments in powerful personal computing. It describes an experiment in the application of new personal computer technology at Brown University which addresses the two educational problems noted above. It then outlines in detail the initial courseware for the environment. Finally, it discusses what changes in pedagogy will be needed to make such technology usable on a wide-scale.
Goals for computer science education in the 1980s
Authors: Shaw Mary
Published: July 2004

The nature of computing, and hence of computer science, is changing rapidly. Many topics that now seem interesting will be obsolete or irrelevant within ten years, and our perspective on other topics will change. If a curriculum designed now is to remain effective through 1990 or beyond, we must try to understand the forces that are shaping the field and to anticipate the roles that computing and computer science will play in the future.

At Carnegie-Mellon, a group of eight faculty and graduate students is designing a new undergraduate computer science curriculum. We began by examining the trends that will affect the field over the next decade and the new phenomena and issues that may arise. From this basis we are developing a new curriculum without prior assumptions drawn from existing curricula. In this talk I will discuss our view of current trends in computer science and the roles that colleges and universities must play over the next decade.
Maniac
Authors: Fletcher G. Yates , Hodges Larry F. , Worth Stephen G.
Published: July 2004

The vast amount of machine-dependent details which must be covered concurrently with general architecture and assembly language concepts often hinder the student from assimilating the main objectives of the ACM CS 3 course. Current instructional strategies are ineffective in building a comprehensive framework of basic concepts from which machine and programming details can be understood. A new approach is required if our students are to complete this course with an understanding of some of the larger issues of computer architecture rather than scattered details of some particular assembly language.

In this paper we present both an instructional tool and a corresponding instructional strategy for the CS 3 course. The tool, MANIAC, is a simulated machine which is used to introduce students to the basic concepts of computer architecture and assembly language. The strategy, the preliminary machine approach, is designed to integrate the use of MANIAC with the teaching of the architecture and assembly language of an actual machine such as the PDP-11 or IBM/370.
ACM doctoral dissertation award
Authors: Bell Gwen
Published: July 2004

Dr. Bell is director of The Computer Museum in Marlboro, Mass., a memeber of the Charles Babbage Institute Program Committee and an editorial board member for the Annals of the History of Computing. As director of The Computer Museum since 1980, she has interpreted computer history via exhibitions, programs and public speeches.
Inferring cognitive focus from students' programs
Authors: Rogers Jean B.
Published: July 2004

Programs written by students in an introductory Computer Science course were analyzed and patterns abstracted from them. These patterns include style of modularization, choice of constructs, choice of vocabulary, and style of communication through user-interaction and documentation. Individual characteristics of the students, such as their focus on detail or on aggregate conceptual units, their manner of organizing knowledge, and their perception of the purpose of computer programs was compared with the patterns in the students' programs, with tentative relationships being identified.
Use of a syntax checker to improve student access to computing
Authors: Fox Christopher , Lancaster Ronald L.
Published: July 2004

This paper describes the design of a syntax checker which is being used to provide enhanced access to computing for introductory programming students. Syntax errors are detected on a microcomputer prior to submission of the job to the mainframe for execution. Advantages of this approach for the students, the instructor, and for the computer center are discussed.