bluuebunny/crossref_metadata_2025 huggingface dataset:
A multi-agent system for computer science education
Authors: Shi Hongchi , Shang Yi , Chen Su-Shing
Published: July 2004

In this paper, we present a multi-agent system for supporting student-centered, self-paced, and highly interactive learning in undergraduate computer science education. The system is based on a hybrid problem-based and case-based learning model, for both creative problem solving and mechanical experience simulation. It aims at enhancing the effectiveness of the undergraduate learning experience in computer science. Implemented using the prevalent Internet, Web, and digital library technologies, the system adopts an open architecture design and targets at large-scale, distributed operations. In the initial implementation of the system, a number of prototypes using different Java-based software environments have been developed. They offer tradeoffs in system performance and design complexity.
Teaching computer networking using open source software
Authors: Nelson Daniel , Ng Yau Man
Published: July 2004

For the past seven years we have taught a subject entitled Network Software and Management (NSM) for both computer science and electrical engineering students. We discuss the evolution of this subject syllabus in response to the changing requirements of the workplace environment, ever improving technology and the need to combine theory and practice in teaching subjects such as this. We used open source software exclusively in our laboratory exercises and we provide the rationale behind our choice of specific software packages.
A worldwide, web-based study of the attitudes of college freshmen toward computing
Authors: Tjaden Bunny J. , Tjaden Brett C.
Published: July 2004

We propose to initiate a worldwide survey of colleges and universities to re-evaluate attitudes of students toward computing courses. In 1985, a study of college freshmen was conducted to determine their attitudes toward introductory computer science courses [10]. At that time, access to and experience with computers was not the norm for the typical student about to enter the university. The 1985 study found that females, as well as students with no computer experience, reported the most negative encounters with computing. We intend to expand the original study, delving into whether or not the programming language learned, compiler and operating system used, peer and parental attitudes, as well as other factors, influence a student's attitude toward computing. We are particularly interested in examining these attitudes from the standpoint of women and minorities, those who are still least likely to have prior, in-depth computer experience. Additionally, with the ease of communication due to email and the internet, we believe it is of interest to computing educators worldwide to participate in such a study. We will provide a survey instrument, a set of World Wide Web tools, and a database. Faculty and their classes from around the world will be encouraged to participate. Each institution will be able to immediately compare the profile of their students with those of other schools. We will provide search capabilities on several key fields in order to facilitate participant data analysis. We foresee the results of our survey generating a dialogue among educators and possibly changing the direction of and/or way in which computer science is taught.
Making the connection
Authors: Dann Wanda , Cooper Stephen , Pausch Randy
Published: July 2004

In learning to program, students must gain an understanding of how their program works. They need to make a connection between what they have written and what the program actually does. Otherwise, students have trouble figuring out what went wrong when things do not work. One factor that contributes to making this connection is an ability to visualize a program's state and how it changes when the program is executed. In this paper, we present Alice, a 3-D interactive animation environment. Alice provides a graphic visualization of a program's state in an animated small world and thereby supports the beginning programmer in learning to construct and debug programs.
Teams need a process!
Authors: Hilburn Thomas B.
Published: July 2004

This paper begins with a discussion of the importance of software development and the problems encountered by those trying to work effectively on software project teams. It is argued that for students to be effective in working on teams they need the discipline and organization offered by a rigorous team software process. The author describes his experiences in using the Team Software Process (TSP) to teach an introductory course in software engineering. The structure and key elements of the process are presented, along with techniques used in selecting and forming teams. The paper examines the TSP quality assurance features and finishes with a discussion of the techniques used to acquire feedback and to evaluate the affect of the TSP on student learning.
Enter the usability engineer
Authors: Faulkner Xristine , Culwin Fintan
Published: July 2004

This paper examines the role of Human Computer Interaction in the context of the Computer Science and Software Engineering curricula. We suggest there needs to be much more integration between Computer Science and HCI. We believe this can be brought about by adopting HCI as the underlying principle to the development of systems. Usability engineering would provide the necessary framework for the development of usable systems.
Interactive packages for learning image compression algorithms
Authors: Khuri Sami , Hsu Hsiu-Chin
Published: July 2004

This paper introduces three interactive packages for learning image compression algorithms. The first two packages, RLE and Quadtree, animate bitmap image compression algorithms, and the third package, JPEG, is a tutorial about the Joint Photographic Expert Group (JPEG) standard. The goal in designing and developing the packages was to provide instructors with tutorial and demonstration tools for teaching various interesting algorithms to students in CS1/CS2, Data Structures and Algorithms, Data Compression and Image Processing courses. The packages visualize image compression algorithms by displaying their different states of execution, using different colors to highlight the important areas, and providing textual explanations to help users understand the visualization. All three packages are interactive, platform-independent, and easy to use.
Can Web development courses avoid obsolescence?
Authors: Klassner Frank
Published: July 2004

Yes.
Combating the code warrior
Authors: Weber-Wulff Debora
Published: July 2004

Many CS101 courses purport to teach object-oriented programming, but many seem to be directly translated from traditional structured programming courses. Lynn Andrea Stein's "Rethinking CS101" program at MIT offers a radically different approach to teaching OO programming by concentrating on the interactive aspects of object-oriented systems. This approach has the added advantage that students who have previously learned "programming" must also relearn how to approach the problems involved in programming interactive systems. This paper reports on the author's use of this concept outside of MIT, with encouraging results.
Three semesters of CSO using Java
Authors: Odekirk Elizabeth , Jones Dominic , Jensen Peter
Published: July 2004

A CSO class with heavy lab emphasis was developed at the University of Utah in the summer of 1998. It has been taught three times by different instructors to students who were diverse in background, gender, and skill level. The culmination of these efforts is a set of original labs which can be divided into several chronological categories: a gentle introduction, computation and events, interaction and graphical user interfaces, algorithms, object-oriented programming, and Java specific issues. These labs encompassed several themes which guided the curriculum in all three semesters: creativity, visual and interactive methods, and breadth. This paper is a combined summary of these experiences.
ILE
Authors: Hosny H. , Khaled O. , Fathalla M. E.
Published: July 2004

This paper provides an overview of the Interactive Lab Environment (ILE) project and a report on its current status and future directions. ILE is the framework of a customized interactive lab environment for computing concepts and courseware that we developed for our department using Java.In essence ILE is a well-managed, networked set of resources that offers its users a collection of tools. The most significant of these tools are the flexible routes through an interactive learning environment combining the presentation of course information and notes, executable examples of learning materials, visual tools for presenting new concepts that are otherwise hard to visualize, and a quick means of communication within the academic unit. In addition to the ILE framework itself and a few course material demos, two interactive components were developed and implemented thus far, both of which are visual tools but with differing degrees of abstraction and disclosure.
Pedagogical power tools for teaching Java
Authors: Raab Jeff , Rasala Richard , Proulx Viera K.
Published: July 2004

We describe a Java toolkit that is designed to support the creation of powerful and extensible GUI interfaces during the first year computer science course. The goals of this toolkit are to provide:• an infrastructure for creating well designed programs that illustrates the concepts of computer science and its practical applications• an environment for learning the basic ideas of interface design and for experimenting with a variety of designs• a paradigm for building interfaces in Java that scales from individual data items to large structures, using recursively displayable container classesAdditionally, the toolkit classes themselves can be studied as examples of proper object oriented design, and of building event listeners.
Algorithm simulation with automatic assessment
Authors: Korhonen Ari , Malmi Lauri
Published: July 2004

Visualization is a useful aid for understanding the working of algorithms. Therefore many interactive algorithm animation tools have been developed. However, students may misinterpret the visualization and therefore the correctness of their interpretation should be confirmed by tests supplemented with feedback.In this paper, a learning environment for data structures and algorithms is presented. The combination of algorithm animation and simulation with automatic assessment provides a way to give meaningful feedback to the students. Our experience shows that this combination is of great value for the students studying algorithms.
Future challenges in program visualization (panel session)
Authors: Sutinen Erkki
Published: July 2004

As an interdisciplinary topic, program visualization research needs a comprehensive approach, in order to be useful for college education and research, as well as software engineering. This main challenge consists of several aspects, like developing efficient visualization techniques, composing attractive pilot environments, analyzing visualizations from the cognitive point of view, creating functional taxonomies to compare various environments, supporting teamwork in algorithm design and programming, and designing field testing methods to evaluate a given visualization environment.
Toolbook multimedia demonstrations for Java programming
Authors: Ellis Ainslie
Published: July 2004

This paper describes a set of multimedia demonstrations built to facilitate the learning of introductory Java programming. They provide demonstrations of complex processes and concepts that are difficult, if not impossible, to present using more traditional media used in lectures.
OOPtutor
Authors: Gelderblom J. Helene
Published: July 2004

The author developed OOPtutor, a prototype of a system that teaches entry level object-oriented programming in Java. It uses a simple world of dogs to introduce the important object-oriented concepts like objects, classes, methods and inheritance. The prototype was implemented as a set of object-oriented classes that perform general CBL authoring functions. This article gives a brief description of the OOPtutor prototype and its implementation.
Visual tool for teaching synchronization problems in operating systems
Authors: Bhatti M. Afzal
Published: July 2004

During the last several years, many attempts were made to prove that information technology (IT) holds great promise for education. For that purpose all over world, research has been carried out on the instructional use of IT in education. The results of the research activity have repeatedly proven that computers can be powerful educational tools. Information technology, when properly used, can improve learning, motivate students, and help them gain higher-level cognitive skills critical to lifelong learning. Yet, despite the proven success of instructional computing, it has not yet been fully adopted in meaningful way into computer science education at university level. The paper is about an attempt to use information technology to teach basic concepts in one of the core computer science courses---operating systems---in a modest computing environment.
Teaching Java with Graphics in CS1
Authors: Schaub Stephen
Published: July 2004

This paper discusses an approach to teaching basic object-oriented concepts in CS1 using Java graphics. Students first use a simplified turtle graphics API to explore introductory programming issues. Later, they see a real-world example of how inheritance can be used to add functionality to the standard Java Abstracting Windowing Toolkit, to facilitate the construction of sophisticated graphics applications.
Software development for next generation communication networks
Authors: DeMillo Richard A.
Published: July 2004

Even casual observes have to notice the dramatic changes in the telecommunications industry that have taken place in the last five years. Giant companies split, merge and are sometimes displaced by newer ones that did not exist a decade ago. The business of running the mighty circuit-switched telephone netwok is under constant assault on one side from packet networks and on the other side from the bewildering array of wireless networks. Service providers compete for customer sometimes with no network infrastructure at all.
Bugs in the programs
Authors: Pethia Richard D.
Published: July 2004

Security on the Internet is receiving increasing attention as more and more organizations are becoming dependent on the network. The use of the Internet for electronic commerce, government operations, research activities, and entertainment has now reached the point that attacks against the network and the systems connected to it have become major news items. While the press highlights a few high-profile incidents, the actual number of attacks is much higher. The CERT Coordination Center works with the Internet community to deal with incidents and responded to over 8,000 incidents in 1999. The incident projection for year 2000 is 17,000 to 20,000. At the same time, the amount of damage resulting from the incidents is also increasing. While the press often focuses on cases of web site graffiti, more serious cases of financial fraud, extortion, and debilitating denial of service attacks are being reported at increasing rates.
Classifying properties
Authors: Naumovich Gleb , Clarke Lori A.
Published: July 2004

Traditionally, verification properties have been classified as
safety
or
liveness
properties. While this taxonomy has an attractive simplicity and is useful for identifying the appropriate analysis algorithm for checking a property, determining whether a property is safety, liveness, or neither can require significant mathematical insight on the part of the analyst. In this paper, we present an alternative property taxonomy. We argue that this taxonomy is a more natural classification of the kinds of questions that analysts want to ask. Moreover, most classes in our taxonomy have a known, direct mapping to the safety-liveness classification, and thus the appropriate analysis algorithm can be automatically determined.
Survival: a tale of a senior project
Authors: Anderson Elaine
Published: July 2004

In 1984 the Computer Information Systems Department at Humboldt State University implemented a B.S. degree program in Computer Information Systems. Prior to that year the program had been offered under the auspices of a Business Administration degree as a concentration. In the evolvement of the program since 1984. The faculty of the department determined that a senior project course would form an appropriate capstone course for all CIS majors. The course and its incorporation into the degree program will occur in 1987/88. It so happened that Bailes and Sayers' paper [1] and the opportunity to apply their guidance occurred at the beginning of the spring semester. The story of our experiment with the course using a variation of the "contract" suggested by Bailes and Sayer, as written by the three students involved, follows.One semester, three graduating seniors found themselves with class schedule conflicts that prevented their taking a particular required course. When it became obvious that they could not schedule the conflicting class, the chair of their department assigned to them a senior project. The guidelines for the project were adapted from ones outlined in the SIGCSE Bulletin Vol. 18 No. 4, December 1986. The students could do whatever they wanted for a project so lon g as the department chair approved, and they fulfilled the objectives. Here is what these graduating seniors did.
A comparison of programming team performance on software development projects
Authors: Jordan Donald L.
Published: July 2004

A senior level course for software project developments is offered every semester at Lamar University. The design and programming teams formed in the class are analyzed. The purpose of this paper is to present some statistics and key parameters from that analysis to compare the performance of large and small size programming teams on software development projects.
Teaching first year programming: a proposal
Authors: Ferchichi Ahmed , Jaoua Ali
Published: July 2004

The first contact of students with programming is of prime importance and ought to be controlled carefully. This paper proposes an approach for managing this first contact.
Misleading intuition in algorithmic problem solving
Authors: Ginat David
Published: July 2004

This paper presents a study of misleading intuition in the domain of algorithmic problem solving. I noticed incorrect intuitive solutions to challenging algorithmic problems and interviewed students on their solutions. The students arrived at an erroneous conviction rather rapidly and demonstrated overconfidence and reinforcement of their incorrect ideas when presented with new evidence. I present two colorful and unfamiliar algorithmic challenges posed to the students, describe and discuss my experience, and offer some suggestions for reducing the effect of misleading intuition.
Do we really teach abstraction?
Authors: Bucci Paolo , Long Timothy J. , Weide Bruce W.
Published: July 2004

Abstraction is one of the cornerstones of software development and is recognized as a fundamental and essential principle to be taught as early as CS1/CS2. Abstraction supposedly can enhance students' ability to reason and think. Yet we often hear complaints about the inability of CS undergraduates to do that. Do we supply students with the tools they need to reach their potential to think carefully and to reason rigorously about software behavior? Typically we do not, but as educators there are techniques we can use to help our students develop such skills starting in CS1/CS2.
A chat room assignment for teaching network security
Authors: Mitchener W. Garrett , Vahdat Amin
Published: July 2004

This paper describes a chat room application suitable for teaching basic network programming and security protocols. A client/server design illustrates the structure of current scalable network services while a multicast version demonstrates the need for efficient simultaneous distribution of network content to multiple receivers (e.g., as required by video broadcasts). The system also includes implementations of two security protocols, one similar to Kerberos and another based on public key encryption.
From RS-232 to object request brokers
Authors: Janzen David
Published: July 2004

Selecting an appropriate set of laboratory experiences and projects for a Data Communications and Computer Networks course can be difficult due to the broad and deep nature of the topics. Emphasis may be placed on many networking aspects including design, evaluation, efficiency, security, protocols, tools, and applications. This paper presents a set of projects that attempt to integrate software engineering and systems administration topics. The projects emphasize network application programming. Particular attention will be given to a sequence of incremental projects using an object-oriented approach including the use of the Unified Modeling Language (UML) and a design pattern.
Automated feedback on programs means students need less help from teachers
Authors: Odekirk-Hash Elizabeth , Zachary Joseph L.
Published: July 2004

Many educators believe that the most effective means of teaching is through one-on-one interactions with students. It is not surprising, then, that an effective way to teach programming is to give students immediate feedback on programs that they have just written. Unfortunately, such one-on-one teaching scenarios are becoming increasingly difficult to arrange. We built InSTEP, an online tutoring system for beginning C programmers, to see whether an automated system could provide effective immediate feedback to beginning programming students. In an introductory programming course, we compared two groups of students. One group solved six programming problems with feedback from InSTEP; the second group solved the same six problems without feedback from InSTEP; both groups had access to feedback from teaching assistants. While both groups of students took about the same amount of time to complete the problems and performed about the same on a subsequent test, the students who received feedback from InSTEP spent less than a third of the time asking the teaching assistants questions than did the others.
AnimalScript
Authors: Rößling Guido , Freisleben Bernd
Published: July 2004

In this paper, we present the
AnimalScript
visualization language. This scripting language uses the flexibility of the
Animal
system and provides many additional new graphic primitives and animation effects that go beyond the traditional
Animal
GUI features.
AnimalScript
can easily be configured by changing the content of a registration file. Users may also have multiple registration files, as
AnimalScript
will always use the first registration file it finds.
AnimalScript
can easily be extended with additional features without needing to read, let alone change, any existing code.
When worlds collide!
Authors: Zimmerman Guy W. , Eber Dena E.
Published: July 2004

The use of virtual reality technologies as a medium for artistic expression requires the combined talents of artists and computer scientists working in concert. We created a course to bring together students and faculty from these two diverse worlds, both to create artistic virtual environments and to foster skills needed to work on interdisciplinary teams. This paper describes this course, the art works created and discuses some of the issues that arise when such worlds collide.
Introducing computer systems from a programmer's perspective
Authors: Bryant Randal E. , O'Hallaron David R.
Published: July 2004

The course "Introduction to Computer Systems" at Carnegie Mellon University presents the underlying principles by which programs are executed on a computer. It provides broad coverage of processor operation, compilers, operating systems, and networking. Whereas most systems courses present material from the perspective of one who designs or implements part of the system, our course presents the view visible to application programmers. Students learn that, by understanding aspects of the underlying system, they can make their programs faster and more reliable. This approach provides immediate benefits for all computer science and engineering students and also prepares them for more advanced systems courses. We have taught our course for five semesters with enthusiastic responses by the students, the instructors, and the instructors of subsequent systems courses.
Undergraduate research in genetic algorithms
Authors: Lankewicsz Linda Bright
Published: July 2004

The study of genetic algorithms (GAs) in the undergraduate curriculum introduces students to parallel search strategies and to experimental design. Not only does it build on the topics covered in an Analysis of Algorithms course but it exposes students to issues such as the importance of the form of representation to solving a problem and to the difficulties encountered when a local minima is selected as the solution rather than the best global solution. As an illustration of the merits of including genetic algorithms in the curriculum, an undergraduate research project investigating the use of a diploid sexual model for crossover operations is described.
Teaching internet algorithmics
Authors: Goodrich Michael T. , Tamassia Roberto
Published: July 2004

We describe an Internet-based approach for teaching important concepts in a Junior-Senior level course on the design and analysis of data structures and algorithms (traditionally called CS7 or DS&A). The main idea of this educational paradigm is twofold. First, it provides fresh motivation for fundamental algorithms and data structures that are finding new applications in the context of the Internet. Second, it provides a source for introducing new algorithms and data structures that are derived from specific Internet applications. In this paper, we suggest some key pedagogical and curriculum updates that can be made to the classic CS7/DS&A course to turn it into a course on Internet Algorithmics. We believe that such a course will stimulate new interest and excitement in material that is perceived by some students to be stale, boring, and purely theoretical. We argue that the foundational topics from CS7/DS&A should remain even when it is taught in an Internet-centric manner. This, of course, should come as no surprise to the seasoned computer scientist, who understands the value of algorithmic thinking.
Explorations
Authors: Lischner Ray
Published: July 2004

A style of homework assignment is presented, called
explorations.
An exploration is part of an introductory programming course, specifically designed to help first-time programmers overcome common hurdles, such as misconceptions about the nature of computers and programs. An exploration is a structured lab where the student makes predictions about a program's behavior, then runs the program to compare the actual result with the predicted result. The questions are deliberately designed to challenge common errors and preconceived notions of computers and programming languages. Guided questions help the students refine their mental models of computers. Successful explorations have resulted in significant gains in comprehension, retention, and student satisfaction. Several guidelines are presented to help teachers write effective explorations.
Solving the CS1/CS2 lab dilemma
Authors: Robbins Kay A. , Key Catherine Sauls , Dickinson Keith , Montgomery John
Published: July 2004

In our quest to modernize our CS1/CS2 curriculum, we ran into several problems in the effective delivery of the courses and their associated laboratories. We have developed a teaching model in which students become the presenters for the hands-on laboratories. In order for this approach to be effective, the laboratories must be reused from semester to semester, so that student presenters are truly knowledgeable. The student-presenter model also requires more detailed supporting material and a rethinking of course grading policies.
Second language acquisition and CS1
Authors: Applin Anne Gates
Published: July 2004

This paper presents an empirical study of the relative effectiveness of two teaching methods used in CS1 classrooms. While the teaching methods are nothing new, the results of the study are an important contribution to the body of computer science education literature. The research design should also be of interest in that it demonstrates how statistical significance can be achieved with a relatively small sample by using the naturally occurring groups that we have as course sections.The teaching methods studied here were having students write programming assignments from scratch versus having them add to or modify existing well-written, well-documented programs. The results are perhaps not surprising. After controlling for certain factors, the statistical analysis showed that students who added to program templates as programming assignments scored better on the comprehensive examination and had higher overall course averages than their counter parts who wrote programs from scratch. This idea is firmly based in cognitive psychology and teachers of language use a similar method extensively. Reading increases vocabulary, aids in concept retention, and improves writing skill.
A web-based little man computer simulator
Authors: Yurcik William , Brumbaugh Larry
Published: July 2004

This paper describes a web-based simulation tool which can be used to teach introductory computer organization based on the conceptual paradigm of a Little Man Computer. Specifically we share examples how this tool can be used to improve student comprehension of the interaction between computer architecture, assembly language, and the operating system.
Using a PDP-11/10 to teach content and history in computer organization courses
Authors: Harms Douglas , Berque Dave
Published: July 2004

This paper describes our use of a 1970's era PDP-11/10 to support an hour long module which we have incorporated into our computer organization course for the past few semesters. The module is designed to reinforce standard concepts such as number systems and two-pass assemblers while at the same time exposing the students to some historical issues. After providing some background information about the PDP-11/10 we explain the motivation for our approach. Then we describe a fifteen minute instructional video which we have produced on the topic of developing programs on the PDP/11-10. The video is available from the authors either on VHS tape or as a QuickTime file, thereby allowing instructors at other schools to try our approach by showing the video to their students.
Turing the tables
Authors: Barnes Julie , Leventhal Laura
Published: July 2004

The most recent report of the Computing Curricula 2001 (CC2001) suggests that updated curricula must reflect the broadening nature of our discipline. Two areas that are included in the strawman draft of CC2001 are software engineering (SE) and human-computer interaction (HC). While the first inclination might be to incorporate these minimal HC concepts in a traditional SE course, we propose a different approach. This paper outlines a project oriented HC course in which we are able to emphasize SE in the context of HC concepts. We include an overview of course content that illustrates our approach.
Using squeak for teaching user interface software
Authors: Guzdial Mark
Published: July 2004

Squeak is a new programming language that is particularly appropriate for learning computer science. It offers an excellent infrastructure for interesting projects (e.g., multimedia, Web browsing and serving), and all source code is included (and written in Squeak) from the virtual machine, windowing, on up. Squeak is being used in a course on
Objects and Design
(focusing on the development of user interfaces), both to enhance the infrastructure for a course on, and to change how user interfaces are taught. Rather than teach a toolkit, the focus is now on teaching students
how to build
toolkits. This paper presents a pilot study suggesting benefits of our new approach.
Making parallel programming accessible to inexperienced programmers through cooperative learning
Authors: Pollock Lori , Jochen Mike
Published: July 2004

This paper describes how we utilized cooperative learning to meet the practical challenges of teaching parallel programming in the early college years, as well as to provide a more real world context to the course. Our main contribution is a set of cooperative group activities for both inside and outside the classroom, which are targeted to the computer science discipline, have received very positive student feedback, are easy to implement, and achieve a number of learning objectives beyond knowledge of the specific topic. These activities can be applied directly or be easily adapted to other computer science courses, particularly programming, systems, and experimental computer science courses.
“Alfonse, give me a call!”
Authors: Hartley Stephen J.
Published: July 2004

The SR programming language supports a simple and elegant set of abstractions for its model of distributed computing. The model provides an effective framework for demonstrating to students the different styles of distributed programming. A small Java toolkit based on SR's model is presented in this paper. This toolkit allows instructors to use the popular Java language as a platform in parallel and distributed processing courses.
What could be more SLic?
Authors: Smith King L. A. , Barr John , Coleman Ben
Published: July 2004

The last few years has seen renewed interest in teaching programming-in-the-large (PIL) and programming-in-context of a larger existing program (PIC) throughout the computer science curriculum. Although these skills have been a focus of software engineering courses and capstone projects, there is an emphasis to teach these skills in other courses across the curriculum. This paper addresses incorporation of PIL and PIC in the programming language course, and presents specific PIC and PIL projects using an interpreter for SLic, a simple logic (declarative) language. SLic itself is part of a family of interpreters in MuLE, a software environment designed to support interpreter-based projects in the programming languages course. MuLE is written in DrScheme (from Rice's PLT software project distributed under the GNU Library General Public License) and runs under Windows 95/98/NT/2000, MacOS, and Unix/X.
Design patterns for sorting
Authors: Nguyen Dung “Zung” , Wong Stephen B.
Published: July 2004

Drawing on Merritt's divide-and-conquer sorting taxonomy [1], we model comparison-based sorting as an abstract class with a template method to perform the sort by relegating the splitting and joining of arrays to its concrete subclasses. Comparison on objects is carried out via an abstract ordering strategy. This reduces code complexity and simplifies the analyses of the various concrete sorting algorithms. Performance measurements and visualizations can be added without modifying any code by utilizing the decorator design pattern. This object-oriented design not only provides the student a concrete way of unifying seemingly disparate sorting algorithms but also help him/her differentiate them at the proper level of abstraction.
Ancient Egyptian numbers
Authors: Gegg-Harrison Timothy S.
Published: July 2004

A critical piece of any successful curriculum is a robust example that permeates the key concepts of the field. For computer science, we refer to such an example as CS-complete. A good CS-complete example is applicable in CS1, CS2, and Discrete Mathematics. Approximately 4000 years ago, the ancient Egyptians used a numbering system that serves as a prototype CS-complete example. In this paper, we outline the use of Egyptian numbering system as an example that naturally extends through CS1, CS2, and Discrete Mathematics.
Real-time lab excercises
Authors: Herzog Erik , Loborg Peter , Nadjm-Tehrani Simin
Published: July 2004

This paper describes our design of real-time systems laboratories in an integrated theme of study which includes automatic control. The theme appears at the end of the third year of a 4,5 year master of engineering programme, which adopts Problem-Based Learning (PBL) as a main pedagogical method. We describe the rationale behind our choice of application area, the lab environment, and the operating system used. The paper concludes by giving some qualitative evaluations as well as some quantitative measures based on limited data.
Java power tools
Authors: Rasala Richard , Raab Jeff , Proulx Viera K.
Published: July 2004

The
Java Power Tools
or JPT is a Java toolkit designed to enable students to rapidly develop graphical user interfaces in freshman computer science programming projects. Because it is simple to create GUIs using JPT, students can focus on the more fundamental issues of computer science rather than on widget management. In a separate article[4], we will discuss with examples how the JPT can help freshman students to learn about the basics of algorithms, data structures, classes, and interface design. In this article, we will focus on how the JPT itself can be used as an extended case study of object-oriented design principles in a more advanced course.The fundamental design principles of the JPT are that
the elements of a graphical user interface should be able to be combined recursively as nested views
and that
the communication between these views and the internal data models should be as automatic as possible.
In particular, in JPT, the totality of user input from a complex view can be easily converted into a corresponding data model and any input errors will be detected and corrected along the way. This ease of communication is achieved by using string objects as a lingua franca for views and models and by using parsing when appropriate to automatically check for errors and trigger recovery. The JPT achieves its power by a combination of computer science and software design principles. Recursion, abstraction, and encapsulation are systematically used to create GUI tools of great flexibility. It should be noted that a much simpler pedagogical package for Java IO was recently presented in [9].
OO overkill
Authors: Astrachan Owen
Published: July 2004

Object oriented design patterns as popularized in [GHJV95] are intended to solve common programming problems and to assist the programmer in designing and developing robust systems. As first year courses increasingly emphasize object orientation, knowledge of design patterns and when to use them becomes an important component of the first year curriculum. Recent literature has focused on introducing the patterns to computer science educators, but not on the situations and contexts in which the patterns are appropriate. Design patterns and object orientation are parts of a methodology that scales to large systems. In this paper we show that these concepts do not always scale down. We analyze examples from current literature that would be simpler without patterns, and provide examples of when the same design patterns do make design and programs simpler.
TOS
Authors: Nicholas Tyrone , Barchanski Jerzy A.
Published: July 2004

This paper describes TOS - an educational distributed operating system implemented in Java. First the current trends in commercial operating systems are shortly presented and compared with several available educational operating systems. Next we give our rationals to use Java as the TOS implementation language. Then the architecture of the system and its components - launchers and servers are described. Finally we explain the advantages of this architecture and give some examples of possible student projects and assignments.
Architecture-dependent operating system project sequence
Authors: Donaldson John L.
Published: July 2004

Developing hands-on programming projects for a course on operating systems is a challenge. A wide variety of methods have been used and reported on at past SIGCSE meetings. A good summary of some of these projects can be found in [5]. One approach is to build a rudimentary operating system kernel from the bottom up. This approach necessarily involves some architecture-dependent coding. In this paper, the author describes his experience with such a project sequence based on the Intel protected mode architecture.
Integrating testing into the curriculum — arsenic in small doses
Authors: Jones Edward L.
Published: July 2004

Testing accounts for 50% of the cost of software, yet it receives little treatment in most curricula. This paper presents some approaches to giving all students multiple, incremental exposures to software testing throughout the curriculum. A unifying framework is presented which identifies a minimal set of test experiences, skills and concepts students should accumulate. The integrated approach combines common test experiences in core courses, an elective course in software testing, and volunteer participation in a test laboratory.
Designing better online teaching material
Authors: Brown Judy , Lu Jiayun
Published: July 2004

The creation of excellent online teaching material is challenging because it requires that designers are able to apply learning theories and usability principles. In this paper we describe a web-based tutorial we developed to teach database students about SQL-like operators that can be used to access data in data warehouses (very large collections of data used by analysts). This paper describes the processes and methods used to develop the tutorial and the techniques we used to test prototypes of our tutorial. We show how ideas from user-centered design and learning theory can be usefully combined to create a new process for developing online teaching material that meets learning and usability aims.
Advanced database concepts for undergraduates
Authors: Urban Susan D. , Dietrich Suzanne W.
Published: July 2004

This paper describes the development of a second database course for undergraduates, preparing students for the advanced database concepts they will experience in industry. Assuming an introductory course on relational database systems as a prerequisite, the topics addressed in the course include object-oriented data modeling, object-oriented database systems, object-relational database systems, Web access to databases, and professionalism and ethics. We present our experience with teaching the course, elaborating on the topics and assignments. We also present feedback from students and industry partners as well as our own assessment of future course refinements.
Assessing “hands on” skills on CS1 computer & network technology units
Authors: Veal D. , Maj S. P. , Duley Rick
Published: July 2004

Edith Cowan University (ECU) introduced a new curriculum in computer and network technology based upon a market analysis of employer expectations. Uniquely, within Australia, this curriculum has extensive workshop exercises that require students to work on equipment they are likely to meet in the workplace and as such the workshop environment is potentially hazardous to students. It was found that prospective employers often required both an assessment and an assurance that students following this curriculum could work to an acceptable industry standard. The traditional forms of assessment (examinations and assignments) did not fulfil this requirement. The authors therefore designed a Competency-Based Assessment (CBA) to measure procedural knowledge and skills. The CBA designed was simple, easy to use and can be implemented as part of a standard workshop without interrupting student activities.
Models and areas for CS education research
Authors: Stasko John , Guzdial Mark , Clancy Mike , Dale Nell , Fincher Sally
Published: July 2004

We hope to alert attendees of this panel to a number of aspects of CS education research:• previous work that provides good models for future research;• current projects and results;• areas that deserve more inquiry;• questions for which research is unlikely at the moment to yield useful information.The panel is aimed at people who don't need to be convinced about the value of CS education research, but who perhaps are unfamiliar with what's happening or how they might get involved themselves.
How mathematical thinking enchances computer science problem solving
Authors: Gries David , Marion Bill , Henderson Peter , Schwartz Diane
Published: July 2004

There are deep connections between algorithmic and mathematical thinking. Both construct "systems" --- computing systems in the algorithmic case, intellectual ones in mathematics --- from simple primitives. As Knuth notes in the preface to
The Art of Computer Programming,
"The construction of a computer program from a set of basic instructions is very similar to the construction of a mathematical proof from a set of axioms" [1]. Other connections include similar ways of organizing primitives into larger structures (
e.g.,
recursion in algorithms, recursion and induction in math; conditionals in algorithms, definition in cases and proof by cases in math), similar ways of using abstraction to manage complexity, and an underlying reliance on logic. In short, mathematics is not merely a tool for limited areas of computer science, it is a mindset that fundamentally improves one's ability to devise and implement algorithms. Computer science students therefore need to exercise their mathematical as well as their computational abilities, and computer science educators need to help students use both ways of thinking to solve computing problems.This panel illustrates specific ways in which mathematical reasoning enhances algorithmic problem solving, and provides educators with concrete examples and resources to use in their own teaching. Each panelist will present an exercise, classroom example, or similar item, from their own experience, and will demonstrate ways in which mathematical reasoning helps one solve and/or understand it. The audience will be invited to contribute their own examples and to comment further on the role of mathematical thinking in computer science problem solving.The panelists' and audience members' examples will be collected on a Web page for continuing reference. A prototype of this page is at http://www.cs.geneseo.edu/~baldwin/math-thinking/examples.html.
The university perspective
Authors: Owens Barbara Boucher , Hunt Fran , Reges Stuart , Laxer Cary
Published: July 2004

This panel discusses the granting of credit for AP CS by colleges and universities. Particularly with the change of the AP CS exam from Pascal to C++ last year, this panel is aimed both the collegiate and high school communities who are interested in comments from schools who have experience with AP CS students. Topics will include a short review of the AP curriculum, and some examples of what credit is given, how AP CS students are placed, and how the students perform in those and subsequent courses.
The use of robots in the undergraduate curriculum
Authors: Goldweber Michael , Congdon Clare , Fagin Barry , Hwang Deborah , Klassner Frank
Published: July 2004

Using the robot as a metaphor for assisting students in understanding problem solving in general, the algorithmic process, and the relationship between algorithms and computing agents is not new. While simulated robot environments have existed for many years (e.g. Karel the Robot[3]) it is only recently that the technology for inexpensively supplying undergraduates with real robots has become available. Lego Mindstorms, MIT Handyboards, the Rug Warrior, and others are examples of such systems. Programmable in familiar languages, including C, Ada, and Java, these systems allow for the creative exploration of important computer science concepts. Representing a variety of institution types the panelists will discuss their experiences in using hands-on robot-based projects for illustrating various important computer science concepts.
Status of information systems accreditation
Authors: Gorgone John T. , Lidtke Doris K. , Feinstein David
Published: July 2004

Accreditation standards have been developed for BS programs in Information Systems and have been widely reviewed. The standards drew heavily on the existing computer science accreditation standard and recent curriculum efforts in information systems. The effort was facilitated by support from the National Science Foundation (NSFDUE 9812278). Recently CSAB approved the process to accredit IS programs and that accreditation will begin in Fall 2002.