bluuebunny/crossref_metadata_2025_split huggingface dataset:
Get high school students hooked on science with a challenge
Authors: Cohen M. , Foster M. , Kratzer D. , Malone P. , Solem A. 
Published: July 2004

Skilled scientists and engineers along with a public that understands science and technology are vital in today's technically competitive world. The United States must encourage its students to study and excel in scientific academic subjects and consider science and engineering as a possible career.
An academic program that progresses from a statewide to a national competition is a way of developing science and computing knowledge among high school students and teachers, as well as instilling enthusiasm for science. This paper describes the new Mexico High School Supercomputing Challenge, a nonselective academic-year long program that was initiated in 1990. Teams of high school students from throughout New Mexico do a team computational science project using high performance computers.
Automated support for software development with frameworks
Authors: Schappert Albert , Sommerlad Peter , Pree Wolfgang 
Published: July 2004

This document presents some of the results of an industrial research project on automation of software development. The project's objective is to improve productivity and quality of software development. We see software development based on frameworks and libraries of prefabricated components as a step in this direction. An adequate development style consists of two complementary activities: the creation of frameworks and new components for functionality not available and the composition and configuration of existing components.
Just providing adequate frameworks and components does not necessarily yield automation and efficiency of software development. We developed the concept of relations between software components as a foundation for abstraction, reuse and automatic code generation for component interrelationship. Furthermore we suggest to supplement frameworks with an active cookbook consisting of active recipes which guide the software developer in the use of framework elements.
In this paper our concept of using relations among software components is presented and the active cookbook is illustrated as a means for developer guidance. We created a prototype to demonstrate these concepts.
A robot laboratory for teaching artificial intelligence
Authors: Kumar Deepak , Meeden Lisa 
Published: July 2004

There is a growing consensus among computer science faculty that
it is quite difficult to teach the introductory course on
Artificial Intelligence well [4, 6]. In part this is because AI
lacks a unified methodology, overlaps with many other disciplines,
and involves a wide range of skills from very applied to quite
formal. In the funded project described here we have addressed
these problems by
" Offering a unifying theme that draws together the disparate
topics of AI;
" Focusing the course syllabus on the role AI plays in the core
computer science curriculum; and
" Motivating the students to learn by using concrete, hands-on
laboratory exercises.
Our approach is to conceive of topics in AI as robotics tasks.
In the laboratory, students build their own robots and program them
to accomplish the tasks. By constructing a physical entity in
conjunction with the code to control it, students have a unique
opportunity to directly tackle many central issues of computer
science including the interaction between hardware and software,
space complexity in terms of the memory limitations of the robot's
controller, and time complexity in terms of the speed of the
robot's action decisions. More importantly, the robot theme
provides a strong incentive towards learning because students want
to see their inventions succeed.
This robot-centered approach is an extension of the
agent-centered approach adopted by Russell and Norvig in their
recent text book [11]. Taking the agent perspective, the problem of
AI is seen as describing and building agents that receive
perceptions as input and then output appropriate actions based on
them. As a result the study of AI centers around how best to
implement this mapping from perceptions to actions. The robot
perspective takes this approach one step further; rather than
studying software agents in a simulated environment, we embed
physical agents in the real world. This adds a dimension of
complexity as well as excitement to the AI course. The complexity
has to do with additional demands of learning robot building
techniques but can be overcome by the introduction of kits that are
easy to assemble. Additionally, they are lightweight, inexpensive
to maintain, programmable through the standard interfaces provided
on most computers, and yet, offer sufficient extensibility to
create and experiment with a wide range of agent behaviors. At the
same time, using robots also leads the students to an important
conclusion about scalability: the real world is very different from
a simulated world, which has been a long standing criticism of many
well-known AI techniques.
We proposed a plan to develop identical robot building
laboratories at both Bryn Mawr and Swarthmore Colleges that would
allow us to integrate the construction of robots into our
introductory AI courses. Furthermore, we hoped that these
laboratories would encourage our undergraduate students to pursue
honors theses and research projects dealing with the building of
physical agents.
The senior information systems design project seminar
Authors: Sumner Mary 
Published: July 2004

One of the challenges of teaching MIS is preparing students to apply the knowledge they have gained in a real project. Although they have developed proficiency in problem-solving, structured design techniques, and programming during course work, many MIS students have never interviewed a user or been asked to make design changes at a user's request. In addition, many students have never had to work on a project team, manage schedules, and meet project deadlines.
The senior information systems design project course provides students with an opportunity to apply systems concepts and techniques in the design of an information system. Students identify “live” projects and work on project teams. In the past, many of these projects have been programming design and implementation projects provided by local industry. However, in large-scale projects, students could not start with problem definition, proceed to requirements specification, and complete detailed design, because all of this could not be accomplished in a single term. As a result, they would do segments of larger projects.
With the advent of the microcomputer, however, many smaller scale projects became available in offices seeking to automate records management, routine accounting, and other office automation systems. These projects created an opportunity for students to do an entire project, from systems analysis to detailed design.
The purpose of this paper is to describe the objectives and procedures of the information systems design project seminar and to discuss the nature and scope of design projects conducted in university offices during the fall, 1985 quarter. The paper will describe the respective roles of student systems analysts and users, the systems development practices followed, and some of the successes and pitfalls of the experience.
Distribution of software engineering concepts beyond the software engineering course
Authors: Calhoun James 
Published: July 2004

The importance of the role of documentation in the development and maintenance of software is not in dispute among computer professionals. Within the profession, software has come to mean more than just the source or object code which is produced. A modern definition of software includes documents as a vital component. The largest part of such documentation is external to the program and records the history of the project. Included could be project plans, requirements specification, preliminary detailed code design, user-directed manuals and maintenance journals.
All too often the computer science curriculum, whether by design or default, limits student experience with external documentation to specialized courses such as software engineering. While the documentation experience provided by these courses may prove valuable, its quality may be limited by the student's attitude. If the student's previous experience has been limited to internal documentation, there is a good chance that he has come to view documentation as an add-on, something to be completed after the project is really finished. It is difficult to alter this mind-set.
Identification of a solution to this problem may require not only a reevaluation of the documentation requirements for student software projects but an examination of the availability of programming languages and design tools which support the documentation effort. This paper reports the development of several design tools which are intended for student use in the preparation of preliminary project documentation. Special among these is an interactive graphics editor to be used to assist in the design, documentation and implementation of programs.
Transitioning legacy assets to a product line architecture
Authors: Bayer Joachim , Girard Jean-François , Würthner Martin , DeBaud Jean-Marc , Apel Martin 
Published: July 2004

A successful software system evolves over time, but this evolution often occurs in an ad-hoc fashion. One approach to structure system evolution is the concept of software product lines where a core architecture supports a variety of application contexts. However, in practice, the high cost and high risks of redevelopment as well as the substantial investments made to develop the existing systems most often mandate significant leverage of the legacy assets. Yet, there is little guidance in the literature on how to transition legacy assets into a product line set-up.
In this paper, we present RE-PLACE, an approach developed to support the transition of existing software assets towards a product line architecture while taking into account anticipated new system variants. We illustrate this approach with its application in an industrial setting.
Implementing an IT concentration in a CS department
Authors: Countermine Terry , Pfeiffer Phil 
Published: July 2004

The increasing use of commercial off-the-shelf (COTS) software has created a demand for
IT professionals
—people that build and manage systems assembled from COTS components. In Fall 1999, the ETSU Dept. of CIS started a program of study for training IT professionals. This IT concentration differs from existing concentrations in four key ways:

The IT concentration emphasizes VB instead of C++.

It emphasizes web, database, and networking applications instead of systems software;

It puts more emphasis on human issues in computing: ethics, computer-assisted instruction, and systems analysis and specification;

It deemphasizes science and math, giving students more opportunity to complete a minor of their choosing.

Key design criteria for the concentration included making the content practical and attractive; teaching short-term and long-term skills; and minimizing the need for additional faculty. This final concern was addressed by reworking selected courses in computer organization, databases, networking, and software engineering for the concentration.
The new concentration should meet the needs of students and employers while improving retention and increasing enrollment. Preliminary indications suggest that the IT will become the department's most popular concentration.
Recursion in gradual steps (is recursion really that difficult?)
Authors: Velázquez-Iturbide J. Ángel 
Published: July 2004

We propose a gradual approach to teach recursion. Our main assumption is that the difficulty in learning recursion does not come from the recursion concept itself, but from its interaction with other mechanisms of imperative programming. We use this basic idea to propose a new pedagogical approach. On the one hand, recursion is introduced in a gradual way by means of three fields (grammars, functional programming and imperative programming). On the other hand, each instance of recursion is explained so that all of its accompanying mechanisms are clearly identified.The approach has three main advantages. First, the teaching of recursion is simplified because it is taught in a gradual way. Second, the concept of recursion is isolated and differentiated from other concepts or mechanisms associated to particular instances of recursion. Last, the student perceives recursion as a recurrent concept in the discipline of computer science.
The National Science Foundation (seminar session)
Authors: Martin C. Dianne , Reek Margaret 
Published: July 2004

A new program in undergraduate education at the National Science Foundation is the Course, Curriculum and Laboratory Improvement (CCLI) program. CCLI has two tracks that are of particular interest to CS faculty members. They are the Educational Materials Development (EMD) and the Adaptation and Implementation (A&I) tracks. The focus of the EMD track is to develop, test and implement new materials or practices for national dissemination. The focus of the A&I track is to adapt and implement existing innovative materials or practices within a particular institution.
Both of these tracks offer opportunities for funding for CS faculty concerned about improving the quality of CS undergraduate education. Projects can encompass a broad range of activities, from individual courses and laboratories through comprehensive projects that impact entire curricula or programs across multiple departments or institutions. Funding can be requested for all items normally supported by NSF, such as equipment and personnel. The next CCLI program deadline date is June 7, 2000, making the seminar very timely for people interested in developing a proposal.
Analysis is necessary, but far from sufficient (abstract only)
Authors: Pincus Jon 
Published: July 2004

Why are there so few successful "real-world" programming and testing tools based on academic research? This talk focuses on program analysis tools, and proposes a surprisingly simple explanation with interesting ramifications.
For a tool aimed at developers or testers to be successful, people must use it - and must use it to help accomplish their existing tasks, rather than as an end in itself. If the tool does not help them get their job done, or the effort to learn and/or use the tool is too great, users will not perceive enough value; the tool will not get significant usage, even if it is free.
This talk focuses on the often-overlooked consequences of this seemingly basic statement in two major areas: program analysis, and the work beyond core analysis that must be done to make a successful tool. Examples will be drawn from tools that have been successfully used in industry (sold commercially, and developed for internal use).
Integrating active information delivery and reuse repository systems
Authors: Ye Yunwen , Fischer Gerhard , Reeves Brent 
Published: July 2004

Although software reuse can improve both the quality and productivity of software development, it will not do so until software developers stop believing that it is not worth their effort to find a component matching their current problem. In addition, if the developers do not anticipate the existence of a given component, they will not even make an effort to find it in the first place.Even the most sophisticated and powerful reuse repositories will not be effective if developers don't anticipate a certain component exists, or don't deem it worthwhile to seek for it. We argue that this crucial barrier to reuse is overcome by integratingactive information delivery, which presents information without explicit queries from the user, and reuse repository systems. A prototype system,CodeBroker, illustrates this integration and raises several issues related to software reuse.
Accumulative versioning file system Moraine and its application to metrics environment MAME
Authors: Yamamoto Tetsuo , Matsushita Makoto , Inoue Katsuro 
Published: July 2004

It is essential to manage versions of software products created during software development. There are various versioning tools actually used in these days, although most of them require the developers to issue management commands for consistent versioning. In this paper, we present a novel versioning file system Moraine, which accumulatively and automatically collects all files created or modified. Those files are versioned and stored as compressed forms. The older versions are easily retrieved from Moraine by the time-stamps or tags if required.
Using Moraine system, we have developed a metrics (measurement) environment called MAME (Moraine As a Metrics Environment). MAME can collect various metrics data for on-going or past projects, since its basis, Moraine, is able to retrieve all versions of all products (files).
Both Moraine and MAME have been implemented. Using these systems, we have evaluated the performance of Moraine and MAME with various test data and student project data. The result shows that disk space required by this approach is several times larger than ordinary approaches; however, it is acceptable at the current tendency of disk price decrease. By this approach, an ideal metrics environment has been easily established by developing simple data-collection tools for version files.
Implementing product line variabilities
Authors: Gacek Critina , Anastasopoules Michalis 
Published: July 2004

Software product lines have numerous members. Thus, a product line infrastructure must cover various systems. This is the significant difference to usual software systems and the reason for additional requirements on the various assets present during software product line engineering. It is imperative that they support the description of the product line as a whole, as well as its instantiation for the derivation of individual products.
Literature has already addressed how to create and instantiate generic product line assets, such as domain models and architectures to generate instance specific ones [1, 2, 3], yet little attention has been given on how to actually deal with this genericity at the code level.
This paper addresses the issue of handling product line variability at the code level. To this end various implementation approaches are examined with respect to their use in a product line context.
On guiding the business school toward computer literacy
Authors: Costello Donald F. , Schonberger Richard J. 
Published: July 2004

In colleges and unversities around the country it is common to find that needs for new courses in computing are recognized long before suitable courses are made available. This is especially true for colleges of business administration. The needs have long been obvious, but staffing such courses internally is a slow process. Some colleges of business are well served by computer science departments, but in other schools the catalyst for getting started is lacking. This paper addresses the problem by describing the development of a service course in computing offered by the Department of Computer Science for the College of Business Administration at the University of Nebraska. The approach taken to course development postulated that if a course is to appeal to a college of business administration, it must appeal to the special needs and aptitudes of the typical business student. This particular service course concentrated on special behavioral objectives: need to develop man-machine interface skills, attention to developing self-confidence and a sense of accomplishment, and understanding the information processing concepts needed in business today. The pedagogical approach to attainment of these objectives also was carefully fashioned for the given audience.
As originally conceived, the cognitive objectives of the course aimed at teaching the analytically oriented business college under-graduate how to write programs in the FORTRAN language. In addition, the student was expected to be able to read application programs in the areas of marketing, accounting, finance, operations and personnel management. The course explained how these latter applications packages aid in the management decision process. Finally, the course required that the student become more familar with the general expository material in the area of electronic data processing.
Foundations of computer science for entry-level graduate students
Authors: Weiner Leonard H. 
Published: July 2004

In recent years, as colleges and universities have established new interdisciplinary programs, students have tended increasingly to combine (or switch) academic fields as they pass from one degree level to the next. This has brought about a situation in which many students try to enter new academic areas at the graduate level without having the prerequisite undergraduate course background. And so for some time now, academicians have sought to develop programs and courses that will help those students make up their deficiencies and prepare them for more advanced work, rather than lower the standards of the basic courses.
The course described in this paper was designed to cover approximately two and a half years of undergraduate computer science material in a six-credit, two-semester sequence. It is directed at graduate students from a variety of academic areas and does not require more than the usual resources for a programming course. Therefore, it should be of interest to institutions faced with limited budgets at a time when they are trying to build quality computer science graduate programs.
Accreditation in the computing sciences (Panel Session)
Authors: Cain Tom , Davida George , Engel Gerald L. , Frederick Terry J. , Gibbs Norman E. , Dalphin John F. , Mulder Michael C. 
Published: July 2004

A joint task force of the ACM and the IEEE Computer Society is meeting regularly to discuss issues relating to accreditation or approval in the computing sciences. In addition to considering various mechanisms to implement the important qualitative review and certification, the Joint Committee is developing a preliminary set of Computer Science Program requirements.
Increasing requests are being made to the professional societies to provide guidance in computer science programs. While certain guidance and evaluation mechanisms exists, and agencies to administer them, these tend to be directed to specialized programs and the field is so broad that a wider view must be taken. It is estimated that as many as 500 programs not presently served by existing mechanisms and agencies would benefit from such guidance.
This panel will discuss some of the issues relating to implementation of accreditation/approval as well as quantitative criteria for computer science programs that provide competency in the profession. Audience participation and discussion will be encouraged.
An upper level computer science curriculum
Authors: Chua Y. S. , Winton C. N. 
Published: July 2004

In response to national curricular trends, the computer science curriculum at the University of North Florida has undergone three iterations since its inception in 1972. Experiences with the development of the North Florida curriculum coupled with recent exposure to the current thinking of the IEEE-CS Curriculum Committee motivate this paper.
The curriculum as outlined in this paper owes its origins to the earlier ACM and IEEE-CS model curricula.