bluuebunny/crossref_metadata_2025 huggingface dataset:
Educating the next generation of information specialists
Authors: Williams Kathleen A.
Published: July 2004

This collaborative learning pilot project was in support of a major revision of computer information science (CIS)-oriented curricula. The entire CIS project, sponsored by the National Science Foundation (NSF), will develop detailed curriculum guidelines, supporting laboratory material, original learning and teaching paradigms, and methodology for dealing with complex information systems. The pilot project addressed many of the issues in the latter two areas: new paradigms for teaching and learning and dealing with complex information systems.Specifically, the many aspects of having CIS students gain experience with large information systems problems in industry environment are addressed. This pilot project was developed and supported by Boeing Information & Support Services and the University of Washington Department of Computer Science and Engineering (UWCSE).
Strategic directions in computer science education (panel)
Authors: Wegner Peter , Roberts Eric , Rada Roy , Tucker Allen B.
Published: July 2004

This panel will discuss major issues and challenges in computer science education across a wide range of institutions. It originates from a report developed by the Education Working Group of the Strategic Directions in Computing Research (SDCR) Workshop. That report appears in its entirety in the
ACM Computing Surveys
issue [Wegner96] which is distributed to all attendees to this SIGCSE 97 conference.) In this panel, we will discuss the general aims and accomplishments of the SDCR conference, highlighting the specific recommendations of the Education Working Group. We will outline ideas for improving the quality and effectiveness of computer science programs at the undergraduate, graduate, and K-12 levels. We will also argue for the creation of a Resource Center for developing and distributing computer science and engineering curricular materials, including the idea of developing a "Virtual Computing University."
The use of the WWW to support distance learning through NTU
Authors: Dankell Douglas D. , Hearn James
Published: July 2004

The teaching of graduate level computer science courses can be a challenging task. The students are confronted with a wealth of complex material with, often, higher expectations by their instructors on their performance. Distance education of students employed full-time presents an interesting and complex challenge. This paper describes the instructional package consisting primarily of a World Wide Web (WWW) site used by the author to aid in educating distance education students enrolled in graduate Artificial Intelligence Concept courses at the University of Florida.
An interactive learning system visualizing computer graphics algorithms
Authors: Janser Achim W.
Published: July 2004

At our universities the integration of computers into the classical lectures becomes more and more important, because their usage improves the quality of teaching. Our learning system is concerned with the visualization of Computer Graphics Algorithms. Such an algorithm can hardly be taught on a blackboard or an overhead, because the dynamic and the changes during its execution cannot be illustrated properly on a static display. In a learning system the algorithm can be visualized by using sample outputs that develop stepwise during the execution and by showing the most important variables with their values changing after certain commands. Our learning system is aimed to be used in addition to a classical lecture and practice.
Monitoring and evaluating a redesigned first year programming course
Authors: Hagan Dianne , Sheard Judy , Macdonald Ian
Published: July 2004

A collaborative project between the Computing faculty and the Education faculty of Monash University was aimed at improving the teaching and learning of first year programming. After initial research had identified the problems, some improvements were attempted during 1996. One department was willing and able to make major changes to its subjects immediately. The sequence of two first year programming subjects was restructured and redesigned. The progress of the project was monitored via direct observation, email and the World Wide Web. An improvement in the percentage of students who achieved very good results marked the project as a success.
Cost effective multimedia courseware development
Authors: Pilgrim C. J. , Leung Y. K. , Grant D. D.
Published: July 2004

Multimedia technology offers considerable potential for education though the costs of production of courseware are prohibitive especially in a rapidly changing discipline such as computer science. This paper proposes a cost-effective technique which allows multimedia courseware to be developed quickly and economically. To illustrate this concept, courseware material for an undergraduate Data Communications subject has been implemented.
Teaching software engineering and project management to 300 participants without drain of quality or intensity
Authors: Biffl Stefan , Grechenig Thomas
Published: July 2004

The paper discusses the setting, goals, timing, workload, organization, roles, and communication issues of an established large-scale software engineering workshop course. In order to assess trends of changes introduced this year and success factors for the course in general the technology support for the flow of work products between distributed work places and the lab as well as the integration and exchange of components in the lab is illustrated. Experiences with work teams on team building and distribution of work are summarized briefly.
Visual programming with Java; an alternative approach to introductory programming
Authors: Wester Frank , Sint Marleen , Kluit Peter
Published: July 2004

The appearance of the programming language Java and visual programming environments based on this language give new opportunities to teach introductory programming to university students. The authors are working on a new set of programming courses starting with Visual Programming. In this course the possibilities of visual programming environments are used to teach programming in an application oriented way with more emphasis on building user interfaces and using standard class libraries. Less attention is paid to algorithms. Because the applications in the course are of general interest, the course is suited for a broader audience than computer science students only.
Using a network simulation package to teach the client-server model
Authors: Dixon Michael W. , McGill Tanya J. , Karlsson Johan M.
Published: July 2004

The client-server model is fast becoming the most common form of network architecture used in data communications. It's popularity can be seen in the phenomenal expansion of the World Wide Web. It is essential that students understand the client-server model, and that they learn how to design client-server networks and to analyze their performance. This paper describes a project to achieve this via problem solving sessions using simulation to facilitate understanding of the design and performance analysis of networks using a client-server architecture. Students will be able to gain experience designing client-server networks and testing their designs for efficiency and expandability.
Concurrent programming CAN be introduced into the lower-level undergraduate curriculum
Authors: Feldman Michael B. , Bachus Bruce D.
Published: July 2004

There have been selected cases of satisfactorily teaching undergraduates the topic of concurrent programming. However, these reported experiences did not validate nor invalidate the feasibility claim as they did not provide statistical evidence and validity threat acknowledgments. Prior to this study, there have not been any controlled experiments to address the feasibility of introducing concurrent programming into the curriculum. Unfortunately, in curriculum development, it is seldom that we make decisions based on experimentation. We conducted a controlled experiment to determine whether introducing concurrent programming into the novice or lower-level undergraduate curriculum is possible. The experimental hypotheses examined concurrent programming from a concepts perspective and a problem-solving perspective. We conducted a detailed analysis of both internal and external validity threats to assess not only the validity, but the generalizability of the findings. The findings provide scientific evidence that introducing concurrent programming into the novice or lower-level undergraduate curriculum is possible.
Use of computer conferencing to teach a course on humans and computers
Authors: Palme Jacob , Männikö Sirkku
Published: July 2004

A course with the name "Humans, society and computers" was given using a non-simultaneous computer conferencing system (BBS system).
Ethics, programming, and virtual environments
Authors: Houle Michael E.
Published: July 2004

We have devised a novel experiential approach to teaching students about the social impact of computers and the ethical, legal, and social responsibilities of computing professionals. Rather than teaching these topics in a traditional classroom manner, we teach them in a text-based online virtual educational environment. At the same time we use the environment's object-oriented design to instruct the students in object-oriented concepts, and to introduce them to software engineering by having them work in groups. The approach is proving extremely successful.
VIBDaST
Authors: Theotokis Dimitrios , Gyftodimos George , Georgiadis Panagiotis , Philokyprou George
Published: July 2004

Internet based teaching is well established under various contexts. WWW based virtual interactive books are used for this purpose. Using WWW browsers students can study such books locally or remotely. Enhanced by Java
TM
applets, such books provide an interactive as well as a traditional approach to learning. Examples and exercises implemented as applets cater for both observation and exploration. Such a book, addressing the topic of data structures, is being developed as a teaching aid for a first year Computer Science students. Theory is presented in a hyperlinked textual form thus realising cross references, while examples and exercises are visualised as interactive Java
TM
applets.
Distance learning of the management of software projects
Authors: Boulet Marie-Michèle
Published: July 2004

In this paper, the content of the television distance education course
Management of software projects
is presented. The course is linked with the undergraduate program of computer science from University Laval. The first part of this paper comments on the needs analysis that drives us to design and develop this kind of distance learning material. The second part gives an idea of the knowledge that students must acquire and describe the use of television programs to share parts of the professional lives of forty experienced managers of software projects.
A critique of the advanced placement C++ subset
Authors: Ben-Ari Mordechai , Henney Kevlin
Published: July 2004

The Educational Testing Service has decided that the Advanced Placement Examination in Computer Science will use the C++ programming language in place of Pascal. They have designed a subset of the language to be used in high school courses. This paper claims that the subset is deficient in two areas: (a) the subset is vague on which language features it contains, and (b) the proposed class library diverges significantly from the draft Standard Library.These problems stem from an attempt to come to terms with non-complying implementations. We believe that the AP C++ subset should be defined on educational criteria alone; software and textbook authors and publishers would then adapt their course material to the language subset.
A Turing machine contest for introducing high school students to computer science
Authors: Brogi Antonio
Published: July 2004

This report briefly describes a Computer Science contest for high school students which was recently organized by the Department of Computer Science at the University of Pisa. The goal of the contest was to stimulate the interest of high school students for Computer Science, and to give them a chance of demonstrating and developing their problem solving abilities. A distinguishing aspect of the contest was that no background in Computer Science was required to participate.
Teaching computer science without a computer
Authors: Addison Paul
Published: July 2004

"The Computer in Action" is a role-playing activity developed by the Computer Science Outreach program at Purdue University, in which students process instructions and data in the same way that a real computer does. Students play the roles of Keyboarder, Bus Driver, CPU (The Brains), Math Wizard, Memory Manager, Print Manager, Screen Writer and User, carrying cards with instructions, values and messages to and from the Input, Processing and Output stations. The activity is designed for students in Kindergarten through Grade 3.
A technique for student program submission on UNIX systems
Authors: Macpherson P. A.
Published: July 2004

This paper presents a new scheme for collecting student programs and redistributing grades using simple UNIX scripts. Students keep their work in their own private subdirectories within a directory dedicated to a single class. When a program is due, control of the areas and files contained within them are passed over to the instructor. This locks the programs from alteration and provides a strict form of accountability. When the programs are graded, control of the area is returned to the individual student with the grade file both mailed to the student and left in a file readable by the student. Such a flexible framework has been used for a variety of languages and by students of varying levels of computing experience.
Why is a function defined as set of ordered pairs?
Authors: Gates Ann Q. , Kreinovich Vladik
Published: July 2004

In this short note, we describe the reasoning that makes the standard mathematical definition of a function (as a set of ordered pairs) more natural for students in an introduction to computer science course.
Computation of interprocedural control dependence
Authors: Harrold Mary Jean , Rothermel Gregg , Sinha Saurabh
Published: July 2004

Program dependence information is useful for a variety of software testing and maintenance tasks. Properly defined, control and data dependencies can be used to identify semantic dependencies. To function effectively on whole programs, tools that utilize dependence information require information about interprocedural dependencies: dependencies that exist because of interactions among procedures. Many techniques for computing data and control dependencies exist; however, in our search of the literature we find only one attempt to define and compute interprocedural control dependencies. Unfortunately, that approach can omit important control dependencies, and incorrectly identifies control dependencies for a large class of programs. This paper presents a definition of interprocedural control dependence that supports the relationship of control and data dependence to semantic dependence, an efficient algorithm for calculating interprocedural control dependencies, and empirical results obtained by our implementation of the algorithm.
Comparing flow and context sensitivity on the modification-side-effects problem
Authors: Stocks Philip A. , Ryder Barbara G. , Landi William A. , Zhang Sean
Published: July 2004

Precision and scalability are two desirable, yet often conflicting, features of data-flow analyses. This paper reports on a case study of the modification---ide-effects problem for C in the presence of pointers from the perspective of contrasting the flow and context sensitivity of the solution procedure with respect to precision and scalability. The results show that the cost of precision of flow- and context-sensitive analysis is not always prohibitive, and that the precision of flow- and context-insensitive analysis is substantially better than worst-case estimates and can be sufficient for certain applications. Program characteristics that affect the performance of data-flow analysis are identified.
An experiment in estimating reliability growth under both representative and directed testing
Authors: Mitchell Brian , Zeil Steven J.
Published: July 2004

The Order Statistic model of reliability growth offers improved• experimental design, and• flexibility in testing methodologycompared to conventional reliability growth models. It permits prediction of operational reliability without requiring that testing be conducted according to the operation profile of the program input space.This paper presents the first experimental use of the Order Statistic model under a test plan that combines both representative and directed tests. Results suggest that this is an effective way to obtain quantified measures of test quality without abandoning the advantages of directed test methods.
Automatic test data generation using constraint solving techniques
Authors: Gotlieb Arnaud , Botella Bernard , Rueher Michel
Published: July 2004

Automatic test data generation leads to identify input values on which a selected point in a procedure is executed. This paper introduces a new method for this problem based on constraint solving techniques. First, we statically transform a procedure into a constraint system by using well-known "Static Single Assignment" form and control-dependencies. Second, we solve this system to check whether at least one feasible control flow path going through the selected point exists and to generate test data that correspond to one of these paths.The key point of our approach is to take advantage of current advances in constraint techniques when solving the generated constraint system. Global constraints are used in a preliminary step to detect some of the non feasible paths. Partial consistency techniques are employed to reduce the domains of possible values of the test data. A prototype implementation has been developped on a restricted subset of the C language. Advantages of our approach are illustrated on a non-trivial example.
Automated program flaw finding using simulated annealing
Authors: Tracey Nigel , Clark John , Mander Keith
Published: July 2004

One of the major costs in a software project is the construction of test-data. This paper outlines a generalised test-case data generation framework based on optimisation techniques. The framework can incorporate a number of testing criteria, for both functional and non-functional properties. Application of the optimisation framework to testing specification failures and exception conditions is illustrated. The results of a number of small case studies are presented and show the efficiency and effectiveness of this dynamic optimisation-base approach to generating test-data.
A visual test development environment for GUI systems
Authors: Ostrand Thomas , Anodide Aaron , Foster Herbert , Goradia Tarak
Published: July 2004

We have implemented an experimental test development environment (TDE) intended to raise the effectiveness of tests produced for GUI systems, and raise the productivity of the GUI system tester.The environment links a test designer, a test design library, and a test generation engine with a standard commercial capture/replay tool. These components provide a human tester the capabilities to capture sequences of interactions with the system under test (SUT), to visually manipulate and modify the sequences, and to create test designs that represent multiple individual test sequences. Test development is done using a high-level model of the SUT's GUI, and graphical representations of test designs. TDE performs certain test maintenance tasks automatically, permitting previously written test scripts to run on a revised version of the SUT.
Improving efficiency of symbolic model checking for state-based system requirements
Authors: Chan William , Anderson Richard J. , Beame Paul , Notkin David
Published: July 2004

We present various techniques for improving the time and space efficiency of symbolic model checking for system requirements specified as synchronous finite state machines. We used these techniques in our analysis of the system requirements specification of TCAS II, a complex aircraft collision avoidance system. They together reduce the time and space complexities by orders of magnitude, making feasible some analysis that was previously intractable. The TCAS II requirements were written in RSML, a dialect of state-charts.
Model checking without a model
Authors: Godefroid Patrice , Hanmer Robert S. , Jagadeesan Lalita Jategaonkar
Published: July 2004

VeriSoft is a tool for systematically exploring the state spaces of systems composed of several concurrent processes executing arbitrary code written in full-fledged programming languages such as C or C++. The state space of a concurrent system is a directed graph that represents the combined behavior of all concurrent components in the system. By exploring its state space, VeriSoft can automatically detect coordination problems between the processes of a concurrent system.We report in this paper our analysis with VeriSoft of the "Heart-Beat Monitor" (HBM), a telephone switching application developed at Lucent Technologies. The HBM of a telephone switch determines the status of different elements connected to the switch by measuring propagation delays of messages transmitted via these elements. This information plays an important role in the routing of data in the switch, and can significantly impact switch performance.We discuss the steps of our analysis of the HBM using VeriSoft. Because no modeling of the HBM code is necessary with this tool, the total elapsed time before being able to run the first tests was on the order of a few hours, instead of several days or weeks that would have been needed for the (error-prone) modeling phase required with traditional model checkers or theorem provers.We then present the results of our analysis. Since VeriSoft automatically generates, executes and evaluates thousands of tests per minute and has complete control over nondeterminism, our analysis revealed HBM behavior that is virtually impossible to detect or test in a traditional lab-testing environment. Specifically, we discovered flaws in the existing documentation on this application and unexpected behaviors in the software itself. These results are being used as the basis for the redesign of the HBM software in the next commercial release of the switching software.
Chance-It
Authors: Adams Joel C.
Published: July 2004

Most people enjoy playing games. Most CS-1 students will enjoy a final project that involves computational game-playing.
Chance-It
is a simple two-person dice game with many possible strategies at varying levels of sophistication and complexity. These features make the problem of formalizing and encoding a strategy to play Chance-It an interesting final project for CS-1.This paper describes an object-oriented final project for CS-1 in which students build Player1 and Player2 classes to play Chance-It. A ChanceItGame class and driver are provided to coordinate the interactions of these classes. The project provides students with an enjoyable introduction to object-oriented design and the problem of formalizing and codifying human strategy in software. Examples are given in C++, but convert easily to Java.
The distributed course—a curriculum design paradigm
Authors: Toll Bill
Published: July 2004

One of the curriculum design problems facing computer science is the pressure to add new courses to cover additional topics. Often there is no curriculum space available. In some cases, the topics are covered more effectively by distributing them among a set of courses.However, when parts of a topic, such as parallel processing or scientific visualization, are distributed among a set of courses, additional problems arise in areas of coordination and consistency of coverage.A curriculum design paradigm is presented which seeks to formalize the distribution of a course in such a way that the integrity of the topics is maintained and documented.
Computer science
Authors: Cupper Robert D.
Published: July 2004

A traditional computer science program, in the liberal arts tradition and environment, has been in existence at Allegheny College for many years. The program was designed and adopted in 1979 [6] and the ideas and structure of that program became a substantial contribution to the LACS "Model Curriculum" developed in the early '80s and reported in [12]. In both of these cases, a concerted effort was made to identify and establish just what computer science is and design a curriculum to ensure that its graduates were well grounded in basic concepts and skills, the central core of the discipline, and some advanced or application areas. The Allegheny curriculum underwent minor changes in 1990 in conjunction with the College's adoption of a new base curriculum and calendar. The LACS model curriculum was revisited in the early '90s following publication of ACM's
Computing Curricula 1991
[1] resulting in a "Revised Model Curriculum" published in late 1996. [16].All of these efforts were based on the certainty that computer science had "evolved into an important academic discipline with a unique core of knowledge, a set of basic questions and problems, and a distinct method of approach to analysis of those problems." [6], p. 1. The Allegheny and LACS models were specifically designed to fit into and enhance a traditional liberal arts curriculum [7]. To this end, the goals or objectives of these programs were, above all, to provide for a good liberal education in computer science as a discipline. In particular, the programs were designed to ensure that the student obtains a solid academic base for further study or upon which to build a long-term successful career in computing. Specifically, successful completion of a course of study in computer science following these curricular guidelines ought to:1. enable the graduate to understand the capabilities, limitations, and ramifications of computing, the state of the art, and current research and development in computer science and related areas;2. to provide the potential for creative contribution to the art;3. to facilitate adaptation to changes in hardware and/or software technology and to new and changing applications areas;4. to prepare one for further study in computer science at the graduate level; and5. to prepare a student for distinguished professional development in a career in computing, or, in fact, many other areas. [6], p 8.
Using an object-oriented software life-cycle model in the software engineering course
Authors: Concepcion Arturo I.
Published: July 2004

An object-oriented software life-cycle model, the Modified Spiral Model, was successfully used as the software process in the software engineering course in the Department of Computer Science, California State University, San Bernardino. The model lends itself quite naturally to the object-oriented approach of producing software systems in the iterative and incremental manner. The software engineering class is run like a virtual software company which is composed of teams and team leaders where performance is measured on being able to submit the software deliverables and the success of the task(s) assigned to the team. The paper reports on the implementation of the software project, Algorithma (Algorithm Animation), in the virtual software company using the Modified Spiral Model.
Explication of object-oriented databases
Authors: Dingle Adair , Umphress David , Moul Russ
Published: July 2004

The growing use of Object-Oriented Databases (OODBs) has necessitated the inclusion of OODBs in introductory database courses. Typically, such an analysis is conducted after the explication of the dominant industry standard: the Relational Database model (RDB). Like the RDB model, the OODB model can be easily motivated. Unlike the RDB model, an established data model with defined normal forms, the OODB model cannot be easily evaluated for "goodness". We address this deficiency by examining the criteria of coupling and cohesion in database design. This approach affords the instructor the ability to better present OODBs as well as the opportunity to re-emphasize critical software engineering concepts.
Using inheritance for computing with physical quantities
Authors: Bergmann Seth
Published: July 2004

This paper involves an interdisciplinary project in computer science and physics. Students in introductory physics courses need to be able to deal with dimensioned quantities (often called "dimensional analysis"), and to solve problems using the correct units for various physical quantities. Computer science students need to understand concepts of object-oriented programming, including the notion of inheritance. In this paper we present a project in which physical quantities such as distance, time, mass, speed, force, power, etc. are represented as objects. The student designing the classes can ensure that the client always combines quantities in an appropriate fashion (e.g. a force must be computed as a mass multiplied by an acceleration). The student designing the classes can also allow the client to compute physical quantities using different units (e.g., the addition of three distances: 1 inch + 2 meters + 3 feet). This is done by defining subclasses
Meters, Miles,
and
Feet,
all of which inherit from the class
Distance,
thus providing the student with a nice example of the proper use of inheritance.The relevant classes, with test driver software, have been implemented and are available at the URL: http://www.rowan.edu/~bergmann The software has been implemented in both C++ and Java, though this paper will use the C++ version in its exposition.
Java class visualization for teaching object-oriented concepts
Authors: Dershem Herbert L. , Vanderhyde James
Published: July 2004

Visualization is a useful tool in many areas of computer science education. This paper describes the use of visualization in the introduction of object-oriented concepts. A Java application has been developed that allows the user to interact with a visualization of any Java class through the instantiation of objects, the movement of those objects around the class environment, and the activation of class methods. The user may also move conveniently between classes in this visualization.This Object Visualizer is useful for classroom demonstration, individual student use in the laboratory, and class debugging and testing.
Turning liabilities into assets in a general education course
Authors: Townsend Gloria Childress
Published: July 2004

Debate concerning the content of the general education Computer Science course or the "Computer Literacy" course captures the interest and divides the opinion of the Computer Science community. This paper describes three of the typical difficulties (liabilities) that instructors of a general education course encounter and how instructors may capitalize on these difficulties to transform them into assets.
The computer as a problem solving tool
Authors: Joyce Daniel
Published: July 2004

At Villanova University we have a popular course for non-majors focused on problem solving with computers, taught using our own lecture and lab materials. This paper seeks to describe the essence of the problem solving course by focusing on an assignment that is given after the first unit of the course has been completed. This assignment, writing an essay about how someone uses a computer to solve a problem, requires the application of most of the topics of the first third of the course and is very representative of the spirit of the course as a whole.
The Internet as a motivating theme in a math/computer core course for nonmajors
Authors: Gurwitz Chaya
Published: July 2004

The challenge of a computer literacy course is to present general principles of computer science, while at the same time engaging students who are nonmajors and demonstrating the relevance of the subject. In this paper we describe our experience with a course that uses the Internet as a motivating theme to introduce students to fundamental concepts of computer science. The students found the course interesting and were visibly stimulated by the material. In comparison with previous semesters, the students left the course with more practical skills as well as a greater appreciation of the interrelations between mathematics and computer science.
Retaining women in CS with accessible role models
Authors: Haller S. M. , Fossum T. V.
Published: July 2004

The female role models presented to young women are often unusual individuals who have overcome tremendous social and political obstacles to pursue outstanding careers in mathematics and science. We believe that young women presented with these exceptional role models may actually have their self-confidence undermined because they cannot readily identify with them. At the University of Wisconsin-Parkside (UW-Parkside), we are implementing a project that will employ our own upper-level female computer science (CS) students as half of our laboratory staff in a CS laboratory that is maintained and administrated by our CS students. In this laboratory, women will be as much in control as much as their male counterparts. This non-threatening environment, where women play a prominent role, will communicate to our beginning female students that these roles are realistic and obtainable by them in their college life and in the workplace. We plan to offer our introductory CS sequence to area high school students so that high school girls can benefit from this same experience.
Gender differences in personality components of computer science students
Authors: Haliburton William , Thweatt Mack , Wahl Nancy J.
Published: July 2004

The problem of disproportional representation of females in computer science curricula was examined in the context of Holland's theory of vocational personality. It was hypothesized that some combination of standardized mathematical aptitude and congruence would significantly predict achievement and persistence in computer science.
A study of barriers to women in undergraduate computer science.
Authors: Scragg Greg , Smith Jesse
Published: July 2004

Worldwide, there is a significant discrepancy between the numbers of male and female graduates from computer science programs. SUNY Geneseo offers no exception. The literature cites a number of plausible explanations for the problem, but no definitive answers. We conducted a study to determine why few women complete our own computer science major. Our major finding is that (at least on our campus) the problem is not actually one of retention. Few women---even those in the introductory computer science courses---actually plan to major in computer science to begin with. Although some barriers suggested in the literature do operate within the major, they seem much less significant than the low entry rates. Retention of women once they enter the major is important, but it is secondary to getting women into the major initially. This suggests that the most effective solutions will be those that concentrate not on retention but on recruitment (including outreach to secondary schools).
Design and implementation of an interactive tutorial framework
Authors: Barnett Lewis , Kent Joseph F. , Casp Justin , Green David
Published: July 2004

The work described in this paper is part of an NSF funded project to develop tutorial materials for introductory computer science courses. We had several general goals for these materials that had an impact on their design and implementation:• they should be delivered on-line;• they should be highly interactive;• they should be useful on a wide variety of hardware/software platforms; and• it should be easy to extend the content to different courses or contexts.In trying to meet these goals we designed and implemented a package of Java classes that provided a framework for creating our set of tutorials, yet was general enough to be used in other contexts such as interactive laboratories. This paper describes the framework and the design decisions that governed the implementation. Information about obtaining the package is included in section 7.
Using Java to develop Web based tutorials
Authors: Cole David , Wainwright Roger , Schoenefeld Dale
Published: July 2004

This paper presents the use of Java applets acting as a web-based interface to existing, platform dependent software tools. We present an example application called GAWebTutor which was constructed from a comprehensive genetic algorithm package and web-based Java components. In effect, we packaged an interactive genetic algorithms tutorial and made it available to anyone on the WWW. Furthermore, by building a GUI front end to an existing application in Java, we leveraged browser technology to overcome platform compatibility problems. A blending of Java and platform dependent code can successfully create user friendly, portable, more versatile applications that take full advantage of all available software components. Using our approach, educators can make their educational programs or other software tools available to anyone through the WWW.
Class to survey application programming topics
Authors: Drake Janet M.
Published: July 2004

This paper describes a class that we developed at the University of Northern Iowa to address covering the topics suggested in ACM/IEEE Computing Curricula 1991 [1]. All junior level students take this course, and thus are ensured of a minimum introduction to the topics of software engineering, database management, human computer interfaces, and computer ethics. This paper describes the course and lessons learned in teaching the course. One of the benefits of the course is that it introduces abstract modeling (entity-relationship model) and the model is used in a life cycle that includes analysis, design, implementation, and test. Students see how a model fits into software development and the benefits of modeling. The greatest challenge in the course is finding a coordinated text book that adequately covers all the topics in the course.
An undergraduate course in formal methods
Authors: Tremblay Guy
Published: July 2004

We present a new undergraduate course in formal methods which emphasizes software specification and description instead of formal program correctness or program derivation.This course is motivated by the idea that specifications play a key role in the software development process and that precise and clear descriptions of software systems and artifacts are important. It wants to show students that some simple notions from logic and mathematics (predicates and quantifiers, set theory, maps), together with appropriate constructs for defining software components and systems, can be useful for this purpose.The course is taught using the Spec notation [1] and we first discuss why we did not choose the ubiquitous Z notation. The content of the course is then presented, followed with a brief description of an on-line WWW system that was developed to help the students do the exercices presented in the course notes.
Bringing real-world software development into the classroom
Authors: Nachbar Daniel
Published: July 2004

A proposal is made for combining ongoing volunteer efforts to produce and freely distribute real-world, consumer-oriented software with the existing curricula in computer science. The differences between such an endeavor and currently ongoing free software efforts are described. The pedagogical advantages of working with and contributing to such an effort are explored. Potential enhancements to existing course work are discussed, as are some possible new avenues of instruction. The economic viability of such an enterprise is also briefly described.
Incoming freshmen build their own PCs
Authors: Beil Donald H. , Lange Donna , Olsen Elissa , Spiecker Anthony
Published: July 2004

The Applied Computer Technology Department (ACT) of the National Technical Institute for the Deaf (NTID), a college of the Rochester Institute of Technology (RIT), offered a unique two-day workshop at which incoming freshmen students who are deaf or hard of hearing built their own personal computers.This paper provides extended details of our experience at the most recent offering of this workshop attended by 28 freshmen students. The workshop was held in September, 1997 after new-student orientation and before school began.Sufficient details are provided so that our experience might serve as a reference point for other universities interested in offering a similar workshop.
Teaching the empirical approach to designing human-computer interaction via an experiential group project
Authors: Clarke Matthew C.
Published: July 2004

Empirical research plays an important role in the design of user-interfaces and is frequently included in university courses on human-computer interaction. For instance, the ACM SIGCHI guidelines refer to the importance of empirical research, although they do not specify how this approach to user-interface design should be taught. In an Honours (fourth-year) course at the University of Natal, Pietermaritzburg, the theoretical foundation of empirical research is augmented with a real experience of running a simple experiment. This experiment is planned, executed and analysed by the class as a whole. This paper describes the type of empirical studies carried out and discusses the benefits and limitations of such studies in this educational context.
An integrated course on parallel and distributed processing
Authors: Cunha José C. , Lourenço João
Published: July 2004

Most known teaching experiences focus on parallel computing courses only, but some teaching experiences on distributed computing courses have also been reported. In this paper we describe a course on Parallel and Distributed Processing that is taught at undergraduate level in the Computer Science degree of our University.This course presents an integrated approach concerning concurrency, parallelism, and distribution issues. It's a breadth-first course addressing a wide spectrum of abstractions: the theoretical component focus on the fundamental abstractions to model concurrent systems, including process cooperation schemes, concurrent programming models, data and control distribution, concurrency control and recovery in transactional systems, and parallel processing models; the practical component illustrates the design and implementation issues involved in selected topics such as a data and control distribution problem, a distributed transaction-based support system and a parallel algorithm.We also discuss how this approach has been contributing to prepare the student to further actions regarding research and development of concurrent, distributed, or parallel systems.
A concurrency simulator designed for sophomore-level instruction
Authors: Kurtz Barry L. , Cai Hong , Plock Chris , Chen Xijia
Published: July 2004

The Concurrency Simulator is used in a sophomore-level course to introduce students to parallel computing. This simulator is unique since it integrates a graphical topology into the programming environment. This makes algorithms much easier to express and, combined with a context-sensitive editor, makes it easy for students to enter their algorithms without becoming bogged down in the details of language syntax. We provide detailed examples for the semaphore, rendezvous and monitor paradigms. We briefly describe the development process for this Java 1.1 program and then describe our classroom experiences with students at this level.
Multithreaded programming in an introduction to operating systems course
Authors: Shene Chin-Kuang
Published: July 2004

This paper presents a way of teaching multithreaded programming as a component in an introduction to operating systems course. Topics include programming assignments, term projects, and experiences. This paper also suggests future work for overcoming a bottleneck that occurs in the current version of this course.
Conceptual models and cognitive learning styles in teaching recursion
Authors: Wu Cheng-Chih , Dale Nell B. , Bethel Lowell J.
Published: July 2004

An experimental research design was implemented in an attempt to understand how different types of conceptual models and cognitive learning styles influence novice programmers when learning recursion. The results indicate that in teaching recursion to novice programmers:• concrete conceptual models are better than abstract conceptual models,• novices with abstract learning styles perform better than those with concrete learning styles,• abstract learners do not necessarily benefit more from abstract conceptual models, and• concrete learners do not necessarily benefit more from concrete conceptual models.
WEB-based query processing in a database course project
Authors: Aslam Sohail
Published: July 2004

One of the prominent uses of WWW has been WEB-based querying of databases. Search sites such as Yahoo and Infoseek present the WWW user with a form to be filled in with a query and return the results of the search. WEB forms are also being increasingly used for interaction with database management systems. One key element of the Intranet environment is the use of WEB-based facilities for query processing.In our undergraduate database course project, we decided to not only have the students design and implement relations in a relational database management system, but also provide a WEB-based facility that allows for fairly complex query processing. The actual data was the entire catalog (12,000 holdings) of the Department of Business Management's Library. The students had to first design the appropriate normalized relations and then load the data into a Relational Database Management System (RDBMS). We used PostgreSQL as the RDBMS [1]. The students then designed WEB forms that allowed a user to query the library database using a Web browser. The user could specify simple and complex queries. The students used PHP [2], a public domain tool, to embed SQL queries into ordinary HTML form documents. This avoided the use of CGI scripts or Java applets, thus making the programming task much simpler.This paper presents details of the mechanics of the student project, examples from the students' submissions, and concluding remarks that highlight the benefits of WEB-based query processing.
Teaching data structure design patterns
Authors: Gelfand Natasha , Goodrich Michael T. , Tamassia Roberto
Published: July 2004

In this paper we present an approach for teaching the Freshman-Sophomore introduction to data structures course (CS2) in a way that provides an introduction to object-oriented software engineering patterns in addition to the theory of data structures. We survey in this paper several design patterns and describe how they can be naturally integrated in the CS2 curriculum.
A virtual learning environment for entity relationship modelling
Authors: Hall Lynne , Gordon Adrian
Published: July 2004

Entity Relationship Modelling (ERM) is a fundamental skill in database design. Though ERM concepts are simple, the modelling process itself is a complex activity. Novice ER modellers make systematic errors in their models. Current tool-based support for learning ER modelling is limited, since it concentrates on notation at the expense of methodology, and provides little or no feedback to the learner about the quality of her constructed models. A text-based virtual learning environment, based on the Multi-User Dimension paradigm, is described, in which learners undertake ER modelling tasks by interacting with objects in a virtual world. This learning environment concentrates on the methodology of ER modelling rather than its notation, and provides immediate feedback to a learner about the quality of her models. Preliminary results suggest that this learning environment is both easy to use and effective.
Accommodating diversity of academic preparation in CS1 (panel)
Authors: Dickey Martin , Friedman Frank , Hailperin Max , Manaris Bill , Wolz Ursula
Published: July 2004

Students come into CS1 with a variety of academic and programming backgrounds. Panelists and audience members will discuss the consequences of this fact, and explore a variety of strategies for coping with the situation.