bluuebunny/crossref_metadata_2025_split huggingface dataset:
A seminar course in computer ethics
Authors: Lelewer Debra A. 
Published: July 2004

This paper describes the transformation of a required Senior Seminar course. The transformed course emphasizes ethical, social, political, legal, and economic aspects of computing. In addition, the new rendition of the course increases the requirement for oral and written communication. We describe the previous definition of the course, goals of the redesign, and students' reactions to both the new and old versions. To this author's surprise, student satisfaction is higher with the new course, although it requires more of them.
We discuss course organization, and suggest assignments and teaching strategy. The course was a joy to teach and, fortunately, a very pleasant and meaningful experience for the students.
Teaching EBNF first in CS 1
Authors: Pattis Richard E. 
Published: July 2004

This paper is a guided tour through the first day of a CS 1 course. It discusses teaching Extended Backus-Naur Form (EBNF) as the first topic—not to facilitate presenting the syntax of a programming language, but because EBNF is a microcosm of programming. With no prerequisites, students are introduced to a variety of fundamental concepts in programming: formal systems, abstraction, control structures, equivalence of descriptions, the difference between syntax and semantics, and the relative power of recursion versus iteration. As a non-numeric formal system, EBNF provides a small but concrete context in which to study all these topics.
EBNF descriptions include abstraction (named rules) and the four fundamental control structures (sequence, decision, repetition, and recursion). Because there are no data or parameters in EBNF, it is easy to sidestep tricky issues surrounding variables, scope, assignment statements, and parameter modes. Describing entitles in EBNF is similar to describing computations in a programming language. Students learn to read a description and analyze whether it generates/matches candidate symbols; then they learn to synthesize descriptions from English specifications, augmented by legal and illegal exemplars of symbols.
All these concepts can be covered in one lecture, establishing a high level of formality early in the course, while foreshadowing actual programming language features and techniques to be covered later. Of course, learning EBNF also facilitates presenting the syntax of a programming language concisely during the rest of the course.
Object-oriented simulation of computer architectures using C++
Authors: Reid Richard J. 
Published: July 2004

Object-oriented languages such as C++ allow class definitions which eliminate the need for writing special-purpose simulators in many cases. Simulating digital logic components and computer architectures is one case where the simulation model can be effectively and conveniently expressed in the programming language itself.
A class library supporting: schematic organization, multi-level digital-signal representation, and implementations of a modest set of component primitives has been developed. This library supports two forms of hierarchical arrangements; first, the digital signals themselves can be expressed as vectors (as for a bus), either directly or by composition, and second, the digital components can be arranged hierarchically as modules, and the modules can be used in an identical manner in which the primitives are used.
The library code described here is available from the author.
Creating an authentic learning experience in introductory programming courses
Authors: Herrmann Nira , Popyack Jeffrey L. 
Published: July 2004

We have developed an integrated, software-based course in scientific and statistical programming consisting of an introduction to computer programming and data analysis concepts. This course is being taught in an innovative way to non-majors: “stretched” over two quarters rather than taught in a single term. Classes meet in a computer classroom so students have a seamless lecture/laboratory experience to reinforce the concept that the computer should be made use of whenever needed, rather than only at specified lab times.In addition to presenting key programming and data analysis concepts, we are giving the course an applied research focus to illustrate to students the importance and utility of programming and statistical concepts totheir own fields. This focus provides motivation for students to learn material they often perceive to be difficult and not relevant to them. It also provides a mechanism for addressing the increasing perception of faculty in a variety of technological fields that many students have problems with abstraction, the use of symbolic notation to understand or express ideas (e.g., through mathematical models), the interpretation of graphical information, and written communication, since all of these skills are needed in applied research.The software-based approach to teaching programming concepts dovetails nicely with the applied research orientation of the course in that the software we use is widely applicable to a variety of activities, from word-processing to data handling and analysis.
Restructuring the introductory computer science course for engineers
Authors: Lambert Joseph M. 
Published: July 2004

In Engineering curricula, the introductory course in computer science is an essential component of the lower division preparation of all engineers. Unfortunately, there is absolutely no consensus what should be included in an introductory computer science course for engineers. Moreover, limited energy has been given by the departments who deliver this introductory course to the currency and vitality of the course.
The focus of this paper is to promote a discussion regarding the design and implementation of a three credit course that meets the overriding concerns voiced by Engineering faculties and by students who enroll in the courses. We present a prototype of a course that addresses the concerns of language preference expressed by Engineering faculty as well as their concern regarding the selection of the ever changing software packages to be presented to the students.
Our design presents a course that will challenge all students regardless of their background in computing. This course would set in place a continuing mechanism to insure relevancy of the course to the students.
Modula-2 versus C++ as a first programming language—some empirical results
Authors: Hitz Martin , Hudec Marcus 
Published: July 2004

The success of an experiment of using C++ as a first programming language for students of a specific type of computer science is presented.
The paper motivates the shift from Modula-2 to C++ in the curriculum, shortly describes the course and discusses the statistical evaluation of the results of the last Modula-2 course and the first C++ course, respectively.
The main findings of the study are the fact that in contrast to most expectations, the shift from a typical “educational” language to a much “dirtier” language had no significant effect to the performance of the students taking the course.
TIC-TAC-TOE
Authors: Pilgrim Robert A. 
Published: July 2004

Machines that play simple games have been a part of the development and promotion of computers for years. Charles Babbage conceived of a machine to play tic-tac-toe in an effort to obtain funding for his Analytical Engine. As part of the Summer Computer Science Workshop, participants design and implement a rule base for an expert system that plays the game of X's and O's (tic-tac-toe). This simple game was selected because most middle school age students are already domain experts. The participant has to select and order six or fewer rules with a seventh catch-all rule, “Take any available position.” The designers debug their own expert systems by playing the game and modifying their rule bases. Once they are satisfied with thier own design, they play against each other's expert systems in a round-robin tournament.
The development environment, written in Pascal to run under MS-DOS, displays the current state of the game board and lists the rules with the most recently “fired” rule being highlighted. This program is far from a complete expert system, but it does illustrate a number of principles of expert systems design.
Like most expert systems, a reasonable solution to the tic-tac-toe problem can be embodied in a surprisingly small rule base. No more than seven rules are needed to play a perfect game of tic-tac-toe, and the same rule base is valid whether the opponent or the computer makes the first move.
Formal specification of reusable interface objects
Authors: Alencar P. S. C. , Cowan D. D. , Lucena C. J. P. , Nova L. C. M. 
Published: July 2004

In this paper we present a formal approach of a new object-oriented design concept to support reuse-in-the-large called Abstract Data Views (ADVs). The ADV approach was created to specify clearly and formally the separation of interfaces from the application components of a software system. Such an approach should lead to high degree of reuse of designs for both interface and application components.
Our specification framework is based on descriptive schemas for both ADVs and ADOs, that are the basic building blocks for the system specification, design, and implemention using the ADV approach. These schemas describe the structural, static, and dynanmic features of each system object, and include the specification of the concurrent operation of system components. Additionally, such schemas can be seen as an underlying structure to support the development of a specification language that describes the interconnection between interface and application components.
Reuse dimensions
Authors: Dusink Liesbeth , van Katwijk Jan 
Published: July 2004

In recent years, there have been much publications on reuse. In order to bet an overview of the whole field and also a good impression of the state of the reuse art, we studied reuse literature of the last few years. As basis for comparison, we classified literature according to four (more or less orthogonal) dimensions, based on the actions and knowledge of the reuser, i.e. the software engineer. The dimensions are: actions to be taken to get an existing reusable item; knowledge to be applied to find an existing reusable item; actions to be taken to build the complete system needed; knowledge to be applied to get the complete system needed.
The survey shows that research on reuse from the viewpoint of needed system, receives far less attention than research from the viewpoint of reusable artifacts. We expect reuse to live up to its promise if this topic is addressed was well.
Research directions in software reuse
Authors: Gall Harald , Jazayeri Mehdi , Klösch René 
Published: July 2004

Software reuse is no longer in its infancy. We are able to look back at more than 15 years of research and should use the opportunity of such a symposium to critically evaluate the past research in order to identify promising future research areas in software reuse.
In this paper, we give a broader view of reuse and some of the so far less-considered areas, which we believe may support software reuse to get off the ground. We mention our ongoing research in software reuse, discussing reuse experiments in the areas of long-term software evolution and component programming.
Furthermore, we indicate the critical importance of interactions among the reuse and related communities within software engineering, such as the object-oriented and the software maintenance communities.
Exploiting domain architectures in software reuse
Authors: Gacek Cristina 
Published: July 2004

This paper provides motivation towards the use of domain specific repositories and DSSA's. It shows many of the positive side-effects this usage brings about.
An extension to the faceted approach to components classification [Prieto-Diaz and Freeman 1987] is introduced. Our extension suggests a natural way of further benefiting from the use of domain specific repositories.
Realistic student projects
Authors: Joel William J. 
Published: July 2004

When a student performs a project, under the supervision of a faculty member, it is important that the student feel that the project is of merit and reflects both the student's capabilities as well as the student's interests. All too often the project is fine unto itself but has no connection to the student's other studies or background except that the project falls in the same major field.
Therefore it is important to create a project, in cooperation with a student, that is not only challenging in itself but also relies heavily upon the student's previous coursework. It should mimic project work as performed outside the academic sphere in that it yields a useable result.
Through the use of techniques such as a contract for project grade, outlining attainable goals agreed upon by both the student and the instructor, the student gains an understanding of the project in relation to the student's entire course of studies, as well as future endeavors.
Teaching digital hardware by using complex lab projects
Authors: Prosser Franklin , Winkel David 
Published: July 2004

Indiana University's Department of Computer Science teaches digital hardware organization and design as a two-semester course sequence at the senior/graduate level. The courses are four credit hours each and have classroom and laboratory components. Our goals have been to provide a firm foundation of theoretical and practical knowledge of digital hardware so that our graduates can understand electronic devices, design digital hardware, and work effectively on large projects with engineers, scientists, and managers.
In the laboratory our students confront a small number of large and complex problems, with few or no small-scale isolated experiments. This philosophy is consistent with the approach usually taken in the software areas of our curriculum—to try as best we can to teach the student to cope with the complex issues found in real-world problem-solving. Achieving this goal in the digital hardware instructional laboratory requires a substantial commitment of funds and faculty and staff effort.
An industrial advisory council for a computer science department: a case study
Authors: Ballew David 
Published: July 2004

This paper defines the need for an Industrial Advisory Council for a Computer Science Department and describes how such a Council can benefit the Department in its construction and updating of curriculum, in faculty and student development, in its relationship with the college or university administration and in its work with industry recruiters and management. The paper gives the details of a working Industrial Advisory Council and explains how the Council has actually helped with the items listed above.
The Council described functioned for three years while the author was Head of the Department at the South Dakota School of Mines and Technology. The author now has a new position at Western Illinois University and the paper describes the formation of a new Council at that University.
The effect of a constructivist learning environment for field-dependent/independent students on achievement in introductory computer programming
Authors: Gibbs David C. 
Published: July 2004

Research was conducted to determine the effect of a constructivist learning environment upon field dependent (FD) and field independent (FI) students' achievement in an introductory computer programming course. Prior research in traditional environments had established a correlation between field dependence / independence (FD/I) and the design stage of programming.
A correlational design was followed, using introductory computer science students in their first programming course. A pretest of BASIC programming ability was given to assess baseline proficiency. The Group Embedded Figures Test (GEFT) was given to assess each subject's measure of FD/I. A constructivist model for learning programming was implemented. Achievement tests in two of the stages of programming, design and coding were administered. As additional dependent variables, student construction of programming elements — the design (semantic) elements, and the language-specific coding (syntax) elements - were collected in a portfolio and examined for both qualitative and quantitative differences.
No significant correlations were found between FD/I and the achievement scores of design and coding. No correlation was expected between FD/I and coding. There was no interaction between FD/I and design versus coding. The correlation between FD/I and the quantity of reconstructed programming elements was not significant. The correlation between FD/I and the quality of reconstructed programming elements was not significant. No interaction was found between FD/I and the quantity or quality of semantic versus syntactic elements. Stepwise multiple regression identified two predictors, for design, the predictor was the pretest. Coding was predicted by the quantity of syntactic programming elements.
The principal finding of this research, in contrast to findings in traditional environments is that within this constructivist environment, the cognitive style of FD/I was not found to influence programming achievement.
What's new with ABET/CSAB integration (panel session)
Authors: Saperstein Lee , Martin Kenneth , Bonnette Della , Lidtke Doris K. 
Published: July 2004

The Accreditation Board for Engineering and Technology, Inc. (ABET) and the Computing Sciences Accreditation Board (CSAB) signed a Memorandum of Agreement in November 1998 to integrate CSAB's accreditation services with ABET, with a transition time of approximately two years. During the interim period, the operations of the Computer Science Accreditation Commission (CSAC) are contracted by CSAB to ABET. A committee with CSAC, CSAB, and ABET representation is working to set up the new commission for accrediting programs in the computing sciences. This new commission will probably be called the Computing Accreditation Commission (CAC). Other activities are underway to try to assure that this integration goes as smoothly as possible.
The panel members will discuss from various points of view the current status of the integration and plans for the completion of the integration. Kenneth Martin is a Past Chair of CSAC. Lee Saperstein is past Chair of EAC. Della Bonnette is a Past CSAC Chair and current Team Chair. Doris Lidtke is serving as Adjunct Accreditation Director for Computing at ABET and a Past President of CSAB.
Teaching advice and support for new and adjunct faculty (panel session)
Authors: Congdon Clare Bates , Fitzgerald Sue , King Merle S. , Semmes Pat , Kay David G. 
Published: July 2004

The demand for computer science faculty is growing rapidly, along with the demand for seats in computer science courses. The problem of finding, recruiting, and retaining computer science faculty may have reached crisis proportions[1]. Meeting this demand means an influx of new faculty, including perhaps nontraditional faculty such as adjuncts from industry, emeriti, graduate students, or faculty from other disciplines.
Such diversity is valuable but brings its own challenges. One of these is acclimating new faculty, particularly those from different academic or industrial environments, to the norms, practices, and expectations of a particular school and department. These may vary considerably among institutions, and some may be subtle and unrecognized, not always identified in existing orientation materials.
For the new faculty's experience to be successful (for themselves, for their students, and for the institution), we must identify these issues. But we must also make that information available in an effective form: A comprehensive “policies and procedures” manual may be left unread amid the more immediate demands of meeting the first class or starting a research program. Experienced colleagues will have some answers, at least idiosyncratic ones, and likely are willing to share them when they have a free moment; even so, the new instructor may hesitate to call on the same person too often.
The panelists will describe their experiences as new or adjunct faculty or as those orienting such faculty; thereafter, we will solicit experiences from the audience. We expect to generate and disseminate a list of teaching issues new faculty must address and a range of strategies for helping those faculty address them. This could serve as a “Prototype FAQ,” one that institutions (or their new-faculty coordinators) could adapt to local practices.
Intellectual property law basics for computer science instructors (seminar session)
Authors: Kay David G. 
Published: July 2004

Increasingly the practice of computing involves legal issues. Patenting algorithms, domain name poaching, and “re-using” HTML and graphics from web sites all raise questions in the domain of intellectual property law (which includes patents, copyrights, trade secrets, and trademarks). In the classroom, computer science educators often confront questions that have legal ramifications.
To many computer scientists, the legal system seems arbitrary and impenetrable, just as software development is obscure to many lawyers. But each discipline has its own axioms and goals, its own culture and approach to solving problems. Moreover, each discipline has been largely successful in meeting its goals, despite such problems as frivolous, costly lawsuits on one side and unstable, bloated software on the other.
The goal of this seminar is to give computer science faculty a framework for answering students' questions and debunking the most egregious misconceptions about intellectual property issues.
UML-Based integration testing
Authors: Hartmann Jean , Imoberdorf Claudio , Meisinger Michael 
Published: July 2004

Increasing numbers of software developers are using the Unified Modeling Language (UML) and associated visual modeling tools as a basis for the design and implementation of their distributed, component-based applications. At the same time, it is necessary to test these components, especially during unit and integration testing.
At Siemens Corporate Research, we have addressed the issue of testing components by integrating test generation and test execution technology with commercial UML modeling tools such as Rational Rose; the goal being a design-based testing environment.
In order to generate test cases automatically, developers first define the dynamic behavior of their components via UML Statecharts, specify the interactions amongst them and finally annotate them with test requirements. Test cases are then derived from these annotated Statecharts using our test generation engine and executed with the help of our test execution tool. The latter tool was developed specifically for interfacing to components based on COM/DCOM and CORBA middleware.
In this paper, we present our approach to modeling components and their interactions, describe how test cases are derived from these component models and then executed to verify their conformant behavior. We outline the implementation strategy of our TnT environment and use it to evaluate our approach by means of a simple example.