bluuebunny/crossref_metadata_2025 huggingface dataset:
YAP3
Authors: Wise Michael J.
Published: July 2004

In spite of years of effort, plagiarism in student assignment submissions still causes considerable difficulties for course designers; if students' work is not their own, how can anyone be certain they have learnt anything? YAP is a system for detecting suspected plagiarism in computer programs and other texts submitted by students. The paper reviews YAP3, the third version of YAP, focusing on its novel underlying algorithm -
Running-Karp-Rabin Greedy-String-Tiling
(or
RKS-GST
), whose development arose from the observation with YAP and other systems that students shuffle independent code segments. YAP3 is able to detect transposed subsequences, and is less perturbed by spurious additional statements. The paper concludes with a discussion of recent extension of YAP to English texts, further illustrating the flexibility of the YAP approach.
Teaching formal programming to first year computer science students
Authors: McLoughlin Henry , Hely Kevin
Published: July 2004

The integration of formal methods into the undergraduate curriculum has been slow considering the benefits they offer. One reason for this is that the limited number of relevant textbooks, although excellent, are rather terse. As a result, we have developed various techniques for teaching formal programming in which each step is fully justified by appealing to a design rule or heuristic. Another technique we have developed is 'programming by rule' using generic templates to solve problems of similar structure---rather like differentiation by rule. Our experience to date has been encouraging. We outline some of these techniques and give examples of them in practice.
Web-based laboratories in the introductory curriculum enhance formal methods
Authors: Jones Rhys Price , Ruehr Fritz , Salter Richard
Published: July 2004

In order to be effective, the content of the introductory curriculum must strike a proper balance between the highly motivating (i.e. "fun") aspects of programming and the development of sound scientific background and analytical thinking. As part of an NSF-funded Education Infrastructure project at Oberlin College, we have developed a curriculum that maintains a high level of scientific rigor, while making use of the new technology of HTML and the World Wide Web to instruct and motivate. We provide our students with an integrated experience which includes web-based guided-study laboratory materials, an interactive programming environment and a syllabus which emphasizes the interplay between abstract and formal concepts on the one hand, and concrete implementations and experimental investigations on the other. Scheme is used as the primary programming environment, to illustrate the salient features of the imperative and the object-oriented paradigms, along with the functional paradigm with which it is usually associated. We believe that our approach: 1) revitalizes the material for students who expect a more modern presentation; 2) provides a balanced view of competing perspectives on programming style and methodology; and 3) provides a well-balanced mixture of formal analysis and experimental measurement.In order to produce laboratory materials without the overhead entailed by creating them directly in HTML, we have developed a tool capable of abstracting the functionality and style of HTML documents; thus we can engage both faculty and student authors in the development of laboratories with a uniform style. The very tools used to develop the online materials are themselves an excellent illustration of the empowerment which results from a thorough understanding of the principles of abstraction.
Thinking about binary trees in an object-oriented world
Authors: Berman A. Michael , Duvall Robert C.
Published: July 2004

The Binary Search Tree serves as an important example when teaching data structures. We explore new approaches to understanding the implementation of a Binary Search Tree, using concepts from Object-Oriented Programming and C++. The Binary Search Tree illustrates how adopting a new approach and a new language can lead to a new way of thinking about a familiar problem.
Nightmare on Westwood Avenue
Authors: Dorf Mary Lou , Heuring Gerald R.
Published: July 2004

Traditionally, computer software development courses have produced projects with small numbers of homogeneous users requiring limited maintenance and which run on a single platform as opposed to products which are distributed to large numbers of diverse users, run on multiple platforms, and which are upgraded and re-released many times. The NSF/ILI-IG grant with the university match provided funding to establish a software product development laboratory in an effort to provide students with the product development experience that many will need upon graduation.This paper discusses the concept for, the goals and subgoals of, and the first year's evaluation of the Product Development Laboratory.
Integrating collaborative problem solving throughout the curriculum
Authors: Daigle R. J. , Doran Michael V. , Pardue J. Harold
Published: July 2004

Our graduates are ill-prepared for entry positions in industry. This is the message from a 1994 NSF task force comprised of members from academia and industry. Among the specific deficiencies cited were problem-solving skills and the ability to work in groups. In a recent publication, the authors described a group problem-solving model, Group Zig Zag, based on the Myers-Briggs Type Indicator. In this paper we show how the integration of a collaborative approach throughout the curriculum can be achieved by adopting the Group Zig Zag model.
Documentation standards in the undergraduate computer science curriculum
Authors: McCauley Renée A. , Jackson Ursula , Manaris Bill
Published: July 2004

This paper focuses on documentation standards and their employment throughout the undergraduate computer science curriculum. Specifically, it presents the motivation for a set of well-defined documentation standards for programming-intensive computer science courses. Additionally, it discusses the establishment of standards addressing both the procedure- and object-oriented programming paradigms. Finally, it relates the authors' experiences in using such standards to teach many software engineering principles along with required concepts in the undergraduate computer science curriculum.
Efficiency of algorithms for programming beginners
Authors: Ginat David
Published: July 2004

Introductory computer science courses often present the concept of algorithm efficiency in a rather late stage, through searching and sorting problems. We believe that the concept of efficiency can be presented much earlier. In this paper we present a novel approach in which efficiency of algorithms is presented early, gradually and intuitively. We link our approach to cognitive consequences of programming instruction and illustrate it with three problems.We implemented our approach with 10th and 11th grade high-school students. In the paper, we describe our experience with posing the three problems to the students. Student solutions varied considerably, reflecting different levels of insight into the problems. The various solutions led to fruitful class discussions, thus widening the students' repertoire of templates, and enhancing student realization as to the importance of analysis and planning.
Using iterative enhancement in undergraduate software engineering courses
Authors: Hutchens David H. , Katz Elizabeth E.
Published: July 2004

Many software development courses include both instruction in formal and informal techniques and application of those techniques on a team project. In teaching such a course, a dilemma arises in trying to present material in sufficient detail before students must apply the material in their projects. The students are not comfortable with a technique before they must use it. If the project is moved later in the course, the students do not have enough time to tackle a problem that is big enough to require many of the software development techniques. There must be a better approach to teaching the course without separating the material into two courses or dividing the course over two terms.This paper describes an iterative approach. Let the students develop an initial pass at the project using the techniques they know. Then, have them apply the techniques learned in this class to later iterations. They develop a reasonably large project and apply the techniques appropriately. In addition, they have an opportunity to modify and maintain their documents as they complete the project. This paper describes the approach, experiences using it, and what modifications might be useful.
Lecture supporting system by using e-mail and WWW
Authors: Nishida Tomohiro , Saitoh Akinori , Tsujino Yoshihiro , Tokura Nobuki
Published: July 2004

We have developed a system to support communication between students and teachers on the computer network. By using e-mail, they can exchange information, e.g., questions and reports whenever and wherever they can access the Internet. And by using World Wide Web, the teacher can provide impressive teaching material for the student. Moreover the system provides "easy maintenance" facilities. So the teachers who use it don't have to master the details of the system. They can use it easily by following various navigational information instructions. And to use the system for many years, it can reuse information and setups which were made previously.
WWW interactive learning environments for computer science education
Authors: Carlson David , Guzdial Mark , Kehoe Colleen , Shah Viren , Stasko John
Published: July 2004

The wide accessibility of the World Wide Web makes it a perfect base for developing computer science courseware modules. Since learning involves more than just receiving transmitted information, courseware must be interactive and encourage student engagement, which is a challenge on the Web architecture. This article describes an ongoing effort to develop World Wide Web-based computer science courseware modules that will use interactive components as integral parts of the material, in order to promote student involvement. It also discusses the proposed usage of new technology such as HotJava in this framework.
A semester project for CS1
Authors: Bareiss Catherine C.
Published: July 2004

While much work has been done on the lab component of the CS1 course, programming assignments have not received as much attention. Many CS1 courses have a series of programming assignments that supplement the lab component. However, the assignments are often unrelated to each other. While the advantages of semester project for upper division courses are well known, little has been done on the use of a semester project in the first programming course. However, it is feasible for a first semester programmer to complete an entire semester project if it is designed properly. The development of a semester-long programming project done in phases has many benefits to offer a CS1 course.
The quest for excellence in designing CS1/CS2 assignments
Authors: Feldman Todd J. , Zelenski Julie D.
Published: July 2004

We identify the principles involved in designing effective programming assignments for CS1/CS2. Through a case study of a particularly successful recursion assignment, we establish several prerequisites that must be present in the foundation of a potential assignment and discuss techniques for engineering exceptional assignments through changes to their more malleable components.
Three-dimensional computation visualization for computer graphics rendering algorithms
Authors: Goldman David A. , Eckert Richard R. , Cohen Maxine S.
Published: July 2004

Computation visualization or algorithm animation is becoming an increasingly popular and effective way of teaching, debugging, and analyzing algorithms. Over the past ten years, several algorithm animation systems have been produced. Proposed here is a new approach and framework for visualizing three-dimensional algorithms or computations. Implemented on a prototype algorithm animation system, this framework, termed the vector-guided view, produces insightful visualizations of three-dimensional computation by effectively solving the problems of 3D scene navigation. The creation of this framework was motivated by the desire to produce visualizations of an increasingly large and complex set of rendering algorithms now ubiquitous in the field of computer graphics. To show the potential of this framework, a dynamic visualization of a recursive ray-tracing program has been created. A brief summary of the algorithm animation system is presented.
The computer science fair
Authors: Fitzgerald Sue , Hines Mary Lou
Published: July 2004

Dissatisfaction with the results of programming contest events has led to the development of a new type of competitive event, a computer science fair. The computer science fair, a combination art show/science fair, is designed to attract a wider diversity of participants, to encourage creativity, and to reinforce good project development practices. Students are asked to creatively use technology to express themselves, to design new inventions, and to solve problems by submitting projects in the following categories: 1) computers and the arts and humanities --- computer music, computer art, multimedia projects; 2) computer programs --- entertainment, education, scientific, business, modeling and simulation; and 3) computer or electronically controlled inventions. This paper outlines the rules for submissions and judging of projects and the results of the First Annual Kansas City Computer Science Fair. Results based on gender and age category are reported.
Computer programming in high school vs. college
Authors: Schollmeyer Martina
Published: July 2004

Although there exists a computer science certification exam for high school teachers in some states, there appear to be no general requirements for teaching computer science at the high school level in most states. This may imply that CS material taught at the high school level is not always well-suited for students who want to pursue CS in college.This paper discusses some observations on what skills and abilities are important to prepare high school students for a successful career in CS at the college level. It also discusses preconceived ideas of college freshmen on what computer programming is all about.
A first course in C++ and object oriented programming
Authors: Scafide Jean
Published: July 2004

Almost 70% of industrial job openings list knowledge of C/C
++
as a desirable qualification of potential job applicants. This large and increasing demand for programmers with C/C
++
experience is leading many colleges and universities to switch to C/C
++
as their primary teaching language. This paper presents a detailed outline for an introductory class in C
++
offered to community college students who have completed a single semester of Pascal. The class was first taught in the fall semester of 1994. The paper pinpoints problem areas encountered and discusses refinements made in class content during succeeding semesters.
Knowing your roots
Authors: Adams Joel C.
Published: July 2004

By applying object-oriented design to the definition of a binary search tree, Berman and Duvall [1] designed a data structure comprised of three classes: (i) an Empty
bst
class to model empty binary search trees, (ii) a NonEmpty
bst
class to model non-empty binary search trees, and (iii) a
bst
base class for common attributes of Empty
bst
and NonEmpty
bst
objects. That paper noted the problem of inserting new values into such a structure: since insertions occur at an Empty
bst
object, an Empty
bst
would have to "turn into" a NonEmpty
bst
; a behavior beyond the capabilities of the classes in most languages.This paper presents three C++ solutions to the insertion problem in their order of development. The first solution uses a procedural programming technique, with the second and third solutions shifting to a more object-oriented approach. This chronology illustrates the author's ongoing battle to shift from procedural to object-oriented thinking.
Bandwagons considered harmful, or the past as prologue in curriculum change
Authors: Kay David G.
Published: July 2004

The field of computer science changes rapidly, and this change occurs as well in the introductory curriculum. Formerly advanced topics filter down to the first year, and even to secondary school; some topics disappear completely. These changes are good---they indicate a dynamic discipline and a still-emerging picture of the field's fundamental principles. But we must not let our revolutionary zeal blind us to the pedagogical need and conceptual value of time-tested material. Many topics and approaches that are well understood and now unfashionable should retain their place in the introductory curriculum, where they serve as intellectual ballast, foundation, and motivation for the more current and trendier content. We argue here for balance: that radical change be tempered by an appreciation for the place of long-standing approaches and underlying fundamentals. Those advocating curricular change must articulate their educational goals fully and consider explicitly what effect on those goals they expect the change to have; they must not throw the baby out with the bathwater.
Planning for software verification and validation
Authors: Wallace D R , Fujii R U
Published: July 2004

Software verification and validation (V&V) is a systems engineering process that supports the evaluation of software quality. Software V&V requires careful planning for effective application of a rigorous methodology for evaluating the correctness and quality of the software product throughout the software life cycle. A recent standard, the IEEE Std. 1012--1986, Standard for Software Verification and Validation Plans (SVVP), provides direction for preparing or assessing a software verification and validation plan.This Standard provides uniform and minimum requirements for the format and content of Software Verification and Validation Plans (SVVPs). The Standard specifies minimum verification and validation tasks and the associated inputs and outputs which must be included in SVVPs for noncritical software. it recommends their inclusion in SVVPs for noncritical software. The Standard lists optional V&V tasks to permit the V&V planner to tailor the V&V effort to suit project needs.Definitions for verification, validation, critical software, and software lifecycle are adapted from those from the IEEE Standard Glossary of Software Engineering Terminology, ANSI/IEEE Std 729-1983. The IEEE 1012 Standard directs that V&V shall be initiated early in the lifecycle and parailels development. The Standard can be used with a wide variety of lifecycle models and approaches, i.e., the traditional waterfall model as well as rapid prototyping. In order for the Standard to have broad use, it does not specify a particular V&V organizational approach; nor does it require specific tools or methodologies to perform the V&V tasks but rather establishes minimum criteria for a V&V plan.
Experience with evolutionary prototyping in a large software project
Authors: Hekmatpour S
Published: July 2004

Rapid prototyping has created much interest in recent years and is gradually finding a foothold in software engineering. There is still, however, some confusion and disagreement about its potentials and role in software development. This paper first takes a broad look at the approaches to prototyping and then describes a large software project which employed an evolutionary prototyping approach. It concludes that, in contrary to some previous suggestions, evolutionary prototyping in not limited to small scale software and can cope with large projects as well.
Design approaches and DoD-STD-2167
Authors: Coad P
Published: July 2004

Far too often people assume that DoD-STD-2167,
Defense System Software Development
, requires a top-down design approach. Yet this is not true. Some exact quotes are in order. But first, some acronyms and an appendix name are needed:CSCI Computer Software Configuration ItemSAM Software Acquisition ManagerSDP Software Development PlanSSPM Software and Standards Procedures ManualTLCSC Top-Level Computer Software Component
Implementing user/computer dialogue in COBOL
Authors: Richards Roy Martin
Published: July 2004

For information processing to be effective in today's computer environment, the programming language used must be capable of interaction. This requires that the language be able to handle dialogue between the user and the computer. Since COBOL is currently the predominant language used in business information systems, this article examines the COBOL language as to its capabilities for interaction in terms of five currently popular dialogue styles and shows how each style can be implemented in COBOL programming.
Dynamic structure in software architectures
Authors: Magee Jeff , Kramer Jeff
Published: July 2004

Much of the recent work on Architecture Description Languages (ADL) has concentrated on specifying organisations of components and connectors which are static. When the ADL specification is used to drive system construction, then the structure of the resulting system in terms of its component instances and their interconnection is fixed. This paper examines ADL features which permit the description of dynamic software architectures in which the organisation of components and connectors may change during system execution.The paper outlines examples of language features which support dynamic structure. These examples are taken from Darwin, a language used to describe distributed system structure. An operational semantics for these features is presented in the π-calculus, together with a discussion of their advantages and limitations. The paper discusses some general approaches to dynamic architecture description suggested by these examples.
Tool support for planning the restructuring of data abstractions in large systems
Authors: Griswold William G. , Chen Morison I. , Bowdidge Robert W. , Morgenthaler J. David
Published: July 2004

Restructuring software to improve its design can lower software maintenance costs. One problem in carrying out such a restructuring is planning the new detailed design. The
star diagram
manipulable visualization can help a programmer redesign a program based on abstract data types. However, our measurements revealed that the view can be too large for a programmer to effectively assimilate. Also, design plans can be expressed only by restructuring, although our studies revealed that it is beneficial to preplan a restructuring. Finally, the tool user can build a star diagram for only a single data structure, although an abstract data type might actually have several components or have multiple instantiations.Exploiting basic properties of the star diagram can mitigate these problems. First, programmer-controlled elision can remove clutter from the star diagram view. Second, elision and annotation of star diagram components can mimic restructuring, thereby supporting the planning of a restructuring. Such support also allows for the planning of a non-restructuring maintenance task. Finally, to dynamically control what data structures are visualized, the tool user can union star diagrams.We built a star diagram planning tool for C programs, measured its elision capabilities, and performed a programmer study for the encapsulation of a widely-used data structure in a 28,000 line program. We found that the amount of elision can be substantial, but is not always adequate. In the study we found that each programming team successfully planned their restructuring in rather different, unanticipated ways.
Decoupling change from design
Authors: VanHilst Michael , Notkin David
Published: July 2004

Parnas' seminal 1972 paper, "On the Criteria To Be Used in Decomposing Systems into Modules," identified simplifying change as a critical criterion for modularizing software. Successful designs are those in which a change can be accommodated by modifying a single module. There is a tacit assumption in most of the literature that once a change has been limited to a single module, the cost of making the change is essentially inconsequential. But modules have complexity of their own and are frequently large. Thus, making a change can be expensive, even if limited to a single module.We present a method of decomposing modules into smaller components for the purpose of supporting change. Although similar to the approach of modularizing programs described by Parnas, our approach is specific to decomposing modules. It is not intended to replace traditional high level modularization but rather to augment it with a second level of modularization where the standard of information hiding can be relaxed. The goal of the method is to make modules easier to change by decomposing them around smaller design decisions---ideally encoding only one design choice per submodule component.In this paper we show how submodule components can be used to address the issue of change. We also demonstrate how the ability to address change with submodule components is, to a large extent, independent of the design level modularization. Moreover, we show that, at least in some cases, by using submodule components the choice of high level modularization can itself be changed without having to rewrite large amounts of code.A method of implementation is presented using inheritance, parameterization, and static binding in a way that minimizes implementation dependencies between components. The method supports fine grained decomposition with flexible composability and almost no runtime overhead.
Program decomposition for pointer aliasing
Authors: Zhang Sean , Ryder Barbara G. , Landi William
Published: July 2004

Pointer aliasing analysis is crucial to compile-time analyses for languages with general-purpose pointer usage (such as C), but many aliasing methods have proven quite costly. We present a technique that partitions the statements of a program to allow separate, and therefore possibly different, pointer aliasing analysis methods to be used on independent parts of the program. This decomposition enables exploration of tradeoff between algorithm efficiency and precision. We also present a new, efficient flow-insensitive pointer aliasing algorithm, which is used together with an existing flow-sensitive aliasing algorithm in our experiments. We demonstrate our technique in the context of determining side effects and variable fetches through names containing pointer dereferences (Thru-deref MOD/REF). Initial empirical results using a combination of a flow-sensitive and a flow-insensitive aliasing analysis on the same program, demonstrate that the resulting analysis is much faster than solely using the flow-sensitive method, and obtains similar precision for the Thru-deref MOD/REF problems.
Generating oracles from your favorite temporal logic specifications
Authors: Dillon L. K. , Ramakrishna Y. S.
Published: July 2004

This paper describes a generic tableau algorithm, which is the basis for a general customizable method for producing oracles from temporal logic specifications. A generic argument gives semantic rules with which to build the semantic tableau for a specification. Parameterizing the tableau algorithm by semantic rules permits it to easily accommodate a variety of temporal operators and provides a clean mechanism for fine-tuning the algorithm to produce efficient oracles.The paper develops conditions to ensure that a set of rules results in a correct tableau procedure. It gives sample rules for a variety of linear-time temporal operators and shows how rules are tailored to reduce the size of an oracle.
Predicting the cost-effectiveness of regression testing strategies
Authors: Rosenblum David S. , Weyuker Elaine J.
Published: July 2004

Selective regression testing strategies aim at choosing an appropriate subset of test cases from among a previously run test suite for a software system, based on information about the changes made to the system to create new versions. Although there has been a significant amount of research in recent years on the design of such strategies, there has been significantly less investigation of their cost-effectiveness. In this paper some computationally efficient predictors of the cost-effectiveness of the two main classes of selective regression testing approaches are presented. A case study is described in which these predictors are used to assess the appropriateness of using a particular regression testing strategy to test multiple versions of a widely-used software system.
Automated support for seamless interoperability in polylingual software systems
Authors: Barrett Daniel J. , Kaplan Alan , Wileden Jack C.
Published: July 2004

Interoperability is a fundamental concern in many areas of software engineering, such as software reuse or infrastructures for software development environments. Of particular interest to software engineers are the interoperability problems arising in
polylingual
software systems. The defining characteristic of polylingual systems is their focus on uniform interaction among a set of components written in two or more different languages.Existing approaches to support for interoperability are inadequate because they lack
seamlessness:
that is, they generally force software developers to compensate explicitly for the existence of multiple languages or the crossing of language boundaries. In this paper we first discuss some foundations for polylingual interoperability, then review and assess existing approaches. We then outline PolySPIN, an approach in which interoperability can be made transparent and existing systems can be made to interoperate with no visible modifications. We also describe PolySPINner, our prototype implementation of a toolset providing automated support for PolySPIN. We illustrate the advantages of our approach by applying it to an example problem and comparing PolySPIN's ease of use with that of an alternative, CORBA-style approach.
Abstracting dependencies between software configuration items
Authors: Gunter Carl A.
Published: July 2004

This paper studies an abstract model of dependencies between software configuration items based on a theory of concurrent computation over a class of Petri nets. The primary goal is to illustrate the descriptive power of the model and lay theoretical groundwork for using it to design software configuration maintenance tools or model software configurations. As a start in this direction, the paper analyzes and addresses certain limitations in make description files using a form of
abstract interpretation.
Reverse engineering and system renovation—an annotated bibliography
Authors: van den Brand M. G. J. , Klint P. , Verhoef C.
Published: July 2004

To facilitate research in the field of reverse engineering and system renovation we have compiled an annotated bibliography. We put the contributions not only in alphabetical order but also grouped by topic so that readers focusing on a certain topic can read their annotations in the alphabetical listing. We also compiled an annotated list of pointers to information about reverse engineering and system renovation that can be reached via Internet. For the sake of ease we also incorporated a brief introduction to the field of reverse engineering.
Process reuse using a template approach
Authors: Lam W.
Published: July 2004

This paper reports on the practical reuse of requirements engineering processes for aero-engine control systems. An approach is presented which uses templates to model typical activities in a process, where a process execution is seen as the instantiation of the template. The paper begins with the motivations for process reuse, and then describes aspects of the template approach in greater detail. The lessons learnt about process reuse based on our experience are summarised. The paper concludes with an early evaluation on the practicality of the approach, and highlights areas of further work.
Use of domain analysis to implement the developer off-the-shelf systems (DOTSS) system acquisition approach
Authors: Gambhir S. S. Gulu
Published: July 2004

This paper discusses implementation of Eisner's Developer Off-the-Shelf Systems (DOTSS) system acquisition approach. The DOTSS method involves reuse of entire systems rather than reuse of modules or subsystems. Reuse issues, including methods, benefits, and obstacles as they relate to the DOTSS approach, are presented. The use of Domain Analysis is proposed as a means of developing a set of high-level system requirements that are not overly specific to the problem domain at hand, thereby allowing existing systems from related domains to be considered for reuse. A set of evaluation criteria that can be used to differentiate candidate systems is also included.
Integrating a defect typology with containment metrics
Authors: Kelsey Robert Bruce
Published: July 2004

Software metrics are numerous and varied, but they are typically disjoint and seldom directly support defect causal analysis. Diagnosing problems in the development process is certainly possible with disjoint metrics, but the task is greatly simplified if at least a subset of the metrics used are both applicable throughout the development cycle and oriented towards causal analysis of process deficiencies. This paper describes one such set of metrics, the integration of phase containment metrics with a modified defect typology drawn from the traditional inspection checklist. The result is a defect typology that identifies not only coding errors but deficiencies in the procedures used to develop and qualify the product.
From manufacturing document requirements to customized authoring and automated publishing framework
Authors: Le Bissonnais Marc , Prunet Francois
Published: July 2004

The aim of this paper is a working-out of an open authoring framework for an automated documentation process binded with an object manufacturing-specific engineering framework. Using standards close together to support product documentation as part of the life-cycle of manufactured products is becoming an actual and urgent topic for industry. Indeed, this area leads people to describe very complex systems, but it uses different models, based on many standards, to be handled together during the life cycle steps of these systems. A customizable automated authoring and publishing framework trying to take into account some multimedia research aspects should make the work easier for the designers of such manufacturing systems, allowing them to follow the design process and to have a better communication. We contribute to the problem by using an object-oriented approach providing structuration, abstraction, re-use and easier upgrading based upon textual and graphical modes through the integration and merging of domain models with object services like customized editors, browsers and parsers.
Evaluating software engineering methods and tools, part 7
Authors: Kitchenham Barbara Ann
Published: July 2004

When planning a feature analysis based evaluation of a method or tool the following areas should be addressed and included in the evaluation project plan:1. scope of the evaluation,2. basis of the evaluation,3. roles and responsibilities,4. procedures,5. assumptions and constraints made, and6. timescale and effort involved.These are discussed in the following sections.
An integrated solution based approach to software development using unified reuse artifacts
Authors: Srinath S. , Venkatesh K. , Ram D. Janaki
Published: July 2004

Although development processes are considered important in determining the quality of the product, often processes and products are considered as separate entities. This results in loss of information regarding dependencies spanning across processes and products. In this paper we propose a unit called Unified Reuse Artifact (URA) which can represent artifacts of either the "process" or the "product," in effect representing an artifact of the "solution." With this, a solution is represented as a directed graph of URAs establishing dependencies in a unified manner. This helps bring in other possibilities like project tracking, deciphering contexts and evolution in a unified way, etc. We then propose a process model oriented towards solutions, and which strives to reuse earlier experiences with the concept of a "Solution Framework."
Property-based testing
Authors: Fink George , Bishop Matt
Published: July 2004

The goal of software testing analysis is to validate that an implementation satisfies its specifications. Many errors in software are caused by generalizable flaws in the source code. Property-based testing assures that a given program is free of specified generic flaws. Property-based testing uses property specifications and a data-flow analysis of the program to guide evaluation of test executions for correctness and completeness.
Applying the “STUDIO” method to the interface design of an environmental software system
Authors: Piattini Mario G. , Tigréat Hervé
Published: July 2004

This paper addresses the application of the STUDIO (STructured User-interface Design for Interaction Optimization) method to the user-interface development of an information system (called "HIMPPA") that allows the simulation of heavy-particle dispersion. This method has been proposed in 1994 by D.P. Browne. We have adapted and integrated it with an object-oriented design technique for the HIMPPA project (an ESPRIT-PASO Special Action).
On testable object-oriented programming
Authors: Wang Y. , King G. , Court I. , Ross M. , Staples G.
Published: July 2004

A new philosophy contributing towards the design of testable object-oriented (
OO
) software is introduced in this paper. The testing of conventional
OO
software focuses on the generation of tests for existing objects and systems; the testable object-oriented programming (
TOOP
) method draws attention to building testabilities into objects and systems during coding or compiling, so that the succeeding processes in test generation and implementation can be simplified. A new method of
TOOP
is developed to improve the testability of
OO
software. Software testability at object level and system level is quantitatively modelled. A set of fundamental built-in testable mechanisms oriented to the basic control structures in objects is constructed in order to improve the testability of
OO
software in terms of test controllability and observability. The most interesting feature obtained by
TOOP
is that the built-in tests in any objects can be inherited and reused in the same way as that of codes or functions in conventional
OO
software.
Teaching ethical and social issues in CS1 and CS2
Authors: Schulze Kay G. , Grodzinsky Frances S.
Published: July 2004

The discussion of whether ethical and social issues of computing should be explored in undergraduate computer science education has resulted in most academic institutions and educators agreeing that they are important topics that must be included. Further support has been provided by Curricula '91 [16], the CSAC/CSAB accreditation [2] and ImpactCS [12]. Many books [7, 8, 9, 10] and papers [6, 14] have discussed what topics should be covered and what techniques can be used either in a dedicated course or in modules across the curriculum. However, explicit detailed examples that have worked successfully, particularly in lower level computer science courses, are still rare. This paper will discuss several examples that have been successfully used in CS1 and CS2 at a medium-sized university.
Exploring Martian planetary images: C++ exercises for CS1
Authors: Fell Harriet J. , Proulx Viera K.
Published: July 2004

We present a series of programming exercises based on photographic images of Mars collected by the NASA Viking Orbiter. Even without the news that there may once have been life on Mars [1], we feel that these exercises provide an exciting platform for exploring machine representation of data, presentation of data, and methods of storing and extracting data from files. All exercises are on the level easily mastered in the first programming course.
A model C++ tree iterator class for binary search trees
Authors: Rasala Richard
Published: July 2004

In object-oriented design, the concept of a container class that holds a collection of similar objects is fundamental. To use a container class most effectively, it is helpful to define one or more associated iterator classes that can return the objects in the container class in a specified order. An iterator is a bridge that permits the caller to use the objects in a container without knowledge of the details of how the objects are stored in the container. Although the concept of iterator is discussed in a number of books on C++ and/or object-oriented design, it is difficult to find a complete example that is both elegant and sophisticated. In this article, we provide such an example by developing an iterator class for binary search trees that is capable of doing all standard traversals: inorder, preorder, and postorder.
Testing object-oriented programs
Authors: Rosenberg John , Kölling Michael
Published: July 2004

One of the major difficulties facing anyone trying to teach the first programming course is how to encourage students to thoroughly test their programs. We would argue that the main reasons for this are the lack of suitable tools for testing and the need to write extra "debug" code in order to verify correct operation. We further argue that the problem is even worse with object-oriented languages because of multiple classes and encapsulation. In this paper we describe the testing tools within the Blue programming environment which allow object-oriented programs to be thoroughly tested without writing a single line of new code.
The object-ownership model
Authors: Dingle Adair
Published: July 2004

Any comprehensive course on object-oriented programming must cover the topics of inheritance and overloading. In addition, in view of the relatively large size of some objects, one should also cover the efficiency of parameter passing techniques. By using recent research results, we motivate and present an effective case study that thoroughly examines the concepts and subtleties of each of these topics.
Object-oriented design and programming
Authors: Schoenefeld Dale A.
Published: July 2004

An undergraduate junior or senior level course in object-oriented design and programming is described. The course assumes familiarity with ANSI C and with data structures. The course is a popular elective among upper division students. The small, elegant, pure, and powerful object-oriented language Eiffel is used to illustrate the significant object concepts and as a guide to identifying the most relevant subsets of the C++ and Java languages.
Teaching with object oriented libraries
Authors: Parlante Nick
Published: July 2004

This paper describes a new course centered around the use of large object-oriented libraries and the distinct skills required to use them effectively. The paper describes the needs which led to the formation of the new course, an outline of the course's goals, topics and projects, and observations and conclusions from the course's first offerings.
Experiences teaching data structures with Java
Authors: Weiss Mark Allen
Published: July 2004

This paper describes our experiences incorporating Java in a Data Structures course. We describe the features of Java that made for a more interesting course, the difficulties that we encountered, and compare Java to the prior languages used in this course, Ada and C++. All in all, we found Java to be a reasonable, but not overwhelming better, alternative. Our students were particularly happy with the experiment.
A Web based configuration control system for team projects
Authors: Curtis Ronald
Published: July 2004

In courses involving team programming projects, it is desirable to have team members share files, and establish procedures for developing a configuration. Often, faculty members also wish to track each team to detect team problems and to determine the team dynamics.This paper describes a system that uses the Web to provide a simple to use student interface for getting and submitting files to their team for building a new configuration. It also describes some of the tools available to the faculty member to organize the teams. Since the system backend is programmable, the faculty member can add any functionality desired.
Tournament play in CS1
Authors: Pargas Roy P. , Lundy Joe C. , Underwood John N.
Published: July 2004

This paper describes the fifth programming assignment given to three CS1 sections in the Fall semester of 1995. The assignment was to design and implement in Ada a program that plays the game of Nim. The students' programs were to accomplish two goals: (1) play and defeat the instructor's Nim playing program, and (2) participate in a course-wide computer-Nim tournament. This paper explains how the assignment was presented to the students, how the game playing programs were developed and evaluated, how the tournament was conducted, the results of the tournament, and an evaluation of the whole exercise.
Compiling
Authors: Haynes Christopher T.
Published: July 2004

Traditional compilation courses use formal methods for parsing, but treat the more important semantic aspects informally. We present a one semester course in which compiler development is reduced to a number of transformation steps, each of which is formally specified, easily tested, and clearly motivated by semantic considerations. The source language is substantial (essentially the host language of the compiler) and the target is a popular RISC architecture.
Doing quality work
Authors: Hilburn Thomas B. , Towhidnejad Massood
Published: July 2004

This paper discusses the role of personal software process definition in the education of computing professionals and the importance of emphasizing quality in the development of software. After examining recent government and industry efforts in introducing and instituting effective software development processes, there is a description of the Capability Maturity Model (CMM) and Watts Humphrey's Personal Software Process (PSP) and its use in industry and academia. The rest of the paper reports on a recent project that introduced PSP concepts into CS1 and CS2. Project methods and activities are described and the results of the project are analyzed. Finally, future enhancements and extensions of the project are discussed.
Grading student programs using ASSYST
Authors: Jackson David , Usher Michelle
Published: July 2004

The task of grading solutions to student programming exercises is laborious and error-prone. We have developed a software tool called ASSYST that is designed to relieve a tutor of much of the burden of assessing such programs. ASSYST offers a graphical interface that can be used to direct all aspects of the grading process, and it considers a wide range of criteria in its automatic assessment. Experience with the system has been encouraging.
On-line publication of CS laboratories
Authors: Knox Deborah L.
Published: July 2004

Many computer science educators are actively developing laboratory materials in support of their courses because the lab activities provide a rich learning environment. Some instructors are hesitant to pursue this type of pedagogy because of the time commitment required or because of a lack of materials to use as a starting point. This paper describes the development of a repository of computer science laboratories to encourage development and use of labs.The project described is an on-line repository, a database developed for the WEB using HTML forms to help tailor user requests for information. The backbone of the repository is currently CGI scripts written in PERL. The features of the prototype include lab submission, searching by keyword or topic, and an annotation capability for each lab.We also describe the plans for a SIGCSE sponsored peer reviewed on-line repository of lab materials which will create a recognized avenue for the dissemination of labs. The peer review process will help insure a level of quality, and grant developers recognition for their scholarly work in support of teaching.