bluuebunny/crossref_metadata_2025_split huggingface dataset:
HyperWeb
Authors: Ferrans James C. , Hurst David W. , Sennett Michael A. , Covnot Burton M. , Ji Wenguang , Kajka Peter , Ouyang Wei 
Published: July 2004

Software productivity and quality will increase as we improve our model of software and develop tools to support that model. Development environments must take into account that software is more than source; that it is more than text; and that it forms a highly interconnected web of information. Because more time is spent understanding and maintaining software than creating it, environments should strongly support browsing and reading. Finally, environments must be easy to customize.
In this paper we present HyperWeb, a framework that supports the construction of hypermedia-based software development environments having this richer view of software. It coordinates the activities of an integrated set of tools through a message server, uses an object-oriented database to store software artifacts, and supports hypermedia linking of these software artifacts. It is built around an interpreter for a general purpose scripting language, allowing for very flexible customization and environment building. We also describe our experience in using it to build an environment that supports software design, development and maintenance on Unix. Its primary features include support for document linking, source code annotation and restructuring, and modification request tracking. It is being used and evaluated internally and at several external sites.
obTIOS
Authors: Quester Remco 
Published: July 2004

An open integrated CAx-framework supplies services to build derived CAx-environments (e.g. for concurrent Engineering (CE), VLSI-design, Software Engineering, etc.) with specialized, integrated in-house or foreign tools. Such integrated tool uses services of the CAx-framework and cooperates with other integrated tools to achieve a common engineering objective like the simulation of a VLSI-circuit. In most CAx-frameworks the integrated tools cooperate indirectly using CAx-framework services like Data Handling or Inter-Tool Communication (ITC).
With obTIOS a high-level approach to control cooperation of integrated tools within a Computer Aided Concurrent Engineering (CACE) environment is introduced. The tools of a CACE-environment are grouped to domains which represent the most coarse, mutually independent, structural unit within the CACE-environment. The way in which the tools of a domain cooperate is described by Encapsulated Composed Activities (ECA). An ECA represents a template of control regarding cooperation-in-the-large and cooperation-in-the-small of tools.
Consistency in software system development
Authors: Hangensen Torben Mejlvang , Kristensen Bent Bruun 
Published: July 2004

An important aspect in the software development process is the consistency between various parts of the software system being designed and implemented. During the development of a system we are aware of the consistency problems and we usually solve these by special arrangements developed as part of the development of the software system. In general the solutions applied for some specific system cannot be reused for other systems.
The purpose of this paper is to introduce a general understanding of consistency and the techniques and tools for handling consistency. We introduce a concept called description to denote the various pieces of information which must be consistent. The description covers any fragments software and data, e.g. such as source code, parse trees, and machine code. The interpretation of a description is defined as a mapping into the set of objects, that the description is supposed to describe. Consistency of descriptions is defined as relations between the interpretations of the descriptions. The concepts description, interpretation and relation are used as a framework for modeling consistency in software systems. A consistency model includes interfaces, control parts and representions for descriptions in a system, and a specification of the consistency relations, that are relevant for the system.
The model provides consistency as a new and very important perspective on software systems. It provides a graphical notation, which gives an overview of the consistency relations in a software system being designed. The model is very general and it does therefore apply to any type of software systems. This restricts the level of detail in the model of consistency, but the model allows enhancement of the specification once the type of software system is given.
We define four basic techniques for handling consistency in software systems modeled in terms of descriptions. By combining these techniques we are able to describe the handling of consistency in a given software system. These techniques and the graphical consistency modeling language form a first step towards an engineered approach to the construction of software systems from a consistency view.
A transformational approach to generating application-specific environments
Authors: Garlan David , Cai Linxi , Nord Robert L. 
Published: July 2004

Current software development environments tend to lie at opposite ends of a spectrum: at one extreme are specialized application generators; at the other are general-purpose programming environments. The former provide strong support for system development and reuse, but are costly to build and available only for limited domains. The latter provide weak support, but are generally available and universally applicable.
We describe a technique for automating the production of application-specific environments that lie between these two extremes. The key idea is that these environments can be derived from general-purpose programming environments by a process of structured transformation. We describe a tool for performing these transformations. It provides a set of formal operators for specializing a description of a general-purpose environment; as operators are applied, the system semi-automatically builds a set of transformation rules used to translate application-specific programs into those of the original general-purpose environment. The output of the tool is an application-specific environment together with a program transformer that provides execution semantics for programs written in that environment.
The composability of ASTRAL realtime specifications
Authors: Coen-Porisini Alberto , Kemmerer Richard A. 
Published: July 2004

ASTRAL is a formal specification language for realtime systems. It is intended to support formal software development, and therefore has been formally defined. In ASTRAL a realtime system is modeled by a collection of state machine specifications and a single global specification.
This paper focuses on extending the ASTRAL methodology to allow the composition of ASTRAL system specifications into specifications of larger and more complex systems.
The ASTRAL language includes structuring mechanisms that allow one to build modularized specifications of complex systems with layering. In this paper we concentrate on how to combine these complex system specifications into specifications of even more complex realtime systems. This is accomplished by adding a COMPOSE section to the language that provides the needed information to combine two or more ASTRAL specifications into a single new one.
In this paper we also introduce the necessary proof obligations to assure that the assumptions of each of the components of the larger system are satisfied by the other components of the system that replace the previous external environment. We also discuss how some exported transitions become internal transitions of the new system. A telephony example with local central controls that interface to long distance units is used to motivate the extensions.
Integrating “depth first” and “breadth first” models of computing curricula
Authors: Shackelford Russell L. , LeBlanc Richard J. 
Published: July 2004

Traditional undergraduate Computer Science curricula have been increasingly challenged on a host of grounds: undergraduate computing education is attracting fewer majors, is not producing graduates who satisfy the needs of either graduate programs or business and industry, and is not effectively responding to the increasing needs for computing education among the larger student population. In the face of such challenges, there has been a recent movement to restructure undergraduate computing curricula.
At Georgia Tech we have design (AY 91-92) and implemented (AY92-93) a new computing curriculum that features a radical restructuring of subject matter. During the design and implementation process, we paid close and critical attention to the particulars of both the ACM recommendations and reports from our colleagues at other institutions who had already gained some experience with “Breadth First” approaches. We have conclude that curriculum modernization should integrate key aspects of both “Depth First” and “Breadth First” approaches. Our new curriculum is an example of such integration. We present data (measures of student performance and of student and faculty opinion) that confirm that our approach is viable, and we now believe that it can be a useful model for others. In this paper, we outline the structure of our integrated curriculum and report on key facets of our experience with it.
Two years of “The Digital World”
Authors: Fagin Barry 
Published: July 2004

We report here our cumulative 2-year experience with the “The Digtal World”, a course designed to increase the technological literacy of non-science students. The course relies heavily on computer-aided instruction, including the extensive use of electronic lectures and multimedia. Students were able to acquire a surprising level of sophistication by working with examples of digital technology chosen from their daily lives. Students were also able to identify weaknesses in areas of current technology and public policy similar to those identified by experts.
We describe our successes and failures, and present cumulative data on performance, by major, class, and gender. All courseware and applications for “The Digital World” are available from the author.
Accreditation
Authors: Rozanski Evelyn P. 
Published: July 2004

Accreditation, considered to be the one formal mechanism for assessing quality in the postsecondary environment, focuses on determining and encouraging acceptable levels of educational quality. In particular, specialized program accreditation is purported to enhance program quality.
This exploratory study used a nationwide mail questionnaire to a stratified random sampling of 100 department heads of the units administering baccalaureate Computer Science programs. The purpose was to gain an understanding of how Computer Science programs and departments were related to selected indicators of faculty and program quality.
Several differences and some similarities exist between the accredited and non-accredited groups. The median of the data for each indicator suggested a quality breakpoint to be used in defining two indices. It was found that for each of the two indices, the accredited group outperformed the non-accredited group by thirty percent. The implication is that Computer Science programs that follow accreditation guidelines have the potential for increasing their quality indicators.
Peer learning in an introductory computer science course
Authors: Wills Craig E. , Finkel David , Gennert Michael A. , Ward Matthew O. 
Published: July 2004

A problem in teaching large introductory computer science courses is to overcome the impersonality of the large lecture class and to provide more personal attention to individual students. Our approach is to use peer learning experiences to instill in students the need to take responsibility for their learning and for the learning of those around them. Recent work has shown that educational quality for students and productivity for faculty can be enhanced through use of peer-learning environments where students do not just learn and faculty do not just teach.
The novel aspects of our work are to apply group learning in a large introductory computer science class setting and to expect more responsibility on the part of students for their learning. In support of these goals we have introduced the use of upper-level undergraduate students to help facilitate student group interaction. In addition, we have developed software to minimize the administrative overhead of handling many groups and for students to electronically record group learning activities.
Using graphical presentation techniques in closed laboratory exercises (abstract)
Authors: Proulx Viera , Fell Harriet , Rasala Richard , Koomen Johannes A. G. M. , Wilson Carol W. 
Published: July 2004

The panelists will share their experiences in developing closed laboratory exercises for lower level CS courses with particular emphasis on using graphical presentation techniques as a pedological and motivational tool. The use of interactive animations and visualization is combined with structured support for the student programmer to provide an apprentice style learning environment.
Three major threads form the backbone of this curriculum. The first is the use of interactive animations and experimentation programs to introduce and illustrate dynamic processes—e.g. algorithm behavior, or changes in data structures over a period of time. The second thread is the use of graphics in student programs, not only as motivation, but also as a visual feedback and debugging tool. The third thread trying all together is the extensive use of model programs, shell drivers, toolkits, and procedures that encapsulate abstractions. These programming tools support the apprentice style of learning and illustrate good software design and practice throughout the curriculum.
Removing implementation details from C++ class declarations
Authors: Headington Mark R. 
Published: July 2004

Data abstraction—a concept introduced at varying places in the CS1/CS2/CS7 sequence—separates the properties of a data type (its values and operations) from the implementation of that type. This separation of specification from implementation is achieved by encapsulating the implementation so that users of the type can neither access nor be influenced by the implementation details. Ideally, therefore, the specification should be implementation-independent.
The C++ class mechanism compromises information hiding by requiring the interface to include information—the private part of the class declaration—that is needed only for implementation purposes. This paper describes two techniques for removing details of implementation structure from the C++ class declaration and discusses the advantages and disadvantages of each.
Using an internal internship to enhance computer science education in a two-year college
Authors: Cohen Norman , Dann Wanda 
Published: July 2004

A student internship in a suitable business or organization can augment, reinforce, and embellish material learned in the classroom. Computer Science student interns can experience such things as real-world development environments, projects which greatly exceed the scale of typical programming assignments, the utter importance of (possibly lacking) documentation, as well as diverse languages, operating systems, and hardware. Opportunities for such internships occur rarely, however, for many rural two-year colleges, especially those geographically isolated from companies which could provide this experience.
Despite such a situation at our college, we still provide students with an internship experience by creating an internal organization: the Software Development Internship (SDI) with the mission to develop custom software for other departments on campus. In this paper we describe the formation of the SDI, its activities, and some of the benefits and lessons learned to date.
Parallel threads
Authors: Harlan Robert M. , Akulis Joseph G. 
Published: July 2004

One objective in establishing our NSF ILI funded parallel computation laboratory was to use closed, formal laboratory assignments to introduce parallelism throughout the core computer science curriculum. We discuss laboratory assignments developed for the Computer Organization (CS 3) and Algorithms (CS 4) courses.
The CS 3 lab introduces parallelism based upon processor replication and two-performance indices for evaluating performance of parallel algorithms, speedup and efficiency. One factor that effects performance on MIMD message passage architectures, the ratio of computation to communication, is also introduced.
The CS 4 lab guides students in developing a parallel version of Dijkstra's single source shortest path algorithm. A case study using parallel addition assists students in identifying potential parallelism by examining the data dependency of computations. Students working in teams of two develop a pseudo-code version of the single source shortest path algorithm for an abstract parallel machine. They also analyze the speedup and efficiency of an implementation of the algorithm for one, four and eight processors.
A reuse approach based on object orientation
Authors: Ghezala Henda Hadjami Ben , Kamoun Farouk 
Published: July 2004

The aim of this paper is to present an approach to facilitate reuse. This approach, which is based on an object oriented design method, describes a way of structuring components and reuse library.
Two concepts, domain and theme, are introduced to allow a classification of components by the services that they offer and by application domain. The library itself is organized in three hierarchical levels -general, dedicated and personal-, where the reusable components are stored according to their degree of “interest” (general interest, by application type or particular). So, the library is generic and could cluster various reusable component types (specification components, design components, packages,…).
The contributions of this approach in the development of CASE tools are also emphasized.
An integrated approach to software reuse practice
Authors: Mambella E. , Ferrari R. , Carli F. D. , Surdo A. L. 
Published: July 2004

Since 1993, Sodalia's Software Engineers have been studying a reuse program whose goal is making software reuse a significant and systematic part of the software process. The Sodalia's Corporate Reuse Program is intended to develop a Software Reuse Process that incorporates reuse-specific activities along the Object-Oriented Software Development Process, and a reuse library to support the classification and management of reusable components.
This paper focuses on the on-going experience of Sodalia in the gradual introduction of reuse practice in the organization, illustrates the evolutionary stages, and the reached results.
Concurrent programming in Modula-2
Authors: Brumfield Jeffrey 
Published: July 2004

This paper describes a concurrent process manager that has been developed for the Modula-2 programming language. Using this software, students can gain practical experience in designing and implementing concurrent programs using processes, semaphores, and message links. The use of abstraction in describing the process manager is advocated, and a variety of concurrent programming exercises are presented.
This paper describes a concurrent process manager that has been developed for the Modula-2 programming language. Using this software, students can gain practical experience in designing and implementing concurrent programs using processes, semaphores, and message links. The use of abstraction in describing the process manager is advocated, and a variety of concurrent programming exercises are presented.
A course on “expert systems” for electrical engineering students
Authors: Witten Ian H. 
Published: July 2004

A final-year undergraduate course on Expert Systems, designed for Electrical Engineering students, is described. To cater for this audience the course has a highly practical nature, despite the students' lack of relevant prerequisites in Computer Science. This is achieved by emphasizing logic programming throughout to illustrate all concepts taught; weekly, scheduled laboratory sessions; and a carefully-graded series of assignments.
We have demonstrated that bright engineering students can get to grips with practical issues in applied artificial intelligence through a short, intensive, course — starting from ground level. PROLOG was found invaluable as a pedagogical tool, as was the highly-structured engineering-style laboratory. Informal feedback indicates that the course has achieved its objectives and indeed exceeded expectations.
Visual simulations of data structures during lecture
Authors: Barnes G. Michael , Kind Gary A. 
Published: July 2004

A microcomputer based software package for the graphic simulation of fundamental binary search tree algorithms is presented. This application was developed to augment instructional aids available to the instructor during classroom lecture. The system is mouse controlled and was designed to be used on an IBM PC compatible microcomputer connected to either a large screen video monitor or a projection display. Several screen dumps are presented to illustrate the multi-level graphical representation of trees, pseudocode algorithms, and window environment incorporated in the package. In addition, the literature on CAI oriented simulations for Computer Science topics, with a focus on data structures, is reviewed briefly.
Computer Aided Instruction (CAI) is an educational application area with tremendous potential. The recent advent of reasonably priced personal computers with medium resolution color graphic capabilities will hopefully increase the generation of CAI materials in all fields. Ironically, there has been little CAI material developed to aid in the instruction of Computer Science. Furthermore, earlier efforts at courseware development for computer science was centered on programming languages not more advanced topics. In recent years, however, several researchers have been developing personal computer based courseware simulations of more advanced topics: program execution [2,6,21,16], computer architecture [15,17], and data structures algorithms.
This work is part of a growing body of research being performed in the emerging area of Visual Programming [11,10]. In this paper we will first briefly review the area of graphic simulations of fundamental data structures and their algorithms. Second, we will describe the CABTO (Computer Animation of Binary Tree Operations) package. We developed CABTO to be used as a lecture aid in a lower division data structures course.
Defining ethical and unethical student behaviors using departmental regulations and sanctions
Authors: Cook Janet M. 
Published: July 2004

College students do not automatically possess basic standards of acceptable and unacceptable behavior with regard to computer hardware, software, and data sets. For their sake and our own we need to spell out what is expected of them.
Universities like mine have stated that students cannot be penalized or dismissed for theft or for damage to equipment/software/records unless they have received a copy of a written policy describing proscribed activities and their penalties.
This paper includes two sample policies. One considers only the use of software in microcomputer laboratories. The other covers mainframe, minicomputer and microcomputer facilities, use of resources in a chargeback system, penalties for plagiarism and illegal copying of software, and individual responsibilities with regard to group projects.