bluuebunny/crossref_metadata_2025 huggingface dataset:
Slicing concurrent programs
Authors: Nanda Mangala Gowri , Ramesh S.
Published: July 2004

Slicing is a well-known program analysis technique for analyzing sequential programs and found useful in debugging, testing and reverse engineering. This paper extends the notion of slicing to concurrent programs with shared memory, interleaving semantics and mutual exclusion. Interference among concurrent threads or processes complicates the computation of slices of concurrent programs. Further, unlike slicing of sequential programs, a slicing algorithm for concurrent programs needs to differentiate between loop-independent data dependence and certain loop-carried data dependences.

We show why previous methods do not give precise solutions in the presence of nested threads and loops and describe our solution that correctly and efficiently computes precise slices. Though the complexity of this algorithm is exponential on the number of threads, a number of optimizations are suggested. Using these optimizations, we are able to get near linear behavior for many practical concurrent programs.
Approaching MSIS 2000
Authors: Gorgone John T.
Published: July 2004

This column describes the background and process in creating a new graduate IS curriculum model and guidelines for the 21st Century. It also presents an overview of the MSIS program and the curriculum architecture.
A funny thing happened on the way to the formula
Authors: Johann Patricia
Published: July 2004

The concept of a function is arguably one of the most fundamental in computer science. It is frequently also one of the most problematic. In particular, students often have difficulty inferring, in a mathematically well-supported manner, equality of functions from equality of function values. That is, the transitions they make from demonstrations of equality of values of functions to demonstrations of equality of those functions themselves are often not well reasoned. In this complementary paper to [GK97] we describe one line of reasoning which we have found helps elucidate the mathematical principles according to which such inferences can correctly be made.
An exploration of novice programming errors in an object-oriented environment
Authors: Barr Matthew , Holden Sam , Phillips Dave , Greening Tony
Published: July 2004

When studying a programming language for the first time, the majority of student errors fall into broad (and well-documented) categories [3]. This paper aims to investigate errors made by first year students in Blue: A new, object-oriented language specifically designed at the University of Sydney for teaching novice students [2].These errors were investigated by a survey delivered over the World-Wide Web and consisting of multiple choice and free-form short-answer questions. The results of the survey suggest that a student who learns with Blue is no more likely to make errors that are commonly made by novice programmers, although is not necessarily better equipped to design and write code in an object-oriented paradigm. More research is indicated to make statements about the latter.
Experience teaching an introduction to DBMS
Authors: Guimaraes Mario A. M.
Published: July 2004

This paper describes the methodology used to teach an introductory Database Management System course. Although all content description refers exclusively to this class, the methodology can be used to teach other computer science courses. There are several unique aspects of the course. Students do a preliminary presentation and a final presentation of their projects. During the preliminary presentation, they perform the role of the client (inversion of roles); while during the final presentation, the class performs the role of the client and students evaluate their colleagues.
Encryption algorithms made natural
Authors: Koshelev Misha , Kreinovich Vladik , Longpré Luc
Published: July 2004

Modern cryptographic algorithms such as DES, IDEA are very complex and therefore difficult to learn. Textbooks explain in detail
how
these algorithms work, but they usually do not explain
why
these algorithms were designed as they were. In this paper, we explain the
why,
which hopefully will make cryptographic algorithms easier to learn.
An asynchronous distance-learning course in data communications and networks
Authors: Blum Howard , Sachs David
Published: July 2004

This paper describes the concept of an asynchronous distance-learning course and its application to an elective course,
Data Communications and Networks.
Goals for the asynchronous course included providing facilities and opportunities for interaction and exchange of ideas among class members, analogous to the interactions which occur in a conventional class. Implemented as a Web-based course, a discussion board and email were heavily used to support class interactions. Some experiences with the initial Web-based offering of the course are described.
Integrating computer science and information systems
Authors: Bock Douglas B. , Klepper Robert W. , Schrage John F. , Stephen G. Gregory , Waxman Bernard
Published: July 2004

The Master of Science, major in Computing and Information Systems (CIS) is a graduate program offered jointly by the graduate faculties of the Department of Computer Science in the School of Engineering and the Department of Computer Management and Information Systems in the School of Business. We describe the nature of the program and emphasizes the advantages of a joint degree program that spans academic units. We also touch on problems that may be encountered and how they can be overcome. The successes realized and situations encountered by this merger may benefit other institutions that face similar resource constraints.
Teaching with Electronic Collaborative Learning Groups
Authors: Fåhræus Eva R. , Bridgeman Noel , Rugelj Joze , Chamberlain Barbara , Fuller Ursula
Published: July 2004

The integration of technology and collaborative groups has seen the development of electronic collaborative learning groups.Technology supports collaborative learning by allowing collaboration between distributed participants replacing face-to-face meetings. Technology also provides access to supporting tools and methods such as libraries, chat-rooms, and meeting protocols.One major benefit of using electronic collaborative learning groups is the ability to provide for the uniqueness of each student in a group. However, managing electronic collaborative learning groups is not simple, and the role of the teacher changes from knowledge provider to facilitator. This has implications for the amount of technical support that the teacher may require.
OMEGA
Authors: Cîmpan Sorana , Oquendo Flavio
Published: July 2004

This paper presents an environment for monitoring software-intensive processes: the

O
mega

environment (O
mega
stands for
On-line Monitoring Environment: General and Adaptable
). The environment provides the language

O
mega
/MDL

(
Monitoring Definition Language
) for defining monitoring models as well as a mechanism for the execution of such models

O
mega
/EM

(
Execution Mechanism
). The executing monitoring models (i.e. monitoring systems), observe the subject process and detect deviations between it and an expected behavior, i.e. indicated by the process model instantiation. For monitoring modeling, O
mega
proposes a novel approach based on fuzzy logic. This approach allows to establish the level of conformance between the process enactment and the process model for different aspects of the process, like progress, cost, structure (order between activities), etc. The use of fuzzy logic enables the system to cope with uncertain and imprecise information.
Dynamically generating problems on static scope
Authors: Kumar Amruth
Published: July 2004

Solving problems is an integral part of learning in Computer Science. In order to provide students with a vast supply of problems with which to practice, we propose to use applets that automatically generate problems. In this paper, we first discuss the capabilities required of such applets, and then, present the design and features of an applet we have developed to automatically generate problems on static scope in Pascal.
Structuring the student research experience
Authors: Bernat Andrew , Teller Patricia J. , Gates Ann , Delgado Nellie
Published: July 2004

The benefits of working in a research group are clear: students develop domain expertise, gain an understanding and appreciation of the research process and its practice, and acquire team, communication, problem-solving, and higher-level thinking skills. Students with this experience are better equipped to make informed judgments about technical matters and to communicate and work in teams to solve complex problems. However, it is difficult to provide a quality experience to large numbers of students, particularly to students of differing abilities.The Systems and Software Engineering Affinity Research Group model provides a socialization mechanism and infrastructure that supports the development and management of large research groups that engage undergraduate and graduate students, who have a wide range of skill levels and experiences, in research and projects. This non-hierarchical model integrates students into both small research groups and an encompassing large research group, and uses structured activities to develop their research, technical, communication, and group skills.In this paper we introduce the model and report how the model meets independently developed Best Practice guidelines for student research experiences and we provide indicators of success for use by other projects.
The anthropology semaphores
Authors: Kolikant Yifat Ben-David , Ben-Ari Mordechai , Pollack Sarah
Published: July 2004

This paper describes research into the conceptions of students studying concurrency, using qualitative methods that originated in anthropological field work. We were able to obtain a deep understanding of students' mental models of semaphores: they construct consistent, though non-viable, models of semaphores, and they use them in patterns without understanding the synchronization context. We used the results to improve our teaching of concurrency, for example, by carefully defining the semaphore model and exercising the model outside of a problem-solving context.
Teaching object-orientation with the Object Visualization and Annotation Language (OVAL)
Authors: Raner Mirko
Published: July 2004

Object-oriented techniques and technologies are omnipresent in all branches of modern software development and systems design. Still today there is an enormous demand for training in the area of object-oriented analysis, design and programming.Several languages and notations have been developed for the visual presentation of object-oriented ideas and designs (eg, the Booch method [1], OMT [3] or the emerging standard UML [4]). Such languages or notations are an excellent means of communication and documentation amongst experts. However, for novice trainings they are not very suitable. Instead, they raise additional difficulties: not only a large number of new ideas and a new way of thinking has to be learned, but also a highly non-intuitive graphic notation to present these ideas.The newly developed Object Visualization and Annotation Language (OVAL) is a simple illustrative notation which aims at OO novices. It visualizes the key ideas of object-orientation in a very intuitive way and was especially designed to assist in the process of teaching the way of object-oriented thinking.
Teaching tools for software engineering education
Authors: Dick Martin , Postema Margot , Miller Jan
Published: July 2004

This paper examines a set of teaching tools in the Software Engineering Practice course at Monash University. Analyzing various aspects of the course and student survey response to their value provides evaluation of the overall success of the tools. The paper demonstrates that a successful teaching program needs to combine a range of teaching tools to achieve its aims.
Systems analysis with attitude!
Authors: Abi-Raad Maurice
Published: July 2004

Have you ever been overruled by your students in critical decisions relating to their learning? Have you ever attended your own classes as a guest consultant with pre-defined scope of input? Have you ever suffered from the fact that each student is different, and you have a standard program for all? Have you ever empowered your students, and watch them exceed your expectation? The only important question is whether you have the courage to throw out your safety nets and Do It. For those who are looking to be involved in an exciting, challenging, stimulating and rewarding teaching exercise, Systems Analysis with attitude is definitely it. Interested! We were too when we attempted this experiment that we do recommend to collegues in this always-evolving analysis discipline.
Instructional instruments for Web group learning systems
Authors: Ou Kuo-Liang , Chen Gwo-Dong , Liu Chen-Chung , Liu Baw-Jhiune
Published: July 2004

Owing to the lack of face-to-face interactions, students using a web-based learning system are likely to study alone and with relatively little classmate support and pressure. Teachers in a web-based learning system may apply the group-learning model to overcome this problem. Therefore, teachers first need to organize, manage, and monitor the group learning. Additionally, they must take appropriate actions based on teaching strategies to improve the learning achievements of the students. To perform these tasks effectively, the teachers must obtain relevant information by searching and analyzing the huge amount of web-access logs or by monitoring web interactions. This will be burdensome and difficult to do well for the teachers. This work presents novel methodologies for developing instruments to assist teachers in performing grouping, intervention and strategy analysis. The proposed methodologies apply data mining tools provided by existing database management systems. A tool is initially R developed to assist in organizing learning groups according to teacher specifications. Database techniques, including multidimensional cube, are then applied to make student web logs meaningful and helpful to teachers in managing group learning. The associate rule mining tool is finally employed to assist teachers in analyzing their pedagogical strategies. These tools relieve the teacher of tedious data collection and analysis, and thus can focus on managing the groups to promote student learning achievement.
Colorful examples for elaborating exploration of regularities in high-school CS1
Authors: Ginat David
Published: July 2004

Exploration of regularities is a key element in problem analysis - the primary stage of algorithm design. The recognition of regularities during problem analysis elicits underlying principles of the design. While university teachers are well aware of the significance of regularities, high-school computer science teachers often fail to appreciate it, and focus on technical details of program design and implementation. We believe that the elaboration of regularities in high-school computer science education enhances teachers' and students' scientific conception of computer science.In this paper we present an approach for elaborating the role of regularities. The elaboration is done by directing the students, at the primary stage of problem analysis, to look for problem characteristics from various angles, in different ways, and for diverse tasks. Our approach is based on colorful and attractive examples, which include challenging problems and games, often with physical objects. Such examples enrich the students' intuition, and leave a long-term imprint.
Making students read and review code
Authors: Zeller Andreas
Published: July 2004

The
Praktomat
system allows students to
read, review, and assess each other's programs
in order to improve quality and style. After a successful submission, the student can retrieve and review a program of some fellow student selected by Praktomat. After the review is complete, the student may obtain reviews and re-submit improved versions of his program. The reviewing process is independent of grading; the risk of plagiarism is narrowed by
personalized assignments
and
automatic testing
of submitted programs. In a survey, more than two thirds of the students affirmed that reading each other's programs improved their program quality; this is also confirmed by statistical data.
A generic model for on-line learning
Authors: Rosbottom John , Crellin Jonathan , Fysh Dave
Published: July 2004

We describe a generic model for on-line learning which has been used to
develop
a course unit in Computer Science, and to
evaluate
a course unit in Economics.The model may be used to produce a
template
for on-line learning resources. Alternatively a template developed intuitively by an experienced teacher may be
evaluated
using the generic model. Using these approaches both the model and the template may be refined.We also study the use of the model and templates as ways of
disseminating
web-based on-line learning among colleagues in Economics and Computer Science departments.
Apprenticeship learning of software engineering using Webworlds
Authors: Chalk Peter
Published: July 2004

There is an increasing use of the World Wide Web in the teaching of topics in computer science. Many examples involving animation have been reported and other modeling environments (or 'Webworlds'), such as diagramming tools, are emerging. The software engineering curriculum includes topics such as testing and design, which can be supported by graphical editors. This paper presents three examples of software produced to support learning in this area and a detailed analysis of the results of one pilot research study. Taken as a whole, the evidence is argued to support the case for apprenticeship learning and that the Web provides an opportunity to exploit this, if collaborative and other tools properly scaffold it.
Integrating interactive computer-based learning experiences into established curricula
Authors: Spalter Anne Morgan , Simpson Rosemary Michelle
Published: July 2004

Educators who wish to integrate interactive computer-based learning experiences into established courses must contend not only with the difficulty of creating quality digital content but with the often equally difficult challenge of reconfiguring their courses to use such materials. We describe our experiences with the Exploratories Project at Brown University [8] and the use of exploratories in an introductory computer graphics programming course [4]. We offer examples of both success and failure, with the goal of helping other educators avoid both painful mistakes and lost time spent coping with unforeseen logistical and pedagogical concerns. Among the lessons we learned: planning can't begin too early for the integration of such materials into an established curriculum, and all possible methods of integration should be considered before committing to any specific approach.
An international student/faculty collaboration
Authors: Last Mary Z. , Daniels Mats , Almstrum Vicki L. , Erickson Carl , Klein Bruce
Published: July 2004

Students of today need to be prepared to work in globally distributed organizations. Part of that preparation involves teaching students to work effectively in teams to solve problems. Students also must be able to work with individuals located at distant sites where there is no or very little face-to-face interaction. The Runestone project, an international collaboration between two universities, adds new dimensions to student teamwork, requiring students to handle collaboration that is remote, cross-cultural, and technically challenging. Runestone is a three-year project funded by the Swedish Council for the Renewal of Undergraduate Education. A pilot study in 1998 was followed by a full-scale implementation in 1999 with another implementation ongoing in 2000.Each time this global cooperation project is run, both students and faculty learn important lessons in how to work with each other in a virtual environment. This paper discusses both student and faculty learning outcomes for Runestone 1999.
Experience with an automatically assessed course
Authors: English John , Siviter Phil
Published: July 2004

This paper describes our experiences of developing and running an introductory module for first year Computing undergraduates. The 'Supporting Technologies' module is intended to equip students with basic computing skills that they will need for the rest of their course. A novel feature of the work discussed here is that several different automated assessment tools and techniques are integrated into a common framework sharing a common results database. This allows a wide range of different assessment formats within the same module framework.
A case for data-driven testing
Authors: Greening Tony , Stevens Glenn , Stratton David
Published: July 2004

This paper describes a novel approach to the on-line assessment of large groups of students, in which it may be desirable to maintain common questions between the groups. It is clear from the literature that computer based assessment has the potential to dramatically reduce the effort involved in testing and marking however problems arise where the cohort of students is larger than the number of available computers. However, the opposite situation is often true in practice, due to the perceived need to design multiple tests. The solution described here uses a small computer laboratory (20 machines) to administer a test to a series of groups of students in existing lab sessions. Each group receives the same set of questions but the data to which the questions apply, and hence the test answers, vary from group to group. The data from tests that have been applied to students is analysed to determine whether discussions with early candidates have influenced the performance of students in later testing sessions.
Our method to teach algorithmic development
Authors: Rosso Ana , Daniele Marcela
Published: July 2004

In this paper we outline a method of teaching algorithmic, based on problem-solving and stating the necessary stages to be considered when writing an algorithm which solves a given problem.
DOMOSIMCOL
Authors: Bravo C. , Redondo M. A. , Ortega M. , Bravo J.
Published: July 2004

The learning systems based on the solution of real projects have proved to be efficient in the different educational levels. With the use of simulation environments these systems achieve a combination between the student monitoring and discovery learning. In this work we present tools that enable the creation of a plan in a collaborative way and the use of simulation in learning communities to the solution of design problems applied to the domotics domain
Publish your Excel grade book on the Web
Authors: Lorenzen Torben
Published: July 2004

I have created an Excel spreadsheet to use as my course grade book. I will begin with an overview of such a sample grade book that I use in a course, teaching students about Microsoft Office. I will then tell you how I use the grade book, the equations that make it work, how to download it from the web, and finally how to modify it.
How to Get a Good Review
Authors: Ben-Ari Mordechai
Published: July 2004

For several years I have been reviewing submissions for SIGCSE conferences and, unfortunately, recommending rejection of the majority of the submissions. While some undoubtedly deserved the recommendation, others described work that is potentially interesting and relevant, but the papers were so poorly written that it was impossible to judge the ideas fairly. I am writing this message to help SIGCSE members write better papers and improve their chances of acceptance.A review is like an audition: you have prepared your presentation for weeks or months, yet you only have a few minutes to convince a director (who knows nothing about you) that you are better than those appearing before or after you. The key words here are that the reviewer knows nothing about you. You may have been working on a project for months, but you only have four pages in which to "perform." You have two tasks when you write a paper. First, you must structure your paper so that your ideas and work are clearly and fully described within the page limit. Second, and more importantly, you must place your work in context so that the reviewer can decide if it is significant and relevant.
The universe model
Authors: Behrends Reimer , Stirewalt R. E. Kurt
Published: July 2004

We present the universe model, a new approach to concurrency management that isolates concurrency concerns and represents them in the modular interface of a component. This approach improves program comprehension, module composition, and reliability for concurrent systems. The model is founded on designer-specified invariant properties, which declare a component's dependencies on other concurrent components. Process scheduling is then automatically derived from these invariants. We illustrate the advantages of this approach by applying it to a real-world example.
Compiler and tool support for debugging object protocols
Authors: Butkevich Sergey , Renedo Marco , Baumgartner Gerald , Young Michal
Published: July 2004

We describe an extension to the Java programming language that supports static conformance checking and dynamic debugging of object “protocols,” i.e., sequencing constraints on the order in which methods may be called. Our Java protocols have a statically checkable subset embedded in richer descriptions that can be checked at run time. The statically checkable subtype conformance relation is based on Nierstrasz' proposal for regular (finite-state) process types, and is also very close to the conformance relation for architectural connectors in the Wright architectural description language by Allen and Garlan. Richer sequencing properties, which cannot be expressed by regular types alone, can be specified and checked at run time by associating predicates with object states. We describe the language extensions and their rationale, and the design of tool support for static and dynamic checking and debugging.
Implicit context
Authors: Walker Robert J. , Murphy Gail C.
Published: July 2004

Software systems should consist of simple, conceptually clean software components interacting along narrow, well-defined paths. All too often, this is not reality: complex components end up interacting for reasons unrelated to the functionality they provide. We refer to knowledge within a component that is not conceptually required for the individual behaviour of that component as extraneous embedded knowledge (EEK). EEK creeps into a system in many forms, including dependences upon particular names and the passing of extraneous parameters. This paper proposes the use of implicit context as a means for reducing EEK in systems by combining a mechanism to reflect upon what has happened in a system, through queries on the call history, with a mechanism for altering calls to and from a component. We demonstrate the benefits of implicit context by describing its use to reduce EEK in the Java™ Swing library.
The impact project (panel session)
Authors: Osterweil Leon J. , Clarke Lori A. , Evangelist Michael , Kramer Jeffrey , Rombach Dieter , Wolf Alexander L.
Published: July 2004

The purpose of this panel is to introduce the Impact Project to the community, and to engage the community in a broad ranging discussion of the project's goals, approaches, and methods. Some of the project's early findings and directions will be presented.
A compositional approach to statecharts semantics
Authors: Lüttgen Gerald , von der Beeck Michael , Cleaveland Rance
Published: July 2004

Statecharts is a visual language for specifying reactive system behavior. The formalism extends traditional finite-state machines with notions of hierarchy and concurrency, and it is used in many popular software design notations. A large part of the appeal of Statecharts derives from its basis in state machines, with their intuitive operational interpretation. The classical semantics of Statecharts, however, suffers from a serious defect; it is not compositional, meaning that the behavior of system descriptions cannot be inferred from the behavior of their subsystems. Compositionality is a prerequisite for exploiting the modular structure of Statecharts for simulation, verification, and code generation, and it also provides the necessary foundation for reusability.

This paper suggests a new compositional approach to formalizing Statecharts semantics as flattened labeled transition systems in which transitions represent system steps. The approach builds on ideas developed for timed process calculi and employs structural operational rules to define the transitions of a Statecharts expression in terms of the transitions of its subexpressions. It is first presented for a simple dialect of Statecharts, with respect to a variant of Pnueli and Shalev's semantics, and is illustrated by means of a small example. To demonstrate its flexibility, the proposed approach is then extended to deal with practically useful features available in many Statecharts variants, namely state references, history states, and priority concepts along state hierarchies.
Automating first-order relational logic
Authors: Jackson Daniel
Published: July 2004

An automatic analysis method for first-order logic with sets and relations is described. A first-order formula is translated to a quantifier-free boolean formula, which has a model when the original formula has a model within a given scope (that is, involving no more than some finite number of atoms). Because the satisfiable formulas that occur in practice tend to have small models, a small scope usually suffices and the analysis is efficient.

The paper presents a simple logic and gives a compositional translation scheme. It also reports briefly on experience using the Alloy Analyzer, a tool that implements the scheme.
On the formalization of architectural types with process algebras
Authors: Bernardo Marco , Ciancarini Paolo , Donatiello Lorenzo
Published: July 2004

Architectural styles play an important role in software engineering as they convey codified principles and experience which help the construction of software systems with high levels of efficiency and confidence. We address the problem of formalizing and analyzing architectural styles in an operational setting by introducing the intermediate abstraction of architectural type. We develop the concept of architectural type in a process algebraic framework because of its modeling adequacy and the availability of means, such as Milner's weak bisimulation equivalence, which allow us to reason compositionally and efficiently about the well formedness of architectural types.
The shape of things to come?
Authors: Rashid Richard F.
Published: July 2004

The future of software engineering isn't what it used to be. The nature of the software we write, the reasons we write it and the way we write it and maintain it have changed rapidly and dramatically over the last few years. And software development is likely change even faster over the next decade. In this talk I will reflect on how commercial software has evolved and what it might look like in the not-to-distant future.
Computer literacy and the older learner: a computer department's response
Authors: Maren Jerry
Published: July 2004

As a computer science educator it is personally gratifying to learn of the success achieved by former students as they experience the thrill of accomplishment in their first computer related job. However, the student who shared one such experience with me last summer was uniquely different from the typical college student. She was over 55" and back to work for the first time in 25 years. Mastery of word processing and spreadsheet software applications had led to her placement in a job employing those skills. Her employer s pleasure with the high quality of her work was as much a joy to me as it was to her. Six months prior to that day she had never worked on a computer and had no thought of doing so. Her progress and subsequent success, as well as that of 15 other older workers, has motivated this article, as well as additional computer training classes for the older workers in our community.
A simple java package for GUI-like interactivity
Authors: Koffman Elliot , Wolz Ursula
Published: July 2004

This paper discusses the motivation for a simple package designed to incorporate user interactivity into a first course in computer science. The package enables novice programmers to build programs with GUI-like interactivity while maintaining good design principles. An advantage of this package is that it is easy to implement using the Swing class. Therefore, it can be used as a case study to illustrate Java features.
Using an isolated network laboratory to teach advanced networks and security
Authors: Hill John M. D. , Carver Curtis A. , Humphries Jeffrey W. , Pooch Udo W.
Published: July 2004

This paper discusses the use of an isolated network laboratory to teach computer security using persistent cooperative groups and an active learning approach. Computer security and computer security education are areas of increasing importance as computer systems become more interconnected. When offered, undergraduate and graduate computer security courses are routinely taught using a traditional lecture format. If the course includes a class project, the class project is limited in scope and constitutes a relatively small portion of the student's grade. This paper examines a different approach in which the class project is the dominant factor in the student's grade. The students work in persistent cooperative teams as either a black or gold team. Black teams attempt to break into other black team computers or attack the gold team. The gold team operates Windows NT, LINUX, and Solaris-based servers and attempts to defend their servers and role-play system administrators. The entire exercise takes place in an isolated lab so as to separate student class activities from the rest of the departmental intranet. Four years of experience running the class with this format suggests that the use of persistent cooperative groups and active learning are effective approaches for teaching network security and are preferred over a lecture-based course.
Javiva
Authors: Turner Joseph A. , Zachary Joseph L.
Published: July 2004

The ability to think abstractly about the components of a computer program is critical for computer science students. A student who has not yet developed this ability tends to view a program as an unstructured collection of statements and expressions. Introductory computer science textbooks promote the use of pre-conditions, post-conditions, and abstraction functions as techniques for fostering abstract thinking. Existing programming languages and tools, however, do not generally support these techniques. Consequently, we have built and are beginning to experiment with Javiva. Javiva extracts pre-conditions, post-conditions, and abstraction functions---included as stylized comments in Java source files---and uses them to create instrumented class files. When these instrumented class files are run, they automatically diagnose and report violations by methods of pre- and post-conditions. These classes also exploit abstraction functions to automatically produce abstract visualizations of their objects.
Rethinking CS0 with JavaScript
Authors: Reed David
Published: July 2004

Traditional approaches to CS0 have emphasized either breadth, through an overview of computer science, or depth, through intensive programming. This paper describes an alternative teaching method that strikes a balance between these two approaches through the use of JavaScript and the World Wide Web. By taking advantage of JavaScript's simplicity and natural Web-based interfaces, the CS0 course described here is able to maintain a strong emphasis on programming and problem-solving, integrate programming skills with Web technology, and still provide reasonable breadth on general computer science topics. This balance between depth and breadth makes the course attractive to both non-majors and majors alike, providing a broad perspective of the field as well as a foundation for continuing studies in computer science.
The Khepera robot and the kRobot class
Authors: Harlan Robert M. , Levine David B. , McClarigan Shelley
Published: July 2004

We discuss a class interface for the Khepera robot that makes the robot an excellent platform for undergraduate robotics courses and robot-based lab exercises in other courses. The interface hides low-level robot-computer communication and permits the building of derived classes that encapsulate related base behaviors relevant for higher-order tasks.
Open artificial intelligence - one course for all
Authors: Merzbacher Matthew
Published: July 2004

Upper-division courses contain some of the most attractive topics in computer science, such as artificial intelligence (AI). Unfortunately, layers of prerequisites restrict AI to advanced computer science students and a separate course for non-majors is not always curricularly feasible. Instead, upper-division AI can be taught in a way that has no prerequisites while retaining the rigor of an upper-division course. This paper includes the syllabus for such an "open AI" course and discusses experiences, positive and negative, with it.
Teaching the human aspect of software engineering - a case study
Authors: Hazzan Orit
Published: July 2004

This paper describes a course I taught at the Technion --- The Israel Institute of Technology --- which addressed human aspects of Software Engineering. More specifically, three human aspects involved in developing software systems were the focus of the course: problem solving methodologies in general and their application in developing software systems in particular; mental processes; and social processes of software-system developers.
A computer program to aid assignment of student project groups
Authors: Redmond Michael A.
Published: July 2004

Group projects are a valuable part of the computer science curriculum. Group work can be enhanced if formation of groups is not via self-selection by the students themselves. Students who are
assigned
to groups are more likely to be exposed to other students with different backgrounds and abilities from which they can learn new things. However in a university with students having a wide mix of schedules, a crucial aspect of successful group formation is compatible time-schedules within a group. This paper describes a computer program designed to aid assignment to groups while helping to ensure that groups have suitable outside-of-class meeting times.
Electronic peer review and peer grading in computer-science courses
Authors: Gehringer Edward F.
Published: July 2004

We have implemented a peer-grading system for review of student assignments over the World-Wide Web and used it in approximately eight computer-science courses. Students prepare their assignments and submit them to our Peer Grader (PG) system. Other students are then assigned to review and grade the assignments. The system allows authors and reviewers to communicate with authors being able to update their submissions. Unique features of our approach include the ability to submit arbitrary sets of Web pages for review, and mechanisms for encouraging careful review of submissions. We have used the system to produce high-quality compilations of student work. Our assignment cycle consists of six phases, from signing up for an assignment to Web publishing of the final result. Based upon our experience with PG, we offer suggestions for improving the system to make it more easily usable by students at all levels.
An interactive dynamic model for integrating knowledge management methods and knowledge sharing technology in a traditional classroom
Authors: Phoha Vir V.
Published: July 2004

This paper reports an interactive dynamic model using Continuous Knowledge Management methods and Knowledge Sharing technology to integrate the acquisition of skills and relevant information (knowledge level) into diverse, individualized, concurrent learning processes in a traditional classroom setting. As opposed to a passive introduction of technology to facilitate the traditional learning processes a Web based active learning and continuous evaluation process was created which integrates
objective
scientific
knowledge
relating to course content,
subjective knowledge
obtained through personal interactions and
empirical knowledge
collected during the learning process. Knowledge Management, an emerging area of Artificial Intelligence, encompasses identifying, mapping, and managing intellectual assets to generate new knowledge for competitive advantage and for sharing of technology. The Web-based model of knowledge management discussed here allows a diverse group of learners to progressively interact and participate in the learning process, providing non-threatening self-evaluation and just-in-time individualized feedback to the learners and efficient tracking and supervision tools to the instructor. CS1003, a required general education class provides an ideal application of this model as the course draws from a diverse body of students ranging from history to math majors and from freshmen to seniors. The instructional design of this course using the interactive dynamics of Knowledge Management includes (i) provision of course archives and relevant static information as a passive repository, (ii) Web Discussion Forums, electronic chats and email communication for active learning and continuous interaction, (iii) an intelligent self-evaluation and grade reporting system for non-threatening self-testing and what-if analysis of performance, and (iv) a dynamic student feedback system including individualized supervision and anonymous feedback. Application of this instructional process enhanced the goals of the course from mere computer literacy to what the 1999 NRC Report calls Fluency in Information Technology (FIT). Three kinds of knowledge requirements are identified for FIT: (1) Contemporary skills, (2) Foundational concepts, and (3) Intellectual capabilities. This model is broadly applicable to extend the benefits of traditional classroom instruction to focus diverse intellectual abilities and interests in a collaborative learning process. Formal and informal evaluation support this claim, demonstrating that the transition from purely traditional teaching to a high degree of technology fluency can be painless, efficient and effective in preparing the students for a technology intensive information age.
IPP
Authors: Estell John K.
Published: July 2004

The portfolio is a well-established method for documenting student learning outcomes. This paper presents the development of a web-based interactive programming portfolio methodology at our institution. This methodology allows the reviewer to easily interact with the computer program under review through the use of Java applets. Both an evaluation form as well as detailed rubrics for the evaluation of the portfolio entry is accessible from the web page containing the portfolio entry. These resources allow reviewers to easily submit their feedback electronically to our students.
Using handheld computers in the classroom
Authors: Jipping Michael J. , Krikke Joshua , Dieter Sarah , Sandro Samantha
Published: July 2004

Handheld computers provide a unique opportunity for teaching computer science. They are inexpensive (and keep dropping in price); they are powerful; they are accessible by students; and they run standard programming interfaces. These facets combine to provide a unique platform for teaching. This paper documents a project to integrate handheld machines into the classroom. We develop the case for using these machines; we overview our plans to use them; and we showcase two applications that we are using in classes. These applications are available for download from the Internet and represent a beginning for our project.
Contributing to success in an introductory computer science course
Authors: Wilson Brenda Cantwell , Shrock Sharon
Published: July 2004

This study was conducted to determine factors that promote success in an introductory college computer science course. The model included twelve possible predictive factors including math background, attribution for success/failure (luck, effort, difficulty of task, and ability), domain specific self-efficacy, encouragement, comfort level in the course, work style preference, previous programming experience, previous non-programming computer experience, and gender. Subjects included 105 students enrolled in a CS1 introductory computer science course at a midwestern university. The study revealed three predictive factors in the following order of importance: comfort level, math, and attribution to luck for success/failure. Comfort level and math background were found to have a positive influence on success, whereas attribution to luck had a negative influence. The study also revealed by considering the different types of previous computer experiences (including formal programming class, self-initiated programming, internet use, game playing, and productivity software use) that both a formal class in programming and game playing were predictive of success. Formal training had a positive influence and games a negative influence on class grade.
Assembly language through the Java virtual machine
Authors: Bredlau Carl , Deremer Dorothy
Published: July 2004

Student understanding of choices and design decisions about instruction formats, addressing, instruction types, and flow of control is developed through the assembly level. We propose the Java Virtual Machine (JVM) as the architecture for teaching assembly language. The paper describes how to use the JVM as a teaching tool for a sophomore level Assembly Language and Computer Architecture course.
A proposed new high level abstraction for computer technology
Authors: Maj S. P. , Veal D. , Duley R.
Published: July 2004

Computer technology can be described using a range of models based on different levels of detail e.g. semiconductors, transistors, digital circuits. Such models are designed to progressively hid irrelevant detail and yet provide sufficient information to be useful for communication, design and documentation. However, developments in computer technology have resulted in a low cost, heterogeneous modular architecture that is difficult to model using current methods. This paper proposes a new generic method of modeling computer technology at a higher level of abstraction than those currently used. Investigations to date indicate that this model is independent of architectural detail and can therefore accommodate changes in technology. This new model is more directly relevant to the cheap, low-cost modular architectures in use today. Furthermore, all work to date has strongly indicated it may be useful as the basis of a new pedagogical framework for teaching not only introductory but also more advanced computer technology.
A comprehensive curriculum for IT education and workforce development
Authors: Golshani F. , Panchanathan S. , Friesen O. , Park Y. C. , Song J. J.
Published: July 2004

Noting the shortage of IT professionals nationally [1], we propose a comprehensive curriculum that supports a variety of programs geared to all ages from early school years to retirement and beyond. Current IT workforce development efforts are limited to training, and have not as yet focused on education and professional development. Largely, this is due to a lack of a science underpinning for IT related curricula. Without such a unified science component, a structured organization of information related concepts cannot be derived.Our proposal includes the development of a number of programs addressing the needs of a variety of learners ranging from elementary school through college and beyond. Seven programs, each with a specific emphasis for various groups, are being developed. Such essential issues as industrial-academic liaisons, workforce (re)training, promotional and awareness programs, teacher training, and IT professional role redefinition, are integral pieces of this project. All developments will be firmly founded on the scientific framework of information science and engineering [2].This work is supported by NSF grant DUE-9950168.