bluuebunny/crossref_metadata_2025 huggingface dataset:
Hybrid learning - a safe route into web-based open and distance learning for the computer science teacher
Authors: Rosbottom John
Published: July 2004

The hybrid learner is located on a continuum between the traditional student attending face to face classes in a University and the distance learner who may never visit the institution, except perhaps to graduate. Modern methods of web-based open and distance learning make hybrid learning attractive and accessible to students.Computer Science students in particular make very good hybrid students because the content of the Computer Science curriculum has a strong practical element that is conducive to independent learning methods, and because they have a familiarity with the tools used in hybrid learning.Suggestions are given on how a teacher may develop web-based open and distance learning (WEB-ODL) for hybrid learners.
Characteristics of programming exercises that lead to poor learning tendencies
Authors: Carbone Angela , Hurst John , Mitchell Ian , Gunstone Dick
Published: July 2004

In most introductory programming courses tasks are given to students to complete as a crucial part of their study. The tasks are considered important because they require students to apply their knowledge to new situations. However, often the tasks have not been considered as a vehicle that can direct learning behaviours in students. In this paper attention is paid to features of programming tasks that led to the following three poor learning behaviours: non-retrieval, lack of internal reflective thinking and lack of external reflective thinking. The data gathered for this study is provided by students and tutors, and describes the students' engagement in the tasks. The paper concludes with a list of generic improvements that should be considered when formulating programming exercises to minimise poor learning behaviours in students.
EXercita
Authors: Gregorio-Rodríguez C. , Llana-Díaz L. , Palao-Gostanza P. , Pareja-Flores C. , Martínez-Unanue R. , Velázquez-Iturbide J. Á.
Published: July 2004

EXercita is a system designed to archive and publish programming exercises. It consists of a repository of structured documents, each describing an exercise, and several tools to manage it. Documents are marked-up with an extension of LaTeX we have designed, called eXercita, and can be automatically published as PostScript files or Web pages. In addition, exercises can be automatically published as a hierarchical Web site that mirrors the structure of the repository.
Treating computer science as science as
Authors: Laxer Cary
Published: July 2004

When I teach sorting algorithms in our introductory computer science class, I always wonder how I can convince the students of the efficiency of Ο (n log n) sorts, and their complex code, vs. the ease of writing Ο (n
2
) sorts. With today's personal computers, even bubble sorting an array of a few thousand items appears to occur instantaneously. In addition, most textbooks provide the program code for implementing most of the standard sorting algorithms, such as bubble sort, selection sort, and quick sort. Since our introductory course has a closed lab period each week, I looked for something to do with my students when it came to sorting. Making them type in the code that was in the book seemed a waste of time.
Exploring recursion in Hilbert curves (poster session)
Authors: Rasala Richard
Published: July 2004

This tip will describe the use of a graphical tool to explore the recursive Hilbert curves and will explain some of the mathematical information that can be visualized using this tool.
Principles of survey research
Authors: Kitchenham Barbara A. , Pfleeger Shari Lawrence
Published: July 2004

In this article, we discuss how to construct a questionnaire. We point out the need to use any previous research results to reduce the overheads of survey construction. We identify a number of issues to consider when selecting questions, constructing questions, deciding on the type of question and finalizing the format of the questionnaire.
Software development process
Authors: Sagheb-Tehrani Mehdi , Ghazarian Arbi
Published: July 2004

A successful project demands a correct and thorough requirements specification. This paper proposes techniques and strategies for handling business rules and requirements. The guidelines we provide are based on our own experiences with the development of large-scale enterprise applications as well as research we have done on best practices for requirements management proposed by other authors. The techniques are based on recursively classifying software requirements into logical coherent classes of requirements so that they improve developers' conception of the requirements and streamline the navigation to the next steps in the process. The techniques proposed in this paper, provide a mechanism for keeping track of requirements and help the development team to test the software in a more efficient way.
The Modula-2 experience
Authors: Schaller Nan C.
Published: July 2004

The 1987-88 school year represents the first time that the Undergraduate Computer Science Department at Rochester Institute of Technology (RIT) has offered its five quarter course programming skills sequence with Modula-2 as its primary teaching language. What follows is a description of RIT's first year Modula-2 experience including the trials and tribulations of new languages, new compilers, and untried texts. With only the first half of the sequence having been offered using Modula-2, the benefits derived from the change thus far will be discussed as well as suggestions, conclusions, and a preview of what is yet to come.
Models, instances, and concurrency in software development
Authors: Chroust G.
Published: July 2004

Triggered by a recent paper [Aoyama_86] on a Concurrent Software Development paradigm, implicit concurrency in current Software Process Models is discussed.
The effective use of undergraduates to staff large introductory CS courses
Authors: Reges Stuart , McGrory John , Smith Jeff
Published: July 2004

In the past few years many schools have tried to simultaneously achieve the following goals in their introductory CS courses:

Allow more students to enroll

Improve the quality of education

Keep spending at current levels

Everyone has discovered that the first two goals are difficult to achieve in the presence of the third. This paper presents a model that has evolved over the last five years at Stanford University where all three goals have been accomplished by replacing graduate student TAs with undergraduate section leaders.
Introducing parallel processing at the undergraduate level
Authors: Butler Ralph M. , Eggen Roger E. , Wallace Susan R.
Published: July 2004

With multiprocessor computers becoming more readily available on college campuses and with the recent development of software tools to aid in the implementation of parallel algorithms, it is time for parallel processing to enter the undergraduate curriculum. In this paper we show how widely available tools combined with concepts learned in an operating systems course could be used to develop an upper level undergraduate course in parallel processing. A typical artificial intelligence search problem (N-queens) is implemented in C and exhibits almost linear speedups.
Assembly language courses in transition
Authors: Little R. Rainey , Smotherman Mark K.
Published: July 2004

Although the CS 3 course of the ACM Curriculum '78 was defined almost a decade ago, the broader perspectives that are desired for that course have not been present in many undergraduate programs. Only recently has the pivotal role of this course begun to attract the attention of computer science faculties. This development is prompted by the increasing awareness in our profession of the need to convey basic principles along with programming skills in introductory courses, and is accompanied by the increasing availability of more well-rounded textbooks. This paper describes the transition at Clemson University from a skills-oriented “assembly language course” to a principles-oriented “introduction to computer systems” course. The course that has resulted will better prepare students for subsequent studies in languages, operating systems, and applications support software.
Learning recursion as a concept and as a programming technique
Authors: Wiedenbeck Susan
Published: July 2004

Two experiments on learning recursion and iteration were carried out. The first studied learning of the mathematical concept of recursion by having subjects compute mathematical functions by analogy to worked out examples. The results suggest that subjects are quite able to induce a computational procedure for both iterative and recursive functions from examples. Furthermore, prior practice with iterative examples does not seem to facilitate subsequent performance on similar recursive problems, nor does prior practice with recursive examples facilitate performance on iterative problems. The second experiment studied novice subjects' comprehension of iterative and recursive Pascal programs. Comprehension of the iterative program was not improved by prior exposure to the recursive version of the program. Comprehension of the recursive version was improved moderately by prior work with the iterative version.
Experience in teaching communication software using Berkeley Unix
Authors: Abdel-Wahab Hussein M.
Published: July 2004

At many universities and institutions throughout the world it is now very common to have a network of computers, each running the Berkeley
4.3BSD
version of
UNIX
or an equivalent version such as
ULTRIX
. This paper is to help students using these versions of
UNIX
to explore and experiment with the interprocess communications and networking facilities. We present examples of client/server programs that can be used as a model for writing distributed applications. We describe how students can test and experiment with these programs. Students are assumed to be familiar with the C programming language and some version of
UNIX
.
Priming the pipeline
Authors: Jepson Andrea , Perl Teri
Published: July 2004

In 1997 The Backyard Project, a pilot program of the Garnett Foundation, was instituted to encourage high school girls to explore careers in the computer industry (See 〈http://taz.cs.ubc.ca/swift/archives/garnett.html〉). At that time, the Garnett Foundation commissioned the Global Strategy Group to execute a survey of 652 college-bound high school students (grades 9 through 12), to help discover directions that The Backyard Project might take to try to move toward the mission of the pilot program. It conducted the study by telephone between March 25 and April 8, 1997 in the Silicon Valley, Boston, and Austin metropolitan areas. It conducted all interviews using a random digit dialing methodology, derived from a file of American households with high incidences of adolescent children. The survey had an overall margin of error of + 3.8%.The top six answers from girls to the survey question "Why are girls less likely to pursue computer science careers?" in order of perceived importance by the girls were: "not enough role models"; "women have other interests"; "didn't know about the industry"; "limited opportunity"; "negative media"; and "too nerdy".The Backyard Project, in existence from 1998-2001, sponsored computer camps on college campuses for high school girls. The first camp in 1998, served 24 girls and by 2000, it had grown to an eight-city program designed to give 360 girls, most from low-income families, a week to learn high tech fundamentals and meet women in the computer industry. This high growth rate reflects the urgent need for programs such as this one.The following discusses the six responses given above by the girl survey respondents. The quotes that follow (unless otherwise noted), speak to the issues raised in the survey and are taken from comments made by the high school girls attending the camp at Stanford University in 1999.
'Virtual family'
Authors: Duplantis Willa , MacGregor Eve , Klawe Maria , Ng Michele
Published: July 2004

This paper introduces and discusses Virtual Family (VF): A gender-neutral game-based software that introduces Java programming. VF provides a completely functioning game that students extend and enhance via programming. We discuss the background and context within which Virtual Family was developed and other available multimedia resources for teaching programming. The paper then goes on to describe Virtual Family's concept and design. Finally, feedback received from Virtual Family teaching workshops is related, as well as preliminary results from using VF in high-school teaching units. Virtual Family is under development in a research lab at the University of British Columbia and is an initiative of Supporting Women in InFormation Technology (SWIFT). SWIFT is a five-year research action and implementation project to increase the participation of women in Information Technology. Virtual Family is available free of charge to anyone interested in using it for teaching or outreach purposes, to order email 〈swift@interchange.ubc.ca〉.
Developing a hardware and programming curriculum for middle school girls
Authors: Countryman Jeri , Feldman Alegra , Kekelis Linda , Spertus Ellen
Published: July 2004

If you ask most children-or even most adults-to draw a picture of a computer scientist, you are likely to get a picture of a man. Despite the personal and professional rewards careers in technology, women are underrepresented in high-tech industry, and most girls do not imagine a career technology. Positions in the technology industry are among the most professionally challenging and highest paying. Yet, by their choices and preparation, girls limit their ability to work in technology fields in the future. For example, at the high school level where students begin to study and prepare for careers, girls enroll in fewer computer science courses---particularly advanced level classes---than boys do.The reasons for the disparity between boys' and girls' involvement in technology are multifaceted. Boys in our culture, much more than girls, are encouraged to engage in hands-on experimentation that gives them an advantage in terms of self-confidence and a willingness to experiment with technology. Children's first exposure to computers often comes through games and most computer games, with their violent themes and gender stereotypes, appeal to boys. Parents who may fail to encourage their daughters to experiment with technology often reinforce differences inadvertently. They are less inclined to enroll them in after-school and summer computer classes.Schools should help to level the playing field. And in fact, some schools have taken steps to reduce the gender divide in technology by setting policies of equal access, offering more gender-neutral software, and providing computer training and support for teachers [1]. Despite these efforts by some school districts, many teachers remain unprepared to integrate technology into the curriculum or to ensure its equitable use by students. And with enormous caseloads, counselors can do little to offer guidance to students and their families about academic and career opportunities in technology.In addition to striving to increase the number of girls involved with technology it is also important to consider
how
girls are participating in the computer culture. A common alternative to computer science courses-and a common point of entry for girls into the computer world-has been courses on computer "tools" such as databases, page layout, graphics, online publishing, and other "productivity software" [2]. These classes may teach basic skills rather than promote higher-order learning [3]. As such, we are challenged to create innovative ways for understanding the role that computers play in the education of girls and for improving their access to and use of computers.
Leveraging an alternative source of computer scientists
Authors: Humphreys Sheila , Spertus Ellen
Published: July 2004

Much has been written about the "leaky pipeline" of women in computer science (CS), with the percentage of women decreasing as one moves from lower levels, such as college, to higher levels, culminating in full professorship. While significant attention focused on keeping women from leaving the pipeline, there is also an opportunity to bring women into the pipeline through non-traditional programs, instead of requiring that everyone enter at the undergraduate level. Both Mills College, a small liberal arts institution for women, and UC Berkeley, a large research university, established programs in the 80's to increase the number of women in computer science by tapping non-traditional students. Both programs share the core value of accommodating older students lacking technical backgrounds. The two programs have produced similar results: graduate degrees earned in computer science by students who would not have qualified without these programs, professional employment in the computer science field by women and minorities, and a recognition that this population represents a rich source of talent for our nation.
A conference's impact on undergraduate female students
Authors: Francioni Joan M.
Published: July 2004

In September of 2000, the 3rd Grace Hopper Celebration of Women in Computing was held in Cape Cod, Massachusetts. Along with a colleague from a nearby university, we accompanied seven of our female undergraduate students to this conference. This paper reports on how the conference experience immediately affected these students --- what impressed them, what scared them, what it clarified for them. It also reports on how the context in which these students currently evaluate their ability, potential and opportunity in computer science is different now from what it was before the conference. Hopefully, by understanding their experience, we can gain some insight into things we can do for all of our undergraduate female students to better support their computer science and engineering education.
Building an effective computer science student organization
Authors: Frieze Carol , Blum Lenore
Published: July 2004

This paper aims to provide a practical guide for building a student organization and designing activities and events that can encourage and support a community of women in computer science. This guide is based on our experience in building Women@SCS, a community of women in the School of Computer Science (SCS)(2) at Carnegie Mellon University. Rather than provide an abstract "to-do" or "must-do" list, we present a sampling of concrete activities and events in the hope that these might suggest possibilities for a likeminded student organization. However, since we have found it essential to have a core group of activist students at the helm, we provide a "to-do" list of features that we feel are essential for forming, supporting and sustaining creative and effective student leadership.
Women in computing around the world
Authors: Galpin Vashti
Published: July 2004

This paper describes the participation of women in computing in more than 30 countries, by focussing on participation at undergraduate level. A brief discussion covers how societal and cultural factors may affect women's participation. Statistics from many different sources are presented for comparison. Generally, participation is low --- most countries fall in the 10-40% range with a few below 10% and a few above 40%.
A gendered view of computer professionals
Authors: Craig Annemieke , Paradis Rose , Turner Eva
Published: July 2004

The under-representation of women in the computing profession in many parts the western world has received our attention through numerous publications, the noticeable low representation of women at computer science conferences and in the lecture halls. Over the past two decades, the situation had become worse. Please refer to the other articles in this special issue for detailed statistics, a discussion of factors that contribute to the low participation rate by women, and for suggestions on how to reverse the current trend.This paper seeks to add to the dialogue by presenting preliminary findings from a research project conducted in four countries. The aim of this research was to gain an insight into the perceptions future computer professionals hold on the category of employment loosely defined under the term of "a computer professional." One goal was to get insight into whether or not there is a difference between female and male students regarding their view of computer professionals. Other goals were to determine if there was any difference between female and male students in different parts of the world, as well as who or what most influences the students to undertake their courses in computing.The team of researchers gave an extensive questionnaire to undergraduate students enrolled in a variety of computing degree programs. The students enrolled in these programs at Victoria University of Technology in Melbourne, the University of East London, the Chinese University of Hong Kong, and Ithaca College located in Ithaca, New York. This article reports on the analysis of the results from the questionnaire. It discusses the gender differences in the responses from the students in these countries to try to get a worldwide perspective. At this time, it does not yet report on the similarities and differences between the groups of participants from each of the four countries. Instead, it investigates whether there are gendered differences in the views of this rather broad sample of student population of future computer professionals.
An ACM-W literature review on women in computing
Authors: Gürer Denise , Camp Tracy
Published: July 2004

The pipeline shrinkage problem for women in computer science is a well-known and documented phenomenon where the ratio of women to men involved in computing shrinks dramatically from early student years to working years [19, 22, 23, 32, 42, 93, 112], also see this issue [24]. During the last decade, considerable research ensued to understand the reasons behind the existence of the shrinking pipeline and in some cases to take action to increase the numbers of women in computing. Through the work of a National Science Foundation funded project [56], ACM's Committee on Women in Computing (ACM-W) has taken a first step towards pulling this research together. A large number of articles was gathered and processed on the topic of women in computing and the shrinking pipeline. The committee created a publicly available online database to organize the references of this body of work by topic, author, and reference information. The database, constantly being updated, is accessible through ACM-W's website 〈http://www.acm.org/women〉. A final report is also available via the ACM-W website which covers current statistics on women in computing, summaries of the literature in the database, and a set of recommendations.The following discussion is a brief synopsis of a subset of the literature review as of August 2001. In addition, you can find statistics on women in computing and recommendations throughout this special issue.
Women in computing
Authors: Teague Joy
Published: July 2004

Career stereotyping and misperceptions about the nature of computing are substantive reasons for the under-representation of women in professional computing careers. In this study, 15 women who have work experience in several aspects of computing were asked about their reasons for entering computing, what they liked about working in computing, and what they disliked. While there are many common threads, there are also individual differences. Common reasons for choosing computing as a career included: exposure to computing in a setting which enabled them to see the versatility of computers; the influence of someone close to them; personal abilities which they perceived to be appropriate for a career in computing; and characteristics of such careers which appealed to them. Generally, women working in the field enjoy the work they are doing. Dislikes arising from their work experiences are more likely to be associated with people and politics than with the work they do --- and they would like to have more female colleagues.
Ten suggestions for a gender-equitable CS classroom
Authors: Treu Kevin , Skinner Alisha
Published: July 2004

Though considerable attention has been paid to the creation of a nurturing environment for women in the field of computer science, proposed solutions have primarily focused on activities outside of the classroom. This paper presents a list of suggestions for modifications to both the pedagogy and content of CS courses designed to make the CS classroom environment more inviting for women students.
The effects of pair-programming on performance in an introductory programming course
Authors: McDowell Charlie , Werner Linda , Bullock Heather , Fernald Julian
Published: July 2004

The purpose of this study was to investigate the effects of pair-programming on student performance in an introductory programming class. Data was collected from approximately 600 students who either completed programming assignments with a partner or programmed independently. Students who programmed in pairs produced better programs, completed the course at higher rates, and performed about as well on the final exam as students who programmed independently. Our findings suggest that collaboration is an effective pedagogical tool for teaching introductory programming.
Integrating empirical methods into computer science
Authors: Reed David , Baldwin Doug , Clancy Michael , Downey Allen , Hansen Stuart
Published: July 2004

Empirical skills are playing an increasingly important role in the computing profession and our society. In addition to being problem-solvers and designers/engineers, computer scientists must also be capable experimenters in order to develop, test, and evaluate complex hardware and software systems. The widespread use of computers as tools for interdisciplinary research also demands a strong grounding in the scientific method.This panel is designed to promote discussion about innovative methods for integrating empirical skills within the traditional computer science curriculum. Each panelist will define a set of core empirical concepts and skills that they see as essential to computer scientists, with a brief rationale for each. In conjunction, they will describe classroom practices that serve to demonstrate the key concepts and/or develop skills they have identified. Sufficient time will be allocated for discussion and contributions from the audience.
Computer science accessibility for students with visual disabilities
Authors: Francioni Joan M. , Smith Ann C.
Published: July 2004

Students with visual disabilities face unique challenges in learning to be computer scientists. These challenges can be overcome, however, with the use of specialized software tools and hardware equipment, collectively called assistive technology. In this paper, we discuss the environment we are using for three students with visual disabilities who are starting in our programs this year. This environment includes a collection of commercial assistive technology and a programming tool that we have developed in-house.
Teaching computer organization/architecture with limited resources using simulators
Authors: Wolffe Gregory S. , Yurcik William , Osborne Hugh , Holliday Mark A.
Published: July 2004

As the complexity and variety of computer system hardware increases, its suitability as a pedagogical tool in computer organization/architecture courses diminishes. As a consequence, many instructors are turning to simulators as teaching aids, often using valuable teaching/research time to construct them. Many of these simulators have been made freely available on the Internet, providing a useful and time-saving resource for other instructors. However, finding the right simulator for a particular course or topic can itself be a time-consuming process. The goal of this paper is to provide an easy-to-use survey of free and Internet-accessible computer system simulators as a resource for all instructors of computer organization and computer architecture courses.
Participatory design in a human-computer interaction course
Authors: Weinberg Jerry B. , Stephen Mary L.
Published: July 2004

Empirical evidence shows the ability for computer technology to deliver on its promises of enhancing our quality of life relies on how well the application fits our understanding of how things work. Software designers need to apply methods that provide insights into the user's mental model of the application's target task and to invite the user to be an active participant in the design process. This paper reports on our efforts to design an HCI curriculum around ethnographic techniques of data gathering and paper prototyping. Initial results are presented that study the course's effects on student's attitudes regarding approaches to software design and their long term design behavior.
Making lemonade
Authors: Wolfman Steven A.
Published: July 2004

Pedagogy of large lecture classes has traditionally focussed on deemphasizing the problems their size creates. This approach has yielded valuable practical advice for instructors. However, this paper argues that there are pedagogical advantages to the large lecture format and that exploiting these advantages can
further
improve classroom instruction. I present some advantages of large classes and anecdotes that demonstrate how to exploit these advantages.
A gimmick to integrate software testing throughout the curriculum
Authors: Goldwasser Michael H.
Published: July 2004

We discuss our experiences in which students of a programming course were asked to submit both an implementation as well as a test set. A portion of a student's grade was then devoted both to the validity of a student's program on others' test sets, as well as how that student's test set performed in uncovering flaws in others' programs. The advantages are many, as this introduces implicit principles of software testing together with a bit of fun competition. The major complication is that such an all-pairs execution of tests grows quadratically with the number of participants, necessitating a fully automated scoring system.
Korat
Authors: Boyapati Chandrasekhar , Khurshid Sarfraz , Marinov Darko
Published: July 2004

This paper presents Korat, a novel framework for automated testing of Java programs. Given a formal specification for a method, Korat uses the method precondition to automatically generate all (nonisomorphic) test cases up to a given small size. Korat then executes the method on each test case, and uses the method postcondition as a test oracle to check the correctness of each output.To generate test cases for a method, Korat constructs a Java predicate (i.e., a method that returns a boolean) from the method's pre-condition. The heart of Korat is a technique for automatic test case generation: given a predicate and a bound on the size of its inputs, Korat generates all (nonisomorphic) inputs for which the predicate returns true. Korat exhaustively explores the bounded input space of the predicate but does so efficiently by monitoring the predicate's executions and pruning large portions of the search space.This paper illustrates the use of Korat for testing several data structures, including some from the Java Collections Framework. The experimental results show that it is feasible to generate test cases from Java predicates, even when the search space for inputs is very large. This paper also compares Korat with a testing framework based on declarative specifications. Contrary to our initial expectation, the experiments show that Korat generates test cases much faster than the declarative framework.
A report on the use of HyperTalk in CS1 within a liberal arts setting
Authors: Goldweber Michael
Published: July 2004

The choice of which formal (programming) language to use in CS1 has occupied or preoccupied computer science educators for some time now. Some have even dubbed the debate as the "language wars." We do not intend for this report to be is another salvo in this war. Instead, we wish to report on why one institution has decided on an unconventional choice--HyperTalk--and the successful results obtained from using it in CS1 for the past five semesters.
Teaching network fundamentals using a simulated network
Authors: Stratton David
Published: July 2004

The classic computer science degree begins by offering students insights into the workings of a stand-alone computer in order that they can be effective in their career in the computing industry. However, the interconnection of computers in networks is now so pervasive that students also need a foundation in network fundamentals. A simulated network is a safe and inexpensive environment in which to expose students to networking issues. Existing network simulators are designed to model traffic and performance and are unsuitable for these purposes. This paper describes a Java application, distributed using the Common Object Request Broker Architecture (CORBA), that has been written to provide an environment in which students can actively engage with some important networking concepts.
Enhancing the learning environment of deaf students
Authors: Kelley Sobel Ann E. , Hill Joseph C.
Published: July 2004

The experiences of teaching a CS1 course that included a deaf student are presented. The intention of this presentation is to provide guidelines for improving the learning environment for future classes of similar student composition.
Evaluation of the SEPA in teaching undergraduate software engineering in the traditional computer science curriculum
Authors: Johnson Hubert A.
Published: July 2004

Experiences provide computer science majors need to mirror the typical situation a student will encounter after graduation. The frustration as well as the benefit of working in a group can only be appreciated if experienced first hand. This has made the introduction of software engineering concepts into the traditional computer science curriculum an invaluable component in all computer science courses.The use of Software Engineering - A Practitioner's Approach (SEPA) in an undergraduate software engineering course taught at Montclair in the Spring of 1997 was an attempt to expose the students to situations as typical of real-world conditions as possible. In assessing the impact of this approach on undergraduate software education, I concluded that the SEPA can provide a rich and significantly worthwhile experience for students as the students in this course had very positive feedback regarding the course.
Principles of survey research
Authors: Kitchenham Barbara , Pfleeger Shari Lawrence
Published: July 2004

This article is the fifth installment of our series of articles on survey research. In it, we discuss what we mean by a population and a sample and the implications of each for survey research. We provide examples of correct and incorrect sampling techniques used in software engineering surveys.
Binomial coefficient recursion
Authors: Rolfe Timothy
Published: July 2004

The binomial coefficient or, alternatively, the number of combinations of
n
items taken
k
at a time, provides two defining recurrences. One of these provides a very useful recursive function a very
good
way for a program to calculate this function. The other provides a very wasteful recursive function the balancing
bad and ugly
way.
Just clicking some theoretical aspects of computing
Authors: Olagunju Amos O. , Geiger Katrenia
Published: July 2004

This paper discusses recurring challenges confronting pedagogical pioneers of an introduction to the theory of computing at the undergraduate level. A generalized click game is presented for use as a vehicle to vitalize the introduction of the elements of the theory of computing.
PC-based development environments and a Unix-centric curriculum
Authors: Golub Evan
Published: July 2004

As computers have become a more common household item, computer science students are able to work at home rather than in campus labs. At institutions that have Unix-centric resources, students are able to use these home computers to connect to campus machines remotely. However, some students want to use a PC-based development environment rather than the ones available under Unix. Do they gain an advantage? Are there problems that they will encounter when they bring their program into the Unix environment?
The bug that destroyed a rocket
Authors: Ben-Ari Mordechai
Published: July 2004

In the 2000 December issue of
inroads,
Michael Williams suggested that the failure of the Ariane 5 rocket launch could be used as a case study in teaching programming concepts. Here is an article I wrote several years ago in which I present the story of the Ariane 5 in terms used to teach introductory computer science.
Support for teaching formal methods
Authors: Almstrum Vicki L. , Dean C. Neville , Goelman Don , Hilburn Thomas B. , Smith Jan
Published: July 2004

This report describes a growth path for the area referred to as
formal methods
within the computing education community. We define the term formal methods and situate it within our field by highlighting its role in Computing Curricula 1991, Computing Curricula 2001, and the SoftWare Engineering Body Of Knowledge (SWEBOK). The working group proposes an enhancement to an existing web resource, which is a rich collection of materials and links related to formal methods. The new resource is designed to provide a bridge between the general computing education community and the formal methods community. The goal is to allow the latter to provide useful support for the former for the ultimate benefit of all of our students. Eventually, the working group aspires to see the concepts of formal methods integrated seamlessly into the computing curriculum so that it is not necessary to separate them in our discussions.
Integrating cultural issues into the computer and information technology curriculum
Authors: Little Joyce Currie , Granger Mary , Adams Elizabeth S. , Holvikivi Jaana , Lippert Susan K. , Walker Henry M. , Young Alison
Published: July 2004

Industry leaders and educators in Computer and Information Technology (CIT) have expressed a need for graduates to have a background in professional, societal, and ethical concerns as well as a strong technical capability (Huff and Martin, 1995). Some educators have gone so far as to include cultural awareness: "The cultural dimensions of information technology can no longer be ignored, with the expansion of the global economy, global markets and global communication enabled by information technology" (Hasan and Ditsa, 1998, p. 5). The rationale for supporting and enhancing instruction in cultural issues for CIT workers comes from the growing globalization of the world in communication, the increase of trans-national organizational mergers and partnerships, the merging of various populations within national boundaries, the increasing traffic of individuals to different countries around the world, and the severe shortage of information technology personnel throughout the world. This paper provides material to support the inclusion of cultural issues within the CIT curriculum. The topics identified, which include diversity and multiculturalism, organizational cultures, professional cultures, socio-economic issues, and gender issues, form a foundation body of knowledge that, once learned, can improve and enhance the work of the information technology professional. Exercises are provided that can be incorporated into existing CIT courses across a wide variety of programs, nations, and cultures. As the internationalization of education continues, more exercises and examples will surely arise from the CIT community.
On the presentation of computer science problems
Authors: Hazzan Orit
Published: July 2004

This paper suggests an alternative way for presenting theorems to students. The discussion focuses on theorems that indicate the existence (or inexistence) of some object. Instead of presenting a given theorem as it is, it is suggested to reformulate the theorem as a (sometimes unsolvable) construction task. Students trials to solve the construction problem, lead them to discover the theorem by themselves.
Object-oriented programming and design patterns
Authors: Lang Joseph E. , Bogovich Brian R. , Barry Sean C. , Durkin Brian G. , Katchmar Michael R. , Kelly Jonathan H. , McCollum J. Michael , Potts Michael
Published: July 2004

When teaching object-oriented concepts, design patterns are usually left until the end or left out entirely. In this paper, design patterns are related to the rules of object-oriented design, strongly suggesting that these two concepts should be taught together as beneficial for the understanding of both.
Resources for instructors of capstone courses in computing
Authors: Clear Tony , Goldweber Michael , Young Frank H. , Leidig Paul M. , Scott Kirk
Published: July 2004

Most computing programs now have some form of integrative or capstone course in which students undertake a significant project under supervision. There are many different models for such courses and conducting these courses is a complex task. This report is intended to assist instructors of capstone courses, particularly those new to the model of teaching and learning inherent in the capstone course.This paper discusses important issues that must be addressed when conducting capstone courses. These issues are addressed through a series of questions, with answers reflecting the way that different institutions have chosen to handle them, and commentary on the impact of these different choices. These questions include: Goals of the Course; Characteristics of Projects; Project Deliverables; Sponsors; Teams; Prerequisites and Preparation; Grading and Assessment; Administration and Supervision; and Reflection, Analysis and Review.Subsequently we present information about the companion Web site, intended as an active repository of best practice for instructors of capstone projects. The Web site will have examples of information about capstone courses and materials used by instructors. Readers are invited to contribute content to this site. The paper concludes with a bibliography of additional reference material and resources.
Isolating cause-effect chains from computer programs
Authors: Zeller Andreas
Published: July 2004

Consider the execution of a failing program as a sequence of program states. Each state induces the following state, up to the failure. Which variables and values of a program state are relevant for the failure? We show how the
Delta Debugging
algorithm isolates the relevant variables and values by systematically narrowing the state difference between a passing run and a failing run--by assessing the outcome of altered executions to determine wether a change in the program state makes a difference in the test outcome. Applying Delta Debugging to multiple states of the program automatically reveals the
cause-effect chain
of the failure--that is, the variables and values that caused the failure.In a case study, our prototype implementation successfully isolated the cause-effect chain for a failure of the GNU C compiler: "Initially, the C program to be compiled contained an addition of 1.0; this caused an addition operator in the intermediate RTL representation; this caused a cycle in the RTL tree--and this caused the compiler to crash."
Invariant inference for static checking
Authors: Nimmer Jeremy W. , Ernst Michael D.
Published: July 2004

Static checking can verify the absence of errors in a program, but often requires written annotations or specifications. As a result, static checking can be difficult to use effectively: it can be difficult to determine a specification and tedious to annotate programs. Automated tools that aid the annotation process can decrease the cost of static checking and enable it to be more widely used.This paper describes an evaluation of the effectiveness of two techniques, one static and one dynamic, to assist the annotation process. We quantitatively and qualitatively evaluate 41 programmers using ESC/Java in a program verification task over three small programs, using Houdini for static inference and Daikon for dynamic inference. We also investigate the effect of unsoundness in the dynamic analysis.Statistically significant results show that both inference tools improve task completion; Daikon enables users to express more correct invariants; unsoundness of the dynamic analysis is little hindrance to users; and users imperfectly exploit Houdini. Interviews indicate that beginning users found Daikon to be helpful; Houdini to be neutral; static checking to be of potential practical use; and both assistance tools to have unique benefits.Our observations not only provide a critical evaluation of these two techniques, but also highlight important considerations for creating future assistance tools.
Using redundancies to find errors
Authors: Xie Yichen , Engler Dawson
Published: July 2004

This paper explores the idea that redundant operations, like type errors, commonly flag correctness errors. We experimentally test this idea by writing and applying four redundancy checkers to the Linux operating system, finding many errors. We then use these errors to demonstrate that redundancies, even when harmless, strongly correlate with the presence of traditional hard errors (e.g., null pointer dereferences, unreleased locks). Finally we show that how flagging redundant operations gives a way to make specifications "fail stop" by detecting dangerous omissions.
Negative scenarios for implied scenario elicitation
Authors: Uchitel Sebastian , Kramer Jeff , Magee Jeff
Published: July 2004

Scenario-based specifications such as Message Sequence Charts (MSCs) are popular for requirement elicitation and specification. MSCs describe two distinct aspects of a system: on the one hand they provide examples of intended system behaviour and on the other they outline the system architecture. A mismatch between architecture and behaviour may give rise to implied scenarios. Implied scenarios occur because a component's local view of the system state is insufficient to enforce specified system behaviour. An implied scenario indicates a gap in the MSC specification that needs to be clarified. It may simply mean that an acceptable scenario has been overlooked and should be added to the scenario specification. Alternatively, it may represent an unacceptable behaviour which should be documented and avoided in the final implementation. Thus implied scenarios can be used to iteratively drive requirements elicitation. However, in order to do so, tools for coping with rejected implied scenarios are needed. The contributions of this paper are twofold. Firstly, we define a language for describing negative scenarios. Secondly, we complement existing implied scenario detection methods with techniques for accommodating negative scenarios.
Composable semantics for model-based notations
Authors: Niu Jianwei , Atlee Joanne M. , Day Nancy A.
Published: July 2004

We propose a unifying framework for model-based specification notations. Our framework captures the execution semantics that are common among model-based notations, and leaves the distinct elements to be defined by a set of parameters. The basic components of a specification are non-concurrent state-transition machines which are combined by composition operators to form more complex, concurrent specifications. We define the step-semantics of these basic components in terms of an operational semantics
template
whose parameters specialize both the enabling of transitions and transitions' effects. We also provide the operational semantics of seven composition operators, defining each as the concurrent execution of components, with changes to their shared variables and events to reflect inter-component communication and synchronization; the definitions of these operators use the template parameters to preserve in composition notation-specific behaviour. By separating a notation's step-semantics from its composition and concurrency operators, we simplify the definitions of both. Our framework is sufficient to capture the semantics of basic transition systems, CSP, CCS, basic LOTOS, ESTELLE, a subset of SDL88, and a variety of statecharts notations. We believe that a description of a notation's semantics in our framework can be used as input to a tool that automatically generates formal analysis tools.