bluuebunny/crossref_metadata_2025 huggingface dataset:
The concorde doesn't fly anymore
Authors: Ben-Ari Mordechai (Moti)
Published: January 2005

While computing technology has undoubtedly changed the world in which we live, the changes have been exaggerated. Talk of a hi-tech internet-driven revolution during the last decade is inaccurate from a historical perspective: (a) It belittles previous technological achievements; for example, the landings on the moon between 1969-1972 were achieved with less computing capability than a PDA has today. (b) So much of the "new" technology dates back thirty years or more; for example, how many of our students know when the first email was sent? This loss of historical perspective has led to demands for an artifact-driven curriculum that I believe is inadequate for the education of future computer scientists and computational engineers. (The latter is a new term I wish to propose for people engaged in the scientifically-based design and construction of systems that perform computations. It is linguistically modeled on the terms mechanical and electrical engineer, and is intended to take the place of the term software engineer.) A comparison of the CC2001 curriculum with the curriculum of a traditional, "non-revolutionary" engineering discipline points to what I believe the future of CS education should be.
Coupling pair programming and writing
Authors: VanDeGrift Tammy
Published: January 2005

Pair Programming has been successful in many introductory computer science courses. Its success has manifested in increased retention rates, better performance on programming tasks, increased confidence, and decreased frustration. This paper highlights experiences using pair programming coupled with individual written reports in a large, introductory computer science course. Through analysis of survey data and written reports, our study shows that students perceive benefits in pair programming, such as those documented earlier (social structure, peer help, less frustration, reduced workload). Regarding the written reports, students cited benefits such as a chance to summarize their project, to reflect on the code, and to use new vocabulary. We discuss what we learn about students' processes, their challenges, and the resources they use for supporting their learning.
Design, science, and engineering topics?
Authors: McCrickard D. Scott , Chewar C. M. , Somervell Jacob
Published: January 2005

Reacting to challenges that have been observed in human-computer interaction (HCI) education, as well as the multidisciplinary design, science, and engineering underpinnings, we investigate a pedagogical approach based on case methods. Our study of various case method techniques in an undergraduate HCI class provides insights into challenges that can be expected in the employment of case methods, student learning outcomes, and considerations for HCI curriculum planning. In general, case methods show great promise with a wide variety of topics, and we present broad recommendations for future work that will improve integration of HCI professional practice, research, and education.
Term project user interface specifications in a usability engineering course
Authors: Leventhal L. M. , Barnes J. , Chao J.
Published: January 2005

Term projects in an undergraduate Usability Engineering (UE) course provide opportunities for students to put the abstract ideas of what they have learned in class into practice. Projects provide students with opportunities to learn that the process of usability engineering is rarely as smooth as it would seem in the abstract. Moreover, term projects give students the opportunity to learn about specific methodologies and notations.One critical phase of the term project is the user interface specification; in our undergraduate UE course we have found the specification phase to be a significant pedagogic challenge. Key elements to that challenge are: 1) Presenting the project requirements in such a way that the students can generate a specification, 2) Defining the form and format for student work, 3) Teaching the process of specification and 4) Assessing the students' work. In this paper, we describe our approach to each of these four challenges. Since 1996, we have had good success with our approach; however, student data suggests that students still find the UE specification process difficult. In Spring 2003, we added some extra steps in our process that seem to lead to greater student understanding and success.
Taking advantage of national science foundation funding opportunities
Authors: Cunningham Steve , McDuffie Ernest , Taylor Harriet
Published: January 2005

This session will highlight programs in the National Science Foundation EHR Division of Undergraduate Education and CISE Division of Experimental and Integrative Activities that are of interest to college faculty, discussing the requirements and guidelines for programs in these areas. It will include a presentation of the characteristics of a competitive proposal and the proposal and review processes, and participants will be encouraged to explore their ideas with the presenters.
Information technology accreditation activities
Authors: Lawson Eydie , Lidtke Doris K. , Price Barbara
Published: January 2005

Programs in Information Technology (IT) have begun at many universities over the past decade and many are now eager for accreditation. This paper describes the activities undertaken in preparation for accreditation of IT programs by the Computing Accreditation Commission of ABET.
Experiences with a tablet PC based lecture presentation system in computer science courses
Authors: Anderson Richard , Anderson Ruth , Simon Beth , Wolfman Steven A. , VanDeGrift Tammy , Yasuhara Ken
Published: January 2005

Computer science instructors frequently teach using slides displayed with a computer and a data projector. This has many advantages, e.g., ability to present prepared materials and ease of switching the display to a development environment during mid-presentation. However, existing computer-based presentation systems severely limit flexibility in delivery, hindering instructors' extemporaneous adaptation of their presentations to match their audiences. One major limitation of computer-based systems is lack of support for high-quality handwriting over slides, as with overhead projectors and other manual presentation systems. We developed and deployed Classroom Presenter, a Tablet PC-based presentation system that (1) combines the advantages of existing computer-based and manual presentation systems and (2) builds on these systems, introducing novel affordances. Classroom Presenter has been used in 25 Computer Science courses at three universities. In this paper we describe the system, summarize results from its deployment, and detail several novel uses of the system by instructors in computer science courses.
Using pen-based computers across the computer science curriculum
Authors: Berque Dave , Bonebright Terri , Whitesell Michael
Published: January 2005

This paper describes our use of pen-based electronic classrooms to enhance several computer science courses. After presenting our motivation for undertaking this work, and its relevance to the growing interest in using tablet PC's in the classroom, we present an overview of our use of this technology to engage students during class. Finally, we present the students' reaction to the approach as measured through attitude surveys and a focus group.
Assessment of a course redesign
Authors: Herrmann Nira , Popyack Jeffrey L. , Char Bruce , Zoski Paul
Published: January 2005

We assess the effectiveness of an extensive redesign of the first Computer Programming course offered to computer science and computer engineering majors. Our goals were to improve student learning while reducing costs by making use of substantial Web-based course material and course management tools, including multi-level online modules that individualize instruction and enable students to self-schedule learning each week. DFW rates and costs were significantly reduced by the redesign.
PL-detective
Authors: Diwan Amer , Waite William M. , Jackson Michele H.
Published: January 2005

The educational literature recognizes that people go through a number of stages in their intellectual development. During the first stage, called received knowledge or dualism, people expect knowledge to be handed to them by authority figures (thus "received") and think in terms of black and white (thus "dualism"). Our experience indicates that many computer science students are at this first stage of learning. To help students move beyond this stage, we describe a system and strategy, the PL-detective, to be used in a "concepts of programming languages" course. Assignments using this system directly confront students with the notion that there are often multiple equally good answers and that discussion with students (rather than asking the instructor) is an effective way of learning how to reason.
Highlighting programming language issues using mixed language programming nn Maple and C
Authors: Phillips Andrew T.
Published: January 2005

Three examples using mixed language programming in Maple and C are provided for the express purpose of highlighting, in a practical way, various issues normally discussed in a traditional programming languages class only as theoretical concepts. The three examples highlight concepts in parameter passing techniques, storage order choices, native machine types and sizes, and the handling of single and multi-dimensional arrays when dealing with legacy code.
Cryptography and computer security for undergraduates
Authors: De Palma Paul , Frank Charles , Gladfelter Suzanne , Holden Joshua
Published: January 2005

The panel discusses solutions to the problem of computer security education.
Seven design rules for teaching students sound encapsulation and abstraction of object properties and member data
Authors: Wick Michael R. , Stevenson Daniel E. , Phillips Andrew T.
Published: January 2005

Because encapsulation is a difficult concept for students to implement correctly, we propose a set of seven software design rules to be used as an aid for teaching the appropriate design and use of encapsulation of object properties.
Adding objects to the traditional ACM programming contest
Authors: Andrianoff Steven K. , Hunkins Dalton R. , Levine David B.
Published: January 2005

Programming contests have a long established role as co-curricular activities. But as programming methodology has changed, the programming contest problems have not reflected these changes. In this paper, we describe a way to modernize the traditional ACM-style contest while preserving the problem solving aspects. We do so by introducing a new type of problem that requires that solutions interact with pre-defined classes. We discuss the effects of this change on a contest conducted for high school students.
Attribute based compiler implemented using visitor pattern
Authors: Neff Norman
Published: January 2005

In our compiler course for undergraduate students, we use a class of attribute grammars to specify type information, target code, and other properties calculated for the source program. In the design of the compiler, a modification of the visitor design pattern allows us to transparently compute the attributes. Within our framework, implementation is straightforward; the emphasis of the course shifts to theory and specification. In several offerings of the course, students have implemented parts of a highly modular compiler for a small, statically typed object oriented language.
A visual and interactive automata theory course with JFLAP 4.0
Authors: Cavalcante Ryan , Finley Thomas , Rodger Susan H.
Published: January 2005

We describe the instructional software JFLAP 4.0 and how it can be used to provide a hands-on formal languages and automata theory course. JFLAP 4.0 doubles the number of chapters worth of material from JFLAP 3.1, now covering topics from eleven of thirteen chapters for a semester course. JFLAP 4.0 has easier interactive approaches to previous topics and covers many new topics including three parsing algorithms, multi-tape Turing machines, L-systems, and grammar transformations.
Taming the tiger
Authors: Frens Jeremy D.
Published: January 2005

The next version of the Java language (Software Development Kit 1.5) will include generics, an enhanced
for
loop, boxing and unboxing of primitive types, typesafe enumerated types, static import, variable arguments, and metadata. This new version is a significant change of the language itself, adding many features that will impact the use of Java in computer science curricula. Fortunately, this new version provides several features that instructors have wanted in the language from its beginning.
Contemplate sorting with columnsort
Authors: McCann Lester I.
Published: January 2005

The efficiency of Internet search engines has made it trivial for students to find implementations of standard algorithms. This fact has led computer science educators to be more creative with their assignments to encourage students to create their own implementations. Unfortunately, excessive creativity can obscure learning objectives, particularly for less insightful students. We demonstrate that recasting the parallel sorting algorithm Columnsort for a uniprocessor environment provides the foundation for a variety of sorting assignments that can engage students while not obscuring educational objectives.
Teaching growth of functions using equivalence classes
Authors: Roussos Constantine
Published: January 2005

Understanding
growth of functions
using the standard big O definition and notation is a challenge for many undergraduate students. This paper

presents an approach to teaching
growth of functions
that utilizes equivalence classes and partial ordering,

identifies those mathematical concepts students should comprehend in order to understand the principles underlying
growth of functions
,

demonstrates pedagogical inadequacies in existing order of complexity notation and definitions and

gives a rationale for restricting functions under consideration to positive-valued, monotonic increasing.
Increasing high school girls' self confidence and awareness of CS through a positive summer experience
Authors: Pollock Lori , McCoy Kathleen , Carberry Sandra , Hundigopal Namratha , You Xiaoxin
Published: January 2005

This paper describes the design, implementation, and impact evaluation of a summer program designed to attract high school girls to entering an information technology field for their college major. Our main contributions include an analysis of immediate and longer term surveys from both the student participants and the female teaching assistants, curriculum and pedagogy highlights of the program, and lessons learned from the planning and implementation experiences.
A CS1 course designed to address interests of women
Authors: Rich Lauren , Perry Heather , Guzdial Mark
Published: January 2005

Literature on women in computing points out that computer science is not being effective at attracting and retaining women.
Introduction to Media Computation
is a new CS1 aimed especially at non-majors which was designed explicitly to address the concerns of women in computer science, such as the lack of relevance and creativity. The course is contextualized around the theme of manipulating and creating media. Of the 121 students who took the course (2/3 female), only three students dropped (all male), and 89% completed the course with a grade C or better. This paper presents data from interviews with women in the Media Computation class, then contrasts with interviews in a more traditional CS1.
CS1 assessment using memory diagrams
Authors: Holliday Mark A. , Luginbuhl David
Published: January 2005

Understanding the execution of an object-oriented program can be a challenge for a student starting a CS1 course. We believe that a type of diagram that we call a memory diagram can aid the student in understanding object-oriented programming and can assist the instructor in assessing the student's understanding.Memory diagrams focus on how, in an abstract sense, the memory of the machine changes as the program executes. Though memory diagrams are a simple idea, by careful use of shape and placement, a number of key points about the meaning of a program fragment can be conveyed visually. We have found a correlation between a student's ability to construct these diagrams and that student's comprehension of object-oriented concepts. We feel that this correlation indicates that memory diagrams can be used as an assessment technique that, in turn, can be used to improve student learning.
Core empirical concepts and skills for computer science
Authors: Braught Grant , Miller Craig S. , Reed David
Published: January 2005

Educators are increasingly acknowledging that practical problems in computer science demand basic competencies in experimentation and data analysis. However, little effort has been made towards explicitly identifying those empirical concepts and skills needed by computer scientists, nor in developing methods of integrating those concepts and skills into CS curricula. In this paper, we identify a core list of empirical competencies and motivate them based on established courses outside of computer science, their potential use in standard CS courses, and their application to real-world problems. Sample assignments that facilitate the integration of these competencies into the CS curriculum are also discussed.
Evaluation of subsetting programming language elements in a novice's programming environment
Authors: DePasquale Peter , Lee John A. N. , Pérez-Quiñones Manuel A.
Published: January 2005

In this paper, we evaluate the effects of applying programming language subsets to the programming environment used by novice (CS1) students in a closed-laboratory setting, as well as reducing the complexity of the user interface for the environment. Our goal in this effort was to assess if such interface and application-level changes adversely impact the student or hinder the later migration to a traditional professional-strength programming environment.We focus on the comparison of the quantitative data captured from the closed-laboratory sessions (assignment grades, number of syntax / semantic errors, and the number of compilation / execution attempts) involving subjects that used a new programming environment featuring a less complex interface in two forms: one lacking support of language subsets, and one supporting the application of language subsets.We found that while using the environment supporting the application of language subsets, there was no difference in the compilation-attempt rate, the number of errors did not increase, and student grades were equivalent between the experiment groups. Additionally, following a migration to the professional environment from the simplified environment, student grades were equivalent to those that had used the professional environment throughout the experiment. Student reaction to the experimental environment was very positive, especially related to the removal of unused tools and project management features.
Raising motivation in real-time laboratories
Authors: Amirijoo Mehdi , Te"anoviC Aleksandra , Nadjm-Tehrani Simin
Published: January 2005

Real-time systems is a topic that one cannot overlook in an engineer's education. However, teaching real-time systems in an undergraduate syllabus is a challenging experience due to conflicting constraints placed on such a course. In this paper we present a new setup for laboratories in the real-time systems course that successfully meets the constraints of mass education, stable environment management, short time span for the labs, and still enables deep involvement of students in the central topic of resource allocation with high motivation.
Illustrating computer hardware concepts using PIC-based projects
Authors: Sarkar Nurul I. , Craig Trevor M.
Published: January 2005

We are developing a series of interesting projects that give students a hands-on introduction to computer hardware concepts. Our projects are designed around the PIC16F84, a powerful 8-bit microcontroller chip that sells for less than $10. The projects are suitable for classroom use in introductory level courses about computer hardware. The effectiveness of these projects has been evaluated both formally by students (student evaluation forms) and informally - through discussion within the teaching team. The feedback from students indicates that the development and implementation of the projects were successful. This paper describes the details of the projects completed to date, their overall effectiveness and our plans for further projects.
"But it looks right!"
Authors: Ginat David , Astrachan Owen , Garcia Daniel D. , Guzdial Mark
Published: January 2005

It is not rare that programming students are surprised when they encounter bugs in their program, which "looks completely right". Such a phenomenon expresses lack of awareness of analysis, design, and testing habits, which yield undesirable outcomes. The special session will focus on various programming aspects that may look seemingly right to students, but yield a buggy, wrong result. Various aspects will be displayed, illustrated, and discussed with the audience, in order to better understand the characteristics of bugs and ways of coping with them in our teaching.
Enhancing apprentice-based learning of Java
Authors: Kölling Michael , Barnes David J.
Published: January 2005

Various methods have been proposed in the past to improve student learning by introducing new styles of working with assignments. These include problem-based learning, use of case studies and apprenticeship. In most courses, however, these proposals have not resulted in a widespread significant change of teaching methods. Most institutions still use a traditional lecture/lab class approach with a strong separation of tasks between them. In part, this lack of change is a consequence of the lack of easily available and appropriate tools to support the introduction of new approaches into mainstream courses.In this paper, we consider and extend these ideas and propose an approach to teaching introductory programming in Java that integrates assignments and lectures, using elements of all three approaches mentioned above. In addition, we show how the BlueJ interactive programming environment [7] (a Java development environment aimed at education) can be used to provide the type of support that has hitherto hindered the widespread take-up of these approaches. We arrive at a teaching method that is motivating, effective and relatively easy to put into practice. Our discussion includes a concrete example of such an assignment, followed by a description of guidelines for the design of this style of teaching unit.
Bringing J2ME industry practice into the classroom
Authors: Umphress David A. , Cross James H. , Jain Jhilmil , Meda Nischita , Barowski Larry A.
Published: January 2005

This paper describes efforts to use industry wireless software development practices in the classroom. Nokia's OK Java 2 Platform Micro Edition (J2ME) application certification program was chosen for use in a core set of wireless software engineering courses. The adaptation process included 1) modifying Nokia OK application standards for classroom use as examples of what is expected of industry-quality software; 2) incorporating Nokia OK software development tools into a student-friendly software development environment; and 3) implementing in-house Nokia OK certification procedures as a basis for assessing student projects and providing feedback.
Teaching wireless networking with limited resources
Authors: Richards Brad , Stull Benjamin
Published: January 2005

The rapid growth of wireless communications services and networks has led departments to consider offering elective courses on the topic. Textbooks exist that can help support such a course, but providing students with hands-on wireless networking experience can be difficult and expensive.We present the outline of a wireless networking course that can be offered with minimal resources, and describe our experiences using the approach. The students who took the initial offering of the course gained hands-on experience with wireless networking, did traditional sockets programming, and acquired the theoretical foundations of both traditional and wireless networking.Students implement a simplified IEEE 802.11 Wireless Ethernet MAC layer as a course project. In our case, the implementations took advantage of the Cybiko, a $50 wireless handheld computer targeted at teenagers. Our materials are currently being ported to other platforms, including Bluetooth-enabled Palms and networks of workstations. The latter platform will allow this project to be conducted without any special resources.
Running on the bare metal with GeekOS
Authors: Hovemeyer David , Hollingsworth Jeffrey K. , Bhattacharjee Bobby
Published: January 2005

Undergraduate operating systems courses are generally taught using one of two approaches:
abstract
or
concrete
. In the abstract approach, students learn the concepts underlying operating systems theory, and perhaps apply them using user-level threads in a host operating system. In the concrete approach, students apply concepts by working on a real operating system kernel. In the purest manifestation of the concrete approach, students implement operating system projects that run on real hardware.GeekOS is an instructional operating system kernel which runs on real hardware. It provides the minimum functionality needed to schedule threads and control essential devices on an x86 PC. On this foundation, we have developed projects in which students build processes, semaphores, a multilevel feedback scheduler, paged virtual memory, a filesystem, and inter-process communication. We use the Bochs emulator for ease of development and debugging. While this approach (tiny kernel run on an emulator) is not new, we believe GeekOS goes further towards the goal of combining realism and simplicity than previous systems have.
Design patterns for semaphores
Authors: Reek Kenneth A.
Published: January 2005

This paper describes two design patterns that are powerful tools to help teach how semaphores are used to solve synchronization problems. The patterns are general enough to be used with many different types of problems, yet are simple enough for students to understand and apply effectively.
Agent-based cooperative learning
Authors: Soh Leen-Kiat , Jiang Hong , Ansorge Charles
Published: January 2005

This paper presents an innovative multiagent system to support cooperative learning among students both in the real classrooms and in distance education. The system, called I-MINDS, consists of a group of intelligent agents. A teacher agent monitors the student activities and helps the teacher manage and better adapt to the class. A student agent, on the other hand, interacts with the teacher agent and other student agents to support cooperative learning activities behind-the-scene for a student. Two I-MINDS innovations are (a) agent-federated "buddy group" formation and (b) automated ranking of questions and responses. We have tested our I-MINDS prototype with experiment and control groups to evaluate the impact of I-MINDS in learning. The results are encouraging.
Effective features of algorithm visualizations
Authors: Saraiya Purvi , Shaffer Clifford A. , McCrickard D. Scott , North Chris
Published: January 2005

Many algorithm visualizations have been created, but little is known about which features are most important to their success. We believe that pedagogically useful visualizations exhibit certain features that hold across a wide range of visualization styles and content. We began our efforts to identify these features with a review that attempted to identify an initial set of candidates. We then ran two experiments that attempted to identify the effectiveness for a subset of features from the list. We identified a small number of features for algorithm visualizations that seem to have a significant impact on their pedagogical effectiveness, and found that several others appear to have little impact. The single most important feature studied is the ability to directly control the pace of the visualization. An algorithm visualization having a minimum of distracting features, and which focuses on the logical steps of an algorithm, appears to be best for procedural understanding of the algorithm. Providing a good example for the visualization to operate on proved significantly more effective than letting students construct their own data sets. Finally, a pseudocode display, a series of questions to guide exploration of the algorithm, or the ability to back up within the visualization did not show a significant effect on learning.
An extensible framework for providing dynamic data structure visualizations in a lightweight IDE
Authors: Hendrix T. Dean , Cross James H. , Barowski Larry A.
Published: January 2005

A framework for producing dynamic data structure visualizations within the context of a lightweight IDE is described. Multiple synchronized visualizations of a data structure can be created with minimal coding through the use of an external viewer model. The framework supplies a customizable viewer template as well as high-level APIs to a graph drawing library and the Java Debugger Interface. Initial classroom use has demonstrated the framework's ease of use as well as its potential to as an aid to student learning.
The role of computer science in undergraduate bioinformatics education
Authors: Burhans Debra T. , Skuse Gary R.
Published: January 2005

The successful implementation of educational programs in bioinformatics presents many challenges. The interdisciplinary nature of bioinformatics requires close cooperation between computer scientists and biologists despite inescapable differences in the ways in which members of these professions think. It is clear that the development of quality curricula for bioinformatics must draw upon the expertise of both disciplines. In addition, biologists and computer scientists can benefit from opportunities to carry out interdisciplinary research with one another. This paper examines the role of computer science in undergraduate bioinformatics education from the perspectives of two bioinformatics program directors. Their respective programs exemplify two substantively different approaches to undergraduate education in bioinformatics due to the fact that they are at markedly different institutions. One institution is a large, technical university, offering both undergraduate and graduate degrees in bioinformatics while the other is a small, Jesuit liberal arts college with an undergraduate program in bioinformatics. Despite these differences there is considerable overlap with respect to the role of computer science. This paper discusses the ways in which computer science has been integrated into these two undergraduate bioinformatics programs, compares alternative approaches, and presents some of the inherent challenges.
CS++
Authors: Boyle Roger , Clark Martyn
Published: January 2005

University education in computer science requires that students learn something of the nature of the discipline. We argue that, in addition to content knowledge, two of the many things the educated computer scientist might know about are the computer science pantheon and the metaphorical structure of the discipline's technical language.
A concepts-first introduction to computer science
Authors: Goldman Kenneth J.
Published: January 2005

We present a unique "concepts-first" curriculum that exposes students without programming experience to the intellectual depth and breadth of computer science through hands-on experience with software development. The curriculum is supported by JPie, a tightly integrated programming environment that enables live construction of Java applications through direct manipulation of graphical representations of programming abstractions. The curriculum, projects, and classroom experience are described.
Science of computing suite (SOCS)
Authors: Burch Carl , Ziegler Lynn
Published: January 2005

Over the last ten years, our department's breadth-first introductory course has evolved independently of other survey courses in computer science. Due to its success, we duplicated the ideas into our course for non-majors, and this has also proven successful. None of the published resources match our vision for these courses, and so the department has developed its own. In this paper, we describe the design of the majors course, and we introduce a variety of resources developed for both courses. These resources, which could be useful in many other courses also, are freely available through the Web.
Panel session
Authors: Denning Peter J. , Darken Rudolph , Roberts Eric , Guzdial Mark
Published: January 2005

Questions and answers about the great principles framework for computing and its impact on the organization and content of curriculum, with special attention to communicating our field, teaching programming, and appealing to a diverse audience.
AlgoVista
Authors: Collberg Christian , Kobourov Stephen G. , Westbrook Suzanne
Published: January 2005

A?goVista is a web-based search engine that assists programmers to find algorithms and implementations that solve specific problems. The search engine is not keyword based but rather requires users to provide (input ? output) samples that describe the behavior of their needed algorithm. The system is easy to use. To search for a particular algorithm or classify a combinatorial structure a user simply
draws
the query in a drawing pane on a web browser. The result of the search is a list of links to web resources describing or providing implementations of the algorithm.A?goVista has many interesting applications in an educational setting. The search engine can help research students classify obscure problems and locate algorithms that would otherwise be hard to find in textbooks. Students can also add calls in their own programs to A?goVista's database of executable problem specifications in order to dynamically check the correctness of their programs. Finally, instructors can use A?goVista to set novel assignments in algorithms and data structures classes.This paper briefly describes A?goVista and reports on its use in two algorithms and theory classes, one at the undergraduate and one at the graduate level.
Design patterns for marine biology simulation
Authors: Nguyen Dung "Zung" , Ricken Mathias , Wong Stephen
Published: January 2005

We specify and implement a GUI application that simulates marine biological systems by making extensive use of object-oriented design patterns.The key design patterns are model-view-control, observer/observable, visitor, command, factory method and decorator. These design patterns help delineate the roles and responsibilities of the objects in the system, establish loose coupling between objects and arrange for the objects to communicate and cooperate with one another at the highest level of abstraction. The result is an application that exhibits minimal control flow, yet is powerful, robust, flexible and easy to maintain.Our work entails a non-trivial redesign of the current AP Computer Science Marine Biology Simulation case study and may serve as a case study for an introductory "object-first" curriculum.
MODeLeR
Authors: Coffey John W. , Koonce Robert
Published: January 2005

This paper contains a description of MODeLeR, a Multimedia Object Design Learning Resource. The impetus for the creation of MODeLeR was to provide an authentic learning environment for the study of object-oriented design to augment intermediate level programming classes. The Resource affords active, collaborative learning experiences in object modeling with the goal of helping students to gain design capabilities in UML and to appreciate the need for design that they often do not perceive since the programs they write are relatively small. Students typically create several different UML diagrams. This paper describes the MODeLeR environment and a pilot study in its use. This paper contains results of both a quantitative study and a qualitative evaluation of the Resource.
Benefits of using socially-relevant projects in computer science and engineering education
Authors: Buckley Michael , Kershner Helene , Schindler Kris , Alphonce Carl , Braswell Jennifer
Published: January 2005

In an attempt to bridge a local technology gap, potentially provide software to health care organizations serving the needs of handicapped clients in the Western NY area, and provide innovative and interesting projects for our capstone design classes, the Computer Science and Engineering department at the University at Buffalo (SUNY) began soliciting projects from local organizations in need. The projects have been integrated into required senior-level undergraduate courses. The practical benefits of project experience on student education, and the benefits of providing useful software to the target organizations, were anticipated, but the experiences have proven to be much more. Students have responded with intensity and philanthropy. The clients have participated in the classroom experience as both recipients and teachers. The program has rescued students at academic risk, and the school is enjoying an enhanced reputation in the community. This paper explores positive and cautionary issues regarding the effort.
A reusable, academic-strength, metrics-based software engineering process for capstone courses and projects
Authors: Conn Richard
Published: January 2005

This paper describes a mature Software Engineering Process that may be applied to capstone courses, student projects, and research projects in a university environment. This process, based in part on the Team Software Process of the Software Engineering Institute, features mature software engineering best practices, including extensive use of metrics to gain insight into process effectiveness and product quality. It is designed to be executed in a single 16-week semester, and it can easily be modified for a longer time frame. It is also designed for the academic culture: (1) it executes as a communicating sequential process running in parallel with and passing information to a series of in-class course presentations and (2) it takes into account that the students cannot devote full time to this one project. This process is independent of the computer language used and any project-specific technology (so it may be applied to software-only projects, robotics projects, smart device projects, embedded programming projects, and any other kind of software-intensive system project). This process is reusable without modification, or it may be tailored. To support tailoring, the process is described using meta data in a format that may be analyzed by automated tools to generate a hypertext document. This process has been tested by using it in a capstone course.
Computing curricula 2004
Authors: Shackelford Russell , Cassel Lillian , Cross James , Impagliazzo John , Lawson Eydie , LeBlanc Richard , McGettrick Andrew , Sloan Robert , Topi Heikki
Published: January 2005

In 2001, the ACM and the IEEE-CS published
Computing Curricula 2001
which contains curriculum recommendations for undergraduate programs in computer science. That report also called for additional discipline-specific volumes for each of computer engineering, information systems, and software engineering. In addition, it called for an Overview Volume to provide a synthesis of the various volumes. The Computing Curricula 2004 Task Force has undertaken a two-pronged strategy to fulfill the latter charge. The purpose of this session is to present an overview of the Task Force's work and to generate feedback from the SIGCSE membership to the Task Force about the direction and plans we have undertaken.
Microarchitecture Optimizations for Exploiting Memory-Level Parallelism
Authors: Chou Yuan , Fahs Brian , Abraham Santosh
Published: January 2005

The performance of memory-bound commercial applicationssuch as databases is limited by increasing memory latencies. Inthis paper, we show that exploiting memory-level parallelism(MLP) is an effective approach for improving the performance ofthese applications and that microarchitecture has a profound impacton achievable MLP. Using the epoch model of MLP, we reasonhow traditional microarchitecture features such as out-of-orderissue and state-of-the-art microarchitecture techniques suchas runahead execution affect MLP. Simulation results show that amoderately aggressive out-of-order issue processor improvesMLP over an in-order issue processor by 12-30%, and that aggressivehandling of loads, branches and serializing instructionsis needed to attain the full benefits of large out-of-order instructionwindows. The results also show that a processor's issue windowand reorder buffer should be decoupled to exploit MLP more efficiently.In addition, we demonstrate that runahead execution ishighly effective in enhancing MLP, potentially improving the MLPof the database workload by 82% and its overall performance by60%. Finally, our limit study shows that there is considerableheadroom in improving MLP and overall performance by implementingeffective instruction prefetching, more accurate branchprediction and better value prediction in addition to runahead execution.
TSOtool
Authors: Hangal Sudheendra , Vahia Durgam , Manovit Chaiyasit , Lu Juin-Yeu Joseph
Published: January 2005

In this paper, we describe TSOtool, a program to check thebehavior of the memory subsystem in a shared memorymultiprocessor. TSOtool runs pseudo-randomly generatedprograms with data races on a system compliant with theTotal Store Order (TSO) memory consistency model; it thenchecks the results of the program against the formal TSOspecification. Such analysis can expose subtle memory errorslike data corruption, atomicity violation and illegalinstruction ordering.While verifying TSO compliance completely is an NP-completeproblem, we describe a new polynomial timealgorithm which is incorporated in TSOtool. In spite of beingincomplete, it has been successful in detecting several bugs inthe design of commercial microprocessors and systems,during both pre-silicon and post-silicon phases of validation.
Low-Latency Virtual-Channel Routers for On-Chip Networks
Authors: Mullins Robert , West Andrew , Moore Simon
Published: January 2005

The on-chip communication requirements of manysystems are best served through the deployment of a regularchip-wide network. This paper presents the design of alow-latency on-chip network router for such applications.We remove control overheads (routing and arbitrationlogic) from the critical path in order to minimise cycle-timeand latency. Simulations illustrate that dramatic cycle timeimprovements are possible without compromising routerefficiency. Furthermore, these reductions permit flits to berouted in a single cycle, maximising the effectiveness of therouter's limited buffering resources.
Immunet
Authors: Puente V. , Gregorio J. A. , Vallejo F. , Beivide R.
Published: January 2005

A new and efficient mechanism to tolerate failures ininterconnection networks for parallel and distributedcomputers, denoted as Immunet, is presented in this work.In the presence of failures, Immunet automatically reactswith a hardware reconfiguration of the surviving networkresources. Immunet has four important advantages overprevious fault-tolerant switching mechanisms. Its lowhardware costs minimize the overhead that the networkmust support in absence of faults. As long as the networkremains connected, Immunet can tolerate any number offailures regardless of their spatial and temporalcombinations. The resulting communication infrastructureprovides optimized adaptive minimal routing over thesurviving topology. The system behavior under successivefailures exhibits graceful performance degradation.Immunet reconfiguration can be totally transparent tothe applications running on the parallel system as they willonly be affected by the loss of those data packetscirculating through the broken components. The rest of thepackets will suffer only a tolerable delay induced by thetime employed to perform the automatic networkreconfiguration. Descriptions of the hardware networkarchitecture and detailed synthetic and execution-drivensimulations will demonstrate the benefits of Immunet.
Adaptive Cache Compression for High-Performance Processors
Authors: Alameldeen Alaa R. , Wood David A.
Published: January 2005

Modern processors use two or more levels ofcache memories to bridge the rising disparity betweenprocessor and memory speeds. Compression canimprove cache performance by increasing effectivecache capacity and eliminating misses. However,decompressing cache lines also increases cache accesslatency, potentially degrading performance.In this paper, we develop an adaptive policy thatdynamically adapts to the costs and benefits of cachecompression. We propose a two-level cache hierarchywhere the L1 cache holds uncompressed data and the L2cache dynamically selects between compressed anduncompressed storage. The L2 cache is 8-way set-associativewith LRU replacement, where each set can storeup to eight compressed lines but has space for only fouruncompressed lines. On each L2 reference, the LRUstack depth and compressed size determine whethercompression (could have) eliminated a miss or incurs anunnecessary decompression overhead. Based on thisoutcome, the adaptive policy updates a single globalsaturating counter, which predicts whether to allocatelines in compressed or uncompressed form.We evaluate adaptive cache compression usingfull-system simulation and a range of benchmarks. Weshow that compression can improve performance formemory-intensive commercial workloads by up to 17%.However, always using compression hurts performancefor low-miss-rate benchmarks-due to unnecessarydecompression overhead-degrading performance byup to 18%. By dynamically monitoring workload behavior,the adaptive policy achieves comparable benefitsfrom compression, while never degrading performanceby more than 0.4%.
The Case for Lifetime Reliability-Aware Microprocessors
Authors: Srinivasan Jayanth , Adve Sarita V. , Bose Pradip , Rivers Jude A.
Published: January 2005

Ensuring long processor lifetimes by limiting failuresdue to wear-out related hard errors is a critical requirementfor all microprocessor manufacturers. We observethat continuous device scaling and increasing temperaturesare making lifetime reliability targets even harder to meet.However, current methodologies for qualifying lifetime reliabilityare overly conservative since they assume worst-caseoperating conditions. This paper makes the case thatthe continued use of such methodologies will significantlyand unnecessarily constrain performance. Instead, lifetimereliability awareness at the microarchitectural design stagecan mitigate this problem, by designing processors that dynamicallyadapt in response to the observed usage to meeta reliability target.We make two specific contributions. First, we describean architecture-level model and its implementation, calledRAMP, that can dynamically track lifetime reliability, respondingto changes in application behavior. RAMP isbased on state-of-the-art device models for different wear-outmechanisms. Second, we propose dynamic reliabilitymanagement (DRM) - a technique where the processorcan respond to changing application behavior to maintainits lifetime reliability target. In contrast to currentworst-case behavior based reliability qualification methodologies,DRM allows processors to be qualified for reliabilityat lower (but more likely) operating points than theworst case. Using RAMP, we show that this can save costand/or improve performance, that dynamic voltage scalingis an effective response technique for DRM, and that dynamicthermal management neither subsumes nor is sub-sumedby DRM.