bluuebunny/crossref_metadata_2025 huggingface dataset:
Partial cutting of woodlots in an agriculture-dominated landscape: effects on forest bird communities
Authors: Holmes Stephen B , Burke Dawn M , Elliott Ken A , Cadman Michael D , Friesen Lyle
Published: January 2005

We studied the short-term effects of partial cutting on the forest bird communities of mixed maple forests in an agriculture-dominated landscape in southwestern Ontario. Blocks that had been recently harvested were grouped according to provincial silvicultural guidelines (standard and heavy cuts) and compared with blocks that had been uncut for at least 24 years (old cuts). We found significant differences in forest bird community structure between standard and heavy cuts and between heavy and old cuts, but not between standard and old cuts. Heavy cuts had more species and more individuals than old cuts, the result primarily of greater numbers of early-successional species. Brown creeper (Certhia americana Bonap.) was the only species to show a significant negative response to harvesting and was the best indicator of old cuts, while indigo bunting (Passerina cyanea L.), brown-headed cowbird (Molothrus ater Bodd.), chestnut-sided warbler (Dendroica pensylvanica L.), American redstart (Setophaga ruticilla L.), and great crested flycatcher (Myiarchus crinitus L.) were all significant indicators of heavy cuts. Our research suggests that it is possible to protect native bird communities in southwestern Ontario by using the single-tree selection system to meet the minimum basal area targets and harvest intensities recommended in provincial silvicultural guidelines.
Abundance of leafminers and leaf area loss by chewing herbivores in hybrids betweenQuercus crispulaandQuercus dentata
Authors: Ishida Takahide A , Hattori Kouhei , Kimura Masahito T
Published: January 2005

We examined responses of phytophagous insects to hybrids between Quercus crispula Blume and Quercus dentata Thunberg in a natural population in northern Japan. The abundance of leafminers and leaf area loss by chewing insects in hybrids were intermediate between those in the parental species (additive mode), close to those of either of the parental species (dominance mode), or similar to those of both parental species (no difference). Hybrids were neither more susceptible nor resistant to the insect herbivores we monitored. In Phyllonorycter (Gracillariidae) species, which are specialized to either of the parental oak species, the mortality of sap-feeding early instar larvae did not differ between hybrids and the parental species. The abundance of four leafminer taxa was correlated with environmental conditions (i.e., distance from the coastal edge of the forest or the timing of budbreak) as well as genetic factors.
Needle and branch biomass turnover rates of Norway spruce (Picea abies)
Authors: Muukkonen P , Lehtonen A
Published: January 2005

Turnover rates of needle and branch biomass, number of needle cohorts, and needle-shed dynamics were modelled for Norway spruce (Picea abies (L.) Karst.) in southern Finland. Biomass turnover rates, vertical distribution, and biomass of the branches were modelled simultaneously. The rate of needle turnover was determined from needle-shed dynamics. The potential litterfall of branches was modelled by combining the vertical distribution of branch biomass and the annual change in height of the crown base. The mean annual turnover rates for needle and branch biomass are 0.10 and 0.0125, respectively. At the age of 5.5 years, 50% of the needles in the needle cohort have been shed. In addition, at the age of 12 years, all needles of the needle cohort have been shed. Turnover of branch biomass was dependent on stand density and tree size. The modelled rates of biomass turnover agreed with measurements of needle and branch litterfall. Many process- or inventory-based models use a single turnover rate for branch litterfall based on literature, and some of the models are fully ignoring the litterfall of branches. Species-specific turnover rates or dynamic litterfall models should be applied when carbon flows in forest stands are modelled.
Estimated realized gains for first-generation slash pine (Pinus elliottii var. elliottii) tree improvement in the southeastern United States
Authors: Vergara Rodrigo , White Timothy L , Huber Dudley A , Shiver Barry D , Rockwood Donald L
Published: January 2005

Realized gains from selection of the first-generation breeding population of slash pine (Pinus elliottii Engelm. var. elliottii) were estimated using data from 38 field trials planted in large rectangular plots in the southeastern United States. The trials consisted of material selected for volume growth and planted by the Cooperative Forest Genetics Research Program at the University of Florida (19 trials) and by the Plantation Management Research Cooperative at the University of Georgia (19 trials). All trials contained slash pine seedlots collected from unrogued or lightly rogued first-generation seed orchards. Analyses of variance detected, on average, moderate gains in rust resistance (I50 = 43.1%) and site index (4.3%) and important gains in individual tree volume (7.7%) and stand yield (10.2%). Silvicultural treatments and age by realized gains interactions were never significant, but significant interactions between seedlots and trials showed that realized gains are not consistent at all sites. Overall results were highly consistent with predicted breeding values for rust resistance, but lower than expected for volume. On average, realized gain in stand yield for first-generation material was approximately 10%, or an extra inside-bark volume of 25 m3·ha1 (357 feet3·acre1) at 25 years.
THE BARNES ζ-FUNCTION, SPHERE DETERMINANTS AND GLAISHER–KINKELIN–BENDERSKY CONSTANTS
Authors: DOWKER J. S. , KIRSTEN KLAUS
Published: January 2005

Summations and relations involving the Hurwitz and Riemann ζ-functions are extended first to Barnes ζ-functions and then to ζ-functions of general type. The analysis is motivated by the evaluation of determinants on spheres which are treated both by a direct expansion method and by regularized sums. Comments on existing calculations are made. It is suggested that the combination ζ′(-n) + Hnζ(-n), where Hn is a harmonic number, should be taken as more relevant than just ζ′(-n). This leads to a Kaluza–Klein technique, providing a determinant interpretation of the Glaisher–Kinkelin–Bendersky constants which are then generalized to arbitrary ζ-functions. This technique allows an improved treatment of sphere determinants.
BOUNDEDNESS OF THE MAPPING f → |f|μ, 0 < μ < 1, ON THE POSITIVE CONE OF BESOV SPACES
Authors: KORRY SOULAYMANE
Published: January 2005

Let μ ∈ [1/2, 1), p ∈ (1, +∞), q ∈ [1, +∞] and s ∈ (0, +∞). For functions in the positive cone of Besov spaces, we prove the following estimate: [Formula: see text] as soon as 0 < s < 1/μ; thus, for positive functions, we may weaken the restriction 0 < s < 1 + 1/p given by Sickel [16] for the boundedness of the mapping f → |f|μfor general function [Formula: see text].
Is Open Source Right for You?
Authors: Ascher David
Published: January 2005

The media often present open source software as a direct competitor to commercial software. This depiction, usually pitting David (Linux) against Goliath (Microsoft), makes for fun reading in the weekend paper. However, it mostly misses the point of what open source means to a development organization. In this article, I use the experiences of GizmoSoft (a fictitious software company) to present some perspectives on the impact of open source software usage in a software development shop.
From the Editors: Open Source Revisited
Authors: Allman Eric , McKusick Marshall Kirk
Published: January 2005

In our first open source theme issue last year (ACM Queue 1(5), July-August 2003), we focused on business issues such as using open source software as a basis for a commercial product. We knew that this was an important topic, but predicted that many of our readers might find it boring. We were wrong. That issue remains among the most responded-to issues of Queue to date. So with that response, we are revisiting the open source theme.
Opinion: Buffer Overrun Madness
Authors: Bates Rodney
Published: January 2005

In January 2003, the Slammer worm was reported to be the fastest spreading ever. Slammer gets access by exploiting a buffer overrun. If you peruse CERT advisories or security upgrade releases, you will see that the majority of computer security holes are buffer overruns. These would be minor irritations but for the world’s addiction to the weakly typed programming languages C and its derivative C++. Buffer overruns are a kind of array bounds error. There are many variations on how one might actually happen, but here is a typical scenario. Function F calls function G, and G returns a string. F allocates a buffer to hold the result and passes a pointer to its zeroth character. G gets the string from somewhere, perhaps a network connection, and copies it into the buffer supplied by F.
The Hitchhiker’s Guide to Biomorphic Software
Authors: Lodding Kenneth N
Published: January 2005

The natural world may be the inspiration we need for solving our computer problems. While it is certainly true that "the map is not the territory," most visitors to a foreign country do prefer to take with them at least a guidebook to help locate themselves as they begin their explorations. That is the intent of this article. Although there will not be enough time to visit all the major tourist sites, with a little effort and using the information in the article as signposts, the intrepid explorer can easily find numerous other, interesting paths to explore.
First, Do No Harm: A Hippocratic Oath for Software Developers?
Authors: Laplante Phillip A
Published: January 2005

When asked about the Hippocratic Oath, most people are likely to recall the phrase, “First, do no harm.” It’s a logical response, as even those unfamiliar with the oath could figure out that avoiding additional injury in the course of treatment is critical. In fact, it’s natural to strive in any endeavor not to break something further in the course of repair. In software engineering, as in medicine, doing no harm starts with a deep understanding of the tools and techniques available. Using this theme and some medical metaphors, I offer some observations on the practice of software engineering. Whatever we do, first, do no harm. After all, we do not want critics 100 years from now ridiculing practices that we now believe to be legitimate, especially if the only reason we adopt them is faith and not deep understanding.
Leveraging Application Frameworks
Authors: Schmidt Douglas C , Gokhale Aniruddha , Natarajan Balachandran
Published: January 2005

In today’s competitive, fast-paced computing industry, successful software must increasingly be: (1) extensible to support successions of quick updates and additions to address new requirements and take advantage of emerging markets; (2) flexible to support a growing range of multimedia data types, traffic flows, and end-to-end QoS (quality of service) requirements; (3) portable to reduce the effort required to support applications on heterogeneous operating-system platforms and compilers; (4) reliable to ensure that applications are robust and tolerant to faults; (5) scalable to enable applications to handle larger numbers of clients simultaneously; and (6) affordable to ensure that the total ownership costs of software acquisition and evolution are not prohibitively high.
Toolkit: Samba Does Windows-to-Linux Dance
Authors: Wolfe Alex
Published: January 2005

With heterogeneous networked environments becoming the rule rather than the exception, there’s more need than ever for Windows and Linux to work and play well together. Enter Samba, the print- and file-sharing tool that enables files residing on Linux hosts to interact with Windows-based desktops.
Without a NULL That String Would Never End
Authors: Kelly-Bootle Stan
Published: January 2005

It’s an undiluted pleasure to be invited to contribute a third column for ’ACM Queue’ under the surly rubric “Curmudgeon.” Curmudgeons are not usually associated with pleasures, diluted or full strength, but at my age the cheap thrill of thrusting a poisoned pen is especially welcome since the targets for satire bob daily as upstart sitting ducks for the roasting: mere “Juvenal delinquents,” as master curmudgeon George Crabbe [sic] called them.
Coordinated parallelizing compiler optimizations and high-level synthesis
Authors: Gupta Sumit , Gupta Rajesh Kumar , Dutt Nikil D. , Nicolau Alexandru
Published: January 2005

We present a high-level synthesis methodology that applies a coordinated set of coarse-grain and fine-grain parallelizing transformations. The transformations are applied both during a pre-synthesis phase and during scheduling, with the objective of optimizing the results of synthesis and reducing the impact of control flow constructs on the quality of results. We first apply a set of source level presynthesis transformations that include common sub-expression elimination (CSE), copy propagation, dead code elimination and loop-invariant code motion, along with more coarse-level code restructuring transformations such as loop unrolling. We then explore scheduling techniques that use a set of aggressive speculative code motions to maximally parallelize the design by re-ordering, speculating and sometimes even duplicating operations in the design. In particular, we present a new technique called "Dynamic CSE" that dynamically coordinates CSE and code motions such as speculation and conditional speculation during scheduling. We implemented our parallelizing high-level synthesis in the SPARK framework. This framework takes a behavioral description in ANSI-C as input and generates synthesizable register-transfer level VHDL. Our results from computationally expensive portions of three moderately complex design targets, namely, MPEG-1, MPEG-2 and the GIMP image processing tool, validate the utility of our approach to the behavioral synthesis of designs with complex control flows.
Reusing an on-chip network for the test of core-based systems
Authors: Cota Érika , Carro Luigi , Lubaszewski Marcelo
Published: January 2005

Networks-on-chip are likely to become the main communication platform of systems-on-chip. To cope with the growing complexity of the test of such systems, the authors propose the reuse of the on-chip network as a test access mechanism to the cores embedded into systems that use this communication platform. An algorithm exploiting the network characteristics to minimize test time is presented. Then, the reuse strategy is evaluated considering a number of system configurations, such as different positions of the cores in the network, power consumption constraints and number of interfaces with the tester. Experimental results for the ITC'02 SOC Test Benchmarks show that the parallelization capability of the network can be exploited to reduce the system test time, whereas area and pin overhead are strongly minimized.
Achieving high encoding efficiency with partial dynamic LFSR reseeding
Authors: Krishna C. V. , Jas Abhijit , Touba Nur A.
Published: January 2005

Previous forms of LFSR reseeding have been static (i.e., test application is stopped while each seed is loaded) and have required full reseeding (i.e., the length of the seed is equal to the length of the LFSR). A new form of LFSR reseeding is described here that is dynamic (i.e., the seed is incrementally modified while test application proceeds) and allows partial reseeding (i.e. length of the seed is less than that of the LFSR). In addition to providing better encoding efficiency, partial dynamic LFSR reseeding has a simpler hardware implementation than previous schemes based on multiple-polynomial LFSRs.
On test suite composition and cost-effective regression testing
Authors: Rothermel Gregg , Elbaum Sebastian , Malishevsky Alexey G. , Kallakuri Praveen , Qiu Xuemei
Published: January 2005

Regression testing is an expensive testing process used to revalidate software as it evolves. Various methodologies for improving regression testing processes have been explored, but the cost-effectiveness of these methodologies has been shown to vary with characteristics of regression test suites. One such characteristic involves the way in which test inputs are composed into test cases within a test suite. This article reports the results of controlled experiments examining the effects of two factors in test suite composition---test suite granularity and test input grouping---on the costs and benefits of several regression-testing-related methodologies: retest-all, regression test selection, test suite reduction, and test case prioritization. These experiments consider the application of several specific techniques, from each of these methodologies, across ten releases each of two substantial software systems, using seven levels of test suite granularity and two types of test input grouping. The effects of granularity, technique, and grouping on the cost and fault-detection effectiveness of regression testing under the given methodologies are analyzed. This analysis shows that test suite granularity significantly affects several cost-benefit factors for the methodologies considered, while test input grouping has limited effects. Further, the results expose essential tradeoffs affecting the relationship between test suite design and regression testing cost-effectiveness, with several implications for practice.
Coupling and cohesion metrics for knowledge-based systems using frames and rules
Authors: Kramer Stefan , Kaindl Hermann
Published: January 2005

Software systems and in particular also knowledge-based systems (KBS) become increasingly large and complex. In response to this challenge, software engineering has a long tradition of advocating modularity. This has also heavily influenced object-oriented development. For measuring certain important aspects of modularity, coupling and cohesion metrics have been developed. Metrics have also attracted considerable attention for object-oriented development. For KBS development, however, no such metrics are available yet.

This article presents the core of the first metrics suite for KBS development, its coupling and cohesion metrics. These metrics measure modularity in terms of the relations induced between slots of frames through their common references in rules. We show the soundness of these metrics according to theory and report on their usefulness in practice. As a consequence, we propose using our metrics in order to improve KBS development, and developing other important metrics and assessing their theoretical soundness along these lines.
The equality axioms are not independent
Authors: Li Dafa
Published: January 2005

After computer experiments by using the ANDP prover we showed that the five axioms for reflexivity, symmetry, transitivity and substitutivity of equality can be replaced by only two of the five axioms.
Qualitative decision making in adaptive presentation of structured information
Authors: Brafman Ronen I. , Domshlak Carmel , Shimony Solomon E.
Published: January 2005

We present a new approach for adaptive presentation of structured information, based on preference-based constrained optimization techniques rooted in qualitative decision-theory. In this approach, document presentation is viewed as a configuration problem whose goal is to determine the optimal presentation of a document, while taking into account the preferences of the content provider, viewer interaction with the browser, and, possibly, some layout constraints. The preferences of the content provider are represented by a CP-net, a graphical, qualitative preference model developed in Boutilier et al. [1999]. The layout constraints are represented as geometric constraints, integrated within the optimization process. We discuss the theoretical basis of our approach, as well as implemented prototype systems for Web pages and for general media-rich document presentation.
Information systems interoperability
Authors: Park Jinsoo , Ram Sudha
Published: January 2005

Interoperability is the most critical issue facing businesses that need to access information from multiple information systems. Our objective in this research is to develop a comprehensive framework and methodology to facilitate semantic interoperability among distributed and heterogeneous information systems. A comprehensive framework for managing various semantic conflicts is proposed. Our proposed framework provides a unified view of the underlying representational and reasoning formalism for the semantic mediation process. This framework is then used as a basis for automating the detection and resolution of semantic conflicts among heterogeneous information sources. We define several types of semantic mediators to achieve semantic interoperability. A domain-independent ontology is used to capture various semantic conflicts. A mediation-based query processing technique is developed to provide uniform and integrated access to the multiple heterogeneous databases. A usable prototype is implemented as a proof-of-concept for this work. Finally, the usefulness of our approach is evaluated using three cases in different application domains. Various heterogeneous datasets are used during the evaluation phase. The results of the evaluation suggest that correct identification and construction of both schema and ontology-schema mapping knowledge play very important roles in achieving interoperability at both the data and schema levels.
Why i care about programming and how to teach it
Authors: Astrachan Owen
Published: January 2005

This is the thirty-fifth SIGCSE conference. Off-by-one bugs notwithstanding, it seems safe to assume that the members of the SIGCSE community have been teaching programming for at least 35 years. Have we improved the teaching of programming in that time? We have changed languages, we have occasionally changed paradigms, and the platform we use to teach programming is effectively infinitely more powerful than it was 35 years ago. However, if we use the SIGCSE proceedings as a snapshot of the state-of-the-art in teaching programming, it's possible to take a view that "the more things change the more they remain the same." In this talk I'll review what the community has had to say about teaching programming and what it is saying today. The community does not always speak in one voice, but there are established trends that illuminate what we as a community view as important. In 1974 David Gries discussed how we should teach programming and used this analogy: "Suppose you attend a course in cabinet making. The instructor briefly shows you a saw, a plane, a hammer, and a few other tools, letting you use each one for a few minutes. He next shows you a beautifully-finished cabinet. Finally, he tells you to design and build your own cabinet and bring him the finished product in a few weeks. You would think he was crazy!" As part of this talk I will demonstrate how I teach program-building and why I think that if we do not program in front of our students we cannot effectively teach programming. I hope to convince you that programming should be taught by demonstration and that I am not crazy.
Great principles in computing curricula
Authors: Denning Peter J.
Published: January 2005

The nearly three dozen core technologies of computing sit in a simple framework defined by great principles and by computing practices. The great principles are of two kinds, mechanics and design. Computing mechanics comprises computation, communication, coordination, recollection, and automation. Design principles address concerns for complexity, resilience, performance, evolvability, and security. Practices comprise programming, systems, modeling, innovating, and applying. This framework opens many new possibilities for teaching computer science, including new approaches to programming. The new CS curriculum at the Naval Postgraduate School is based on the framework presented here.
On understanding compatibility of student pair programmers
Authors: Katira Neha , Williams Laurie , Wiebe Eric , Miller Carol , Balik Suzanne , Gehringer Ed
Published: January 2005

In recent years, educators have increasingly used pair programming in their computer science courses. Pair programming has been shown to be beneficial for both the teaching staff and the students in the courses. Occasionally, though, students are not compatible with their partners. An extensive study was done at the North Carolina State University to provide guidance on forming student pairs to improve the chances that pairs will be compatible and have a productive work relationship. We examined compatibility among freshman, advanced undergraduate, and graduate students. We have found that the students' perception of their partner's skill level has a significant influence on their compatibility. Graduate students work well with partners of similar actual skill level. Freshmen seem to work better with partners with different Myers Briggs personality type. Students' self-esteem does not appear to be a major contributor to pair compatibility.
Student culture vs group work in computer science
Authors: Waite William M. , Jackson Michele H. , Diwan Amer , Leonardi Paul M.
Published: January 2005

Our industrial advisory boards tell us that our students are well prepared technically, but they lack important group work skills. Simply adding project courses and requiring that assignments be done in groups has not improved the situation. A careful study of student culture in Computer Science has uncovered barriers to collaboration, which can be overcome only by pervasive changes in the way we approach our curriculum.
CMeRun
Authors: Etheredge Jim
Published: January 2005

It is generally known that most, if not all, beginning programming students have difficulty understanding and debugging programs. For many students the primary problem is that when a program executes, it is essentially a "black box". They know what they think they wrote, but their only clues to logic errors come from watching the output of the program. If there are problems, it is difficult for inexperienced programmers to trace the problem back to the source of the error(s). This paper presents CMeRun, a tool that allows the user to see each statement in a program as it executes. This tool will allow beginning students to master coding and debugging skills much faster since it allows them to "look into" a program as it executes. Having this kind of insight into program execution will improve understanding, decrease development time, and reduce student frustration.
A statistical analysis of student performance in online computer science courses
Authors: McDonald Merry , Dorn Brian , McDonald Gary
Published: January 2005

During the past few years the number of courses offered online has greatly increased as technology has made delivery of such courses feasible. This paper discusses the experiences of the authors in teaching online courses for upper-division computer science students and reports results of a study comparing success of students in online courses to students in traditional courses.
A tutor on scope for the programming languages course
Authors: Fernandes Eric , Kumar Amruth N.
Published: January 2005

In order to facilitate problem-based learning in our Programming Languages course, we developed a tutor on static and dynamic scope. Static scope includes the scope of variables, the referencing environment of procedures and the scope of procedure names in a language that permits nesting of procedure definitions (e.g., Pascal, Ada). Dynamic scope includes the scope of variables, and the referencing environment of procedures. In this paper, we will describe the design of our tutor, and present the results of evaluating it for two semesters in our Programming Languages course.
SIGCSE special projects showcase
Authors: Fincher Sally
Published: January 2005

This session showcases the projects that have received support from a SIGCSE Special Project Award in the previous year.
The game of set®
Authors: Hansen Stuart
Published: January 2005

This paper presents an object--oriented design for a solitaire version of the game of Set® The design is responsibility driven and illustrates polymorphism and several fundamental design patterns, including Flyweight, Strategy and Factory. It introduces each of these to solve particular problems within the design. The direct application of these concepts and the interest our students show in the game make Set an ideal example for classroom discussions and assignments.
?????
Authors: Davis Timothy , Geist Robert , Matzko Sarah , Westall James
Published: January 2005

A new approach to the design of the computing curriculum for a Bachelor of Arts degree is described. The approach relies extensively on problem-based instruction and computer graphics to teach key concepts in computer science. The novelty arises from the magnitude and origin of the problems to be integrated into the curriculum and the breadth of the impact across the curriculum. Results from a trial course, the first experiment with the new approach, are described. The course, Tools and Techniques for Software Development, is a sophomore-level course in programming methodology. Construction of a ray-tracing system (for generating synthetic images) was the vehicle chosen for the instruction.
Language emulator, a helpful toolkit in the learning process of computer theory
Authors: Vieira Luiz Filipe M. , Vieira Marcos Augusto M. , Vieira Newton J.
Published: January 2005

Language Emulator, written in Java, is a toolkit to help undergraduate students to understand the concepts of Automata Theory. The software allows the manipulation of regular expressions, regular grammars, deterministic finite automata, nondeterministic finite automata with and without lambda transitions, and Moore and Mealy machines. Language Emulator introduces error-detecting and internationalization functionalities into automata tools. It has been accepted by 95% of students in a recent survey, indicating that it is a helpful toolkit in learning Automata Theory.
Taming a professional IDE for the classroom
Authors: Reis Charles , Cartwright Robert
Published: January 2005

An important question that must be addressed in a coherent computing curriculum is which programming environments to use across the curriculum. For Java, currently the most widely used language in computing education, a wide variety of professional integrated development environments (IDEs) are available---including the increasingly popular, open-source Eclipse environment. Professional IDEs for Java work well in advanced courses, but they are poorly matched to introductory courses because they deluge beginning students with a complex array of features. In addition, professional IDEs fail to shield students from distracting complications like the Java command line interface and Java console I/O. For this reason, many educators favor using a "pedagogic" IDE such as BlueJ or DrJava to provide a gentle introduction to the mechanics of Java programming.To eliminate the gap between pedagogic and professional IDEs for Java, we have developed a plug-in for Eclipse that supports exactly the same programming interface as DrJava. It features an Interactions pane for evaluating program statements and expressions "on the fly" as in DrJava. With this plug-in, Eclipse is accessible to beginning programmers. In this configuration, Eclipse is a suitable vehicle for teaching introductory programming--enabling Eclipse to be used across the entire spectrum of the computing curriculum.
Java IO and testing made simple
Authors: Proulx Viera K. , Rasala Richard
Published: January 2005

We present software tools that support robust input processing and comprehensive testing in Java. The software includes the JPT library that supports error-checked typed input via console or GUI for all primitive types. This provides a robust encapsulation of typical interactive input requests encountered in introductory programming courses.The Java Power Framework and its extension allow the user to develop a comprehensive test suite independent of the target classes. The type-safe input framework allows us to implement an external iterator interface for several types of input data sources, including the console, a GUI, a file, and an internal data structure. Student's programs that implement various algorithms can then process data independently of its source: running tests on existing data structures; creating inputs interactively; or running stress tests and timing tests on large input files.
Buffer pools and file processing projects for an undergraduate data structures course
Authors: Shaffer Clifford A.
Published: January 2005

This paper presents a family of programming projects appropriate to a sophomore-level data structures course, centered around the concept of a buffer pool serving as the access intermediary to a disk file. These projects provide a meaningful vehicle for practicing object-oriented design techniques and teach fundamental material on file processing and manipulating binary data. I begin with a concrete example, a heap stored on disk and mediated by a buffer pool. Several important intellectual concepts introduced by such a project are enumerated. Significant extensions and alternatives to the basic project are then described. I conclude with some observations on the role of file processing in modern CS curricula, and the significance of recent trends away from coverage of these topics.
Understanding gender and confidence in CS course culture
Authors: Irani Lilly
Published: January 2005

Women in the first systems course in Stanford's CS core find themselves in a divided culture in which they are a minority. For these women, establishing an identity of competence becomes critical to defining a place in the CS culture and establishing legitimacy. Social factors such as gendered self-presentation and communication, rather than objective measures of ability, plays a large role in developing confidence. Only by understanding the role of such social factors can we develop strategies for creating a more inclusive CS culture in which women may thrive. Findings are drawn from surveys, interviews, and five years of enrollment data.
Assessing the assessment of programming ability
Authors: Daly Charlie , Waldron John
Published: January 2005

A recent study [7] has shown that many computing students are not able to develop straightforward programs after the introductory programming sequence. Normal student assessment should have highlighted this problem, it did not, therefore normal assessment of programming ability does not work.We examine why current assessment methods (written exams and programming assignments) are faulty. We investigate another method of assessment (the lab exam) and show that this form of assessment is more accurate.We explain why accurate assessment is essential in order to encourage students to develop programming ability.
Using game days to teach a multiagent system class
Authors: Soh Leen-Kiat
Published: January 2005

Multiagent systems is an attractive problem solving approach that is becoming ever more feasible and popular in today's world. It combines artificial intelligence (AI) and distributed problem solving to allow designers (programmers and engineers alike) to solve problems otherwise deemed awkward in traditional approaches that are less flexible and centralized. In the Fall semester of 2002, I introduced a new game-based technique to my Multiagent Systems class. The class was aimed for seniors (with special permission) and graduate students in Computer Science, covering some breadth and depth of issues in multiagent systems. One of the requirements was participation in four Game Days. On each Game Day, student teams competed against each other in games related to issues such as auction, task allocation, coalition formation, and negotiation. This article documents my designs of and lessons learned from these Game Days. The Game Days were very successful. Through role-playing, the students were motivated and learned about multiagent systems.
A distributed task environment for teaching artificial intelligence with agents
Authors: Hill John M. D. , Alford Kenneth L.
Published: January 2005

It is not uncommon to teach Artificial Intelligence (AI) by asking students to implement agents that embody intelligent behavior. This helps students gain a fuller understanding of the many concepts taught in the course. There are two issues with this approach that deserve attention. First, students come into an AI course knowing how to program in different languages and having different levels of programming ability. Second, it's useful for the students to have a single task environment for all of the agents they program. A solution to both issues lies in a distributed system where the agents are clients communicating with a server that handles a configurable task environment. This allows the students to program their agents in any language and on any platform they desire, so long as they can communicate with the task environment server. If the task environment can be configured to provide additional levels of complexity and difficulty, this allows students to program at a level they are comfortable with. They can then challenge themselves by incorporating more advanced capabilities into their agents. This paper presents just such a distributed and configurable task environment that was developed for an undergraduate AI course.
Houston, we have a problem
Authors: McKinney Dawn , Denton Leo F.
Published: January 2005

The affective domain can be used to support the internalization of cognitive content and foster the development of curriculum and industry-related interests, attitudes, values, and practices. This study investigated correlations between affective factors and course grade. Interest, perceived competence, effort, lack of pressure, and value correlated significantly with CS1 course grades. Moreover, this study investigated the levels of these factors over the course of CS1. Almost all of the levels of these significant factors decreased significantly during the CS1 course as measured by pretests and posttests. Results of this study further indicated that the use of specific affective objectives and instructional strategies lessened these decreases.
Wanted
Authors: Ventura Phil , Ramamurthy Bina
Published: January 2005

This paper reports research on the effect of prior programming experience on success in an objects-first CS1. In an objects-first, approach students are taught from the very beginning to think in terms of objects and the fundamentals of object-oriented programming, encapsulation, inheritance, and polymorphism. These concepts are introduced before traditional selection and iterative constructs. The finding that students with prior programming experience do not do better than those without such experience flies in the face of conventional wisdom.
Scaffolding with object diagrams in first year programming classes
Authors: Thomas Lynda , Ratcliffe Mark , Thomasson Benjy
Published: January 2005

This paper reports on an experiment in which first year programming students were given explicit encouragement to use Object (Instance) diagrams when tracing code in multiple-choice questions. We conjectured that by providing scaffolding in this technique, students would be helped to understand the code better and that they would then continue to draw their own diagrams in similar situations. This turned out not to be the case. Although generally students who draw diagrams do better in questions that test their understanding of code behaviour and object referencing, our intervention does not appear to have helped students and the students who were exposed to the intervention were not more likely to go on to use the technique themselves.
CS educational research
Authors: Valentine David W.
Published: January 2005

A meta-analysis is performed on the last twenty years of SIGCSE Technical Symposium Proceedings, looking for the kind of CS Educational Research that has been done at the CS1/CS2 level. A six-point taxonomy of articles types is described. It is shown that about one in five of all CS1/CS2 presentations have used some kind of experimental model, albeit "experimental" is defined quite broadly. Over the last ten years both the number of experimental models, and the percentage of experimental models among CS1/CS2 has significantly increased. SIGCSE members are challenged to adopt a research model for their presentations to the Technical Symposium.
Writing efficient programs
Authors: Debray Saumya
Published: January 2005

Performance is an essential aspect of many software systems, and it is important for programmers to understand performance issues. However, most undergraduate curricula do not explicitly cover performance issues---performance monitoring and profiling tools, performance improvement techniques, and case studies---in their curricula. This paper describes how we address this topic as part of a third-year programming course. We focus on tools and techniques for monitoring and improving performance, as well as the interaction between clean program design and performance tuning.
Components-first approaches to CS1/CS2
Authors: Howe Emily , Thornton Matthew , Weide Bruce W.
Published: January 2005

Among the many ways to focus CS1/CS2 content, two have been published that emphasize concepts of component-based software engineering. Courses based on these two instances of a "components-first" approach are remarkably similar in several crucial respects--which is surprising because they were developed independently and with very different objectives. Indeed, the two versions are based on virtually the same principles for content organization, and they share many common features that are unusual for CS1/CS2. Yet, they are notably different in other ways. Detailed analysis of similarities and differences suggests that it might be possible to transfer some of their claimed and documented advantages to other approaches within the programming-first paradigm for CS1/CS2, by rearranging the content of such courses in accord with the underlying principles of the components-first approach.
What do the experts say?
Authors: Lewis Tracy L. , Rosson Mary Beth , Pérez-Quiñones Manuel A.
Published: January 2005

This study examined ways to improve students' chances of success learning design concepts through the use of Object-Oriented Programming and Design (OOP&D) patterns by examining potentially effective ways to teach such patterns to novice programmers. Using hierarchical tree, complete-linkage analysis to survey a group of design experts, the study developed an order in which those experts believed thirty fundamental OOP&D patterns should be taught to optimize effective student learning. Once that basic order was identified, it became possible to divide the patterns into six sequential phases of patterns instruction to allow both maximal teaching and learning. Although the study did not present a conclusively effective approach for OOP&D teaching, it did provide information essential for future sequential phase patterns research.
Remote access internetworking laboratory
Authors: Yoo Sung , Hovis Scott
Published: January 2005

College students in computer networking courses are very interested in Internet technology because of the rapid growth in that area. Of particular interest is the need for practical experience in network design and configuration. A typical computer networking class curriculum includes the study of theory and the laboratory projects. The laboratory projects are designed to give students a better understanding of computer networks. Most of the laboratory projects are software projects. Furthermore it is common to find projects in the area of implementing an application layer protocol and protocol observations in many computer network course textbooks [7,11,12]. However, having a networking laboratory with the proper hardware facilities to teach real networking has several difficulties. These difficulties include funding for the hardware facility, physical space limitations, and physical accessibility of the lab facility [6,10]. We have designed a networking lab that can solve these problems. Old PCs have been converted to IP routers with the free router software Zebra [5]. The proposed laboratory system can be accessed through the Internet, and the network topology can be changed remotely.
A disk head scheduling simulator
Authors: Robbins Steven
Published: January 2005

Disk head scheduling is a standard topic in undergraduate operating systems courses. Disk drives were once fairly simple devices with little intelligence. Disk head scheduling and bad block mapping were done exclusively by operating systems. As disk drives became larger and faster, they took on some of these tasks. Modern drives often have a large cache and hide their internal structure from the outside world. In spite of changes in disk technology, the teaching of disk head scheduling has changed little over the last decade. This paper describes a disk head scheduling simulator that allows students to explore traditional disk scheduling algorithms as well as the consequences of modern disk technology. The simulator, which is written in Java and is freely available, can be run remotely from a browser or downloaded for local execution. We present methods for modifying the traditional curriculum to make the presentation of disk head scheduling more relevant and interesting.
If you know b-splines well, you also nnow NURBS!
Authors: Fisher John , Lowther John , Shene Ching-Kuang
Published: January 2005

This paper presents our attempt in designing intuitive and interesting materials for teaching NURBS in an undergraduate course with the help of our tool
DesignMentor
. This approach does not require tedious mathematics and is based on learning-by-doing and visualization. Our approach was classroom tested and used world-wide in the last seven years.
Simple, low-cost stereographics
Authors: Zelle John M. , Figura Charles
Published: January 2005

Students are very interested in cutting-edge technologies like virtual reality (VR), and VR has many potential uses in education. However, building VR applications has proved challenging due to both cost and technical skill barriers. Through a series of experiments in "shoestring" VR, we have developed methods of bringing an important facet of VR, stereoscopic display, to our students in a simple, cost-effective way. This paper describes our approach.
Teaching computation to undergraduate scientists
Authors: Kaplan Daniel T.
Published: January 2005

This paper describes the motivation and design of an introductory computational course for natural, physical, and social scientists.
CFX
Authors: Reed Dale , John Sam , Aviles Ryan , Hsu Feihong
Published: January 2005

Finding just the right example to answer a question can be difficult for CS1 students and teachers. For this to work well there must be an intuitive interface coupled to an appropriate set of focused examples. The examples then provide the scaffolding to enable students' discovery. CFX (C For eXample) provides the needed easy-to-use web based interface.A small pilot study showed that students using CFX could find answers to their programming questions in roughly half the time it took using a textbook. Freely distributed as open source software under the GNU General Public License [4], CFX can be used as a database authoring tool to capture a set of examples. Once the content is established, the interface as well as the data can be automatically exported to a standalone dynamic interface, using static, non-database content.The development of this system has been sponsored in part by NSF's CCLI program, with sample content developed in conjunction with McGraw-Hill.