bluuebunny/crossref_metadata_2025 huggingface dataset:
Pgraphite: an experiment in persistent typed object management
Authors: Wileden Jack C. , Wolf Alexander L. , Fisher Charles D. , Tarr Peri L.
Published: July 2004

Defining, creating, and manipulating
persistent typed objects
will be central activities in future software environments. PGRAPHITE is a working prototype through which we are exploring the requirements for the persistent object capability of an object management system in the Arcadia software environment.

PGRAPHITE represents both a set of abstractions that define a model for dealing with persistent objects in an environment and a set of implementation strategies for realizing that model. PGRAPHITE currently provides a type definition mechanism for one important class of types, namely directed graphs, and the automatic generation of Ada implementations for the defined types, including their persistence capabilities.

We present PGRAPHITE, describe and motivate its model of persistence, outline the implementation strategies that it embodies, and discuss some of our experience with the current version of the system.
User interface support for the integration of software tools: an iconic model of interaction
Authors: Beaudouin-Lafon Michel
Published: July 2004

This paper presents a model of interaction based on an iconic representation of objects. An application of the model to an iconic shell for Unix™ is described. Finally a client server architecture for the implementation of the model is introduced. We show that a software development environment can take advantage of such a model and architecture in order to provide a consistent, adaptable and extensible user interface.
A graph transform model for configuration management environments
Authors: Heimbigner Dennis , Krane Steven
Published: July 2004

A model for software configuration management that subsumes several existing systems is described. It is patterned after compiler models in which programs are transformed by multiple phases ending in an executable program. We model configuration management as transforming a high-level specification of a software product to be produced into a complete specification capable of being executed to construct the product. This transformational approach is used to model four existing systems and to compare and contrast their operation.
An overview of PCTE and PCTE+
Authors: Boudier Gerard , Gallo Ferdinando , Minot Regis , Thomas Ian
Published: July 2004

The PCTE project has defined a Public Tool Interface on which Software Engineering Environments can be constructed. The interface definition was put into the public domain in September 1986 and several implementations on several machines now exist. The PCTE+ project was set up to define a Public Tool Interface, based on the PCTE work, that could also serve for the development of defense and other high-security applications. This paper summarises the current status of PCTE activity, presents the principal concepts of PCTE and the evolutions that are being proposed in the PCTE+ project.
Programming as process: a “novel” approach to teaching programming
Authors: Gantenbein Rex E.
Published: July 2004

This paper introduces the process model as a way of incorporating the software life cycle into beginning computer science courses. This approach, patterned after a successful method for teaching English composition, provides students with an understanding of how all phases of programming can be accomplished. A five-step model of the process and some useful tools for each step are presented as an example and discussed.
Sizing assignments: a contribution from software engineering to computer science education
Authors: Haas David F. , Waguespack Leslie J.
Published: July 2004

A method of predicting the sizes of programs from a measure of problem size is shown, and research testing the effectiveness of the method is reported. A regression model for predicting average program size as measured by mean_LOC is shown to perform well for a sample of Pascal assignments of moderate size written by students in programming classes.
An Ada-based software engineering course
Authors: Owen G. Scott
Published: July 2004

Currently, many Computer Science Departments have introduced or are considering the introduction of courses in software Engineering. At the same time many departments are considering the use of a language other than Pascal either for an entire Computer Science curriculum, or at least for some advanced courses, such as Data Structures or Software Engineering. At Georgia State University, where our program is primarily based on IBM PC compatible microcomputers, both our Data Structures and Software Engineering courses are based on Ada. In this paper we will discuss the rationale behind our choice of Ada and our experience with using Ada in the Software Engineering course.
Implementing a GKS-like graphics package on a microcomputer
Authors: Mahoney Michael K.
Published: July 2004

A variable-length project for an introductory upper-division computer graphics course for majors is described. The project consists of the implementation of a graphics package based on the Graphical Kernel System (GKS, an ISO and ANSI standard) and application programs which demonstrate features of GKS. Any microcomputer with graphics capabilities equipped with an appropriate compiler can be used for the project. It is assumed that the reader is familiar with the basic concepts of 2D computer graphics. A brief introduction to GKS is included.
Algorithms and software: integrating theory and practice in the undergraduate computer science curriculum
Authors: Wilson Judith , Greenleaf Newcomb , Trenary Robert
Published: July 2004

A theoretical trend in the development of undergraduate computer science curricula is described. While this curriculum trend can be seen as a natural evolution of a discipline, there are other reasons for it. An opposite trend can be observed that seeks to integrate theory and practice in the undergraduate curriculum. We offer general guidelines based on this second curriculum philosophy.
Low-cost networks and gateways for teaching data communications
Authors: Hughes Larry
Published: July 2004

The growing importance of communications in computer science has resulted in many undergraduate computer science programmes offering courses in data communications. Although data communications courses can be taught in a practical manner, the cost of data communications hardware often restricts the amount of actual hands-on experience that students can gain.

In this paper we describe the hardware and software requirements of several low-cost networks that can be used by students to gain experience in a wide variety of data communication topics including local area networks (such as bus networks and ring networks), wide area networks (i.e. store-and-forward networks), and gateways.
Using generics modules to enhance the CS2 course
Authors: Kumar Ashok , Beidler John
Published: July 2004

We normally expect features in a programming language to support the concepts and methodologies in the course. This article describes another role for features within a programming language, support of sound educational methodology. Specifically, this paper describes how the library module capability in Modula-2 may be used to formally separate the concept from the implementation of abstract data types. That is, by having generic support for various structures, the structures can be taught at a conceptual level and students are given assignments to use these structures long before the implementations of the structures are taught. The result is a clear separation of concept and implementation and a better understanding of the structures as ADTs.
An IS1 workbench for ACM information system curriculum '81
Authors: Waguespack Leslie J.
Published: July 2004

This paper describes the System Architects' Workbench, a personal computer-based teaching environment for courses in computer organization and systems programming. This tool set provides an integrated learning and teaching environment for computer systems concepts defined in ACM IS Curriculum '81 IS1. The central tool is a computer simulator based on a pedagogical model of computer system resources which allows students to study principles without becoming too involved in the implementation idiosyncrasies usually associated with machine level programming. Programs may be written directly in machine language or in a Pascal-like language, TP, which includes features that allow complete access to and control of host level resources. The TP compiler supports separate compilation, IPL load module generation, and detailed translation output used for machine language modification and debugging. The simulator supports interactive execution, tracing, modification, and debugging.
APEX1, a library of dynamic programming examples
Authors: Britt Michael
Published: July 2004

This paper surveys the growing field of
program visualization
or
visual programming,
the ability to visualize the execution of a computer program or the effects of a computer program on its data structures on a display device. Additionally, a library of dynamic Pascal examples, APEX1, designed for use in a second Pascal (data structures) course is introduced. Finally, the characteristics that an optimal
program visualization
system should possess are discussed.
A unified approach for multilevel database security based on inference engines
Authors: Null Linda M. , Wong Johnny
Published: July 2004

A multilevel relational database system handles data at different security classifications and provides access to users with different security clearances. Many methods for enforcing security in this environment have been investigated. This paper presents a unified approach to multilevel database security based on two ideas: a trusted filter and an inference engine. These two approaches are introduced separately and then the motivation for the unified system and the system model itself are presented.
Computer aided program design experiments: diagrammatic versus textual material
Authors: Ackermann Ernest C. , Pope William R.
Published: July 2004

An experiment was conducted to determine if using a computer aided diagrammatic approach to design offered advantages to undergraduate students in the several stages of preparing and implementing programs. Results were obtained which favored the use of a computer aided diagrammatic tool. The greatest benefit was realized in the later stages of coding and implementation rather than in the design stage itself. Overall, the diagrammatic classes completed assignments in 27% less time than the classes using a textual approach without any measurable loss of quality. The research was a joint effort of the Naval Surface Warfare Center and Mary Washington College.
CASE and the undergraduate curriculum
Authors: Sidbury James R. , Plishka Richard , Beidler John
Published: July 2004

In 1987 the Dept. of Computer Science at the University of Scranton received an NSF CSIP grant to develop a Software Engineering Laboratory. A decision was made to supplement that laboratory with computer assisted software engineering (CASE) tools. This paper describes the on going integration of CASE tools into the computing curricula at the University of Scranton.
A core course in computer theory: design and implementation issues
Authors: Bagert D. J.
Published: July 2004

This paper describes the design and implementation of a junior-level course in formal languages and automata theory which satisfies CSAB guidelines for the computer science core curriculum in the area of theoretical foundations of computer science. The optimal prerequisites for such a course, as well as its impact on advanced computer science courses, are discussed. Several suggestions on how to present the subject matter in such a formal languages course, which has traditionally been considered too difficult to be taught below the senior level, are also discussed.
Examining compiled code
Authors: Smotherman M.
Published: July 2004

The use of annotated listings of compiler-generated code has the potential to make teaching more effective in several different courses. We consider the production of such listings for several popular compilers and computer systems, including Turbo Pascal on MS-DOS machines and Pascal on Ultrix and VMS systems. The usefulness of these listings in assembly language, computer organization/architecture, and compiler courses, as well as introductory courses, is also considered.
Teaching practical software maintenance skills in a software engineering course
Authors: Collofello J. S.
Published: July 2004

The typical one-semester software engineering course is normally geared towards new software development. Unfortunately, most new computer science graduates do not find themselves in a position where they are developing new software but instead in a position where they are maintaining an existing product. This paper describes some current practical software maintenance approaches which can be taught as a part of a software engineering course.
Removing the emphasis on coding in a course on software engineering
Authors: Rising L.
Published: July 2004

There has been considerable interest in a one-semester course in software engineering [Bullard88, Carver87, Gibbs87]. Faculty members of departments of computer science are introducing courses that involve team projects, in an effort to provide students some experience with large programs. However, software professionals are still concerned that most computer science graduates have little understanding of what is involved in the development of large, complex systems. Too often, code alone is regarded as the primary product without proper consideration of the necessary standards and procedures of the controlling disciplines. This paper describes a course that shifted the emphasis from coding by having students perform supporting activities and maintenance on a large Ada project.
Inservice education of high school computer science teachers
Authors: Kiper J. , Rouse B. , Troy D.
Published: July 2004

This paper describes an inservice retraining program for high school computer science teachers Since computer science teacher certification is a recent development, most of these teachers were trained in another field. This project consisted of a sequence of courses which taught the core principles of computer science to these teachers.
Laying the foundations for computer science
Authors: Larsen L. A.
Published: July 2004

This paper has three primary goals:

Stimulate the discussion of possible skills which might be incorporated into the K-12 curriculum in order to provide students with a foundation for the study of computer science.

Stimulate the discussion of strategies for incorporating into the K-12 curriculum the fundamental skills needed by students pursuing topics in the computer science discipline.

Present a possible set of fundamental skills.
Ada in CS1
Authors: Winslow L. E. , Lang J. E.
Published: July 2004

As the use of Ada in commercial programming increases, it becomes more important to make an attempt to introduce it into the curriculum as early as possible. We have taught CS1 successfully using Ada by strictly concentrating on a subset of the language and through the use of a student-oriented package which enables students to begin writing programs in Ada after one lecture. A laboratory of personal computers was found to be adequate for CS1 use and students were able to write up to 2 programs per week in the course.
Teaching multiple programming paradigms: a proposal for a paradigm general pseudocode
Authors: Wells M. B. , Kurtz B. L.
Published: July 2004

Initial overexposure to the imperative programming paradigm can make it very difficult to introduce students to other paradigms, such as the functional, object oriented and logical paradigms. It is important that students be exposed to several programming paradigms early. Two techniques commonly used to accomplish this are a “survey of languages” approach and use of a language, such as Scheme, that overlaps several paradigms. We propose the use of a paradigm-general pseudocode that can then be translated into the most appropriate target language. This paper describes in detail the features and form of this pseudocode using familiar algorithms. This approach has been used successfully in an upper division class and we believe it can be refined and introduced earlier in the curriculum.
Software development: advice by analogy
Authors: Salenieks P.
Published: July 2004

This paper draws an analogy between software development and mountaineering, suggesting how exponents of the former can learn from the experiences of the latter. The advice given is illustrated by triumphs and tragedies described in the mountaineering and computing literature.
Enlarging the scope of SQA
Authors: Loy P. H.
Published: July 2004

The concept of software quality assurance (SQA) is rapidly evolving, and reflects a growing awareness of the critical importance of this field. However, our view of what SQA is all about needs to focus more on the interrelated aspects of
integration
and
scope
. In terms of integration, SQA must become an integral part of every task in the development process, rather than being a parallel function embodied in a separate organizational department. With respect to scope, SQA must encompass areas that are often seen as marginal to software quality. In particular, the areas of business policy, metrics, peopleware, technology transfer, and technical leadership must be addressed.
A computer graphics course
Authors: Sewry D. A.
Published: July 2004

A computer graphics course is presented that was introduced at the honours level at Rhodes University in 1988. In the past, a course in graphics has not been included in either the undergraduate or post-graduate curriculum. However, with the increased emphasis on the "visual" aspects of computing (full-screen editors combining text and images, windowing, graphical languages, CAD), it was thought appropriate to enhance the honours curriculum. This paper discusses the course structure, possible texts, supporting hardware and experience gained.
CC-modula: a modula-2 tool to teach concurrent programming
Authors: Morales-Fernandez R. , Moreno-Navarro J. J.
Published: July 2004

The present work shows an educational experience at University level in the field of concurrent programming. CC-Modula, a tool to teach concurrent programming using a single language, is presented. It could also be considered as a contribution to the development of methods to implement concurrent mechanisms, in the frame of centralized and distributed operating systems.CC-Modula is a Modula-2 package that allows the use of the best known abstract mechanisms of concurrency. CC-Modula handles parallelism between processes and contains mechanisms to synchronize them. Mechanisms based on shared storage as well as mechanisms based on message passing that implement the CSP schema are included.
Logo as a prelude to LISP: some surprising results
Authors: Louden K.
Published: July 2004

Recently San Jose State University introduced a LOGO-based, rather than a Pascal-based, first course in computer science. This paper reports on an attempt to trace statistically the effect of that curricular change on student performance in a subsequent Lisp course. Student final grades, however, showed no improvement in performance as a result of their prior exposure to functional programming with LOGO.
An alternative to regular lecture classes: a theory seminar in computer algorithms
Authors: Bozonie Michael
Published: July 2004

Not every student has the same experience base. Putting all students into the same class setting without regard to experiences can be catastrophic for experienced students, inexperienced students and instructors. A course approach, called a
theory seminar
, combines the strengths of regular classes, independent studies, and evaluations of prior experiences. A theory seminar has been developed for a computer algorithms course.
Using modula-2 to teach data abstraction
Authors: Mohr J.
Published: July 2004

The principle of abstraction has assumed a central role in modern software engineering. Most modern textbooks on data structures and algorithms propound the advantages of abstraction as a programming tool. Aho, Hopcroft, and Ullman cite generalization and encapsulation as the two primary advantages of both data and procedural abstraction.Allen Tucker echoes these advantages, defining abstraction as "a conscious process of generalizing a type, procedure, or data structure in such a way that it can serve more purposes than the one for which it was originally designed," and encouraging the packaging of procedures in libraries "to promote their wide utility through generalization."Michael Feldman focuses on the use of abstraction to reduce complexity through information hiding. Encapsulating the details of a representation allows us to "concentrate on the mathematical properties of these entities, their visible structure, and the set of operations that can be performed on them."Robert Kruse shows how distinguishing between a general concept and a particular implementation can clarify code, which often allows us to recognize similiarities between situations which were presumed to be different. He also clearly outlines the various levels at which we solve problems: the abstract (conceptual), data structures (algorithmic), implementation and application (programming) levels.Unfortunately, many students have trouble grasping the concept of abstraction. They see Kruse's hierarchical approach to problem solving as a complication rather than a tool, and have difficulty distinguishing one level from another. (Perhaps this problem is unique to the students I have encountered . . . but I doubt it.)Part of the problem in teaching abstraction is that Pascal, C, and most of the other languages which are widely used in data structures courses do not enforce the use of abstraction. Writing a high-level procedure which uses a lower-level one to do its work seems to be merely a stylistic issue ("The prof wants us to write it this way.") The power of hierarchical structure for controlling complexity is easily overlooked when it just seems to make one's program longer.Modula-2 is one of the more recent languages which support data abstraction by separating the definition of an abstract data type (ADT) from its implementation in separately compiled modules. We have used Modula-2 in our data structures and algorithms class for the past two years, and are converting our introductory programming courses (CS1 and CS2) to Modula-2 beginning this fall. We are convinced that the use of Modula-2 helps students understand data abstraction by experiencing it in a concrete way. In essence, the hierarchical view of a problem is not merely encouraged, but can be enforced by the modular nature of the language.
Views of SDE: automation of engineering and engineering of automation
Authors: Stinson W.
Published: July 2004

This paper develops an abstract model of software development and then explores its implications for software development environments (SDEs). It explores the automation of engineering, i.e.,
what
to automate, and the engineering of automation, i.e.,
how
to automate. It explains the automation of engineering by deriving basic automation paradigms from the development model. It explains the engineering of automation in terms of principles which guide the architecture of an SDE.
Techniques and experiences capturing requirements for several real-time applications
Authors: Zucconi L.
Published: July 2004

This paper discusses techniques used and experiences gained while gathering and documenting the functional requirements for five control systems and one engineering database system. The majority of this work was performed on several projects at Lawrence Livermore National Laboratory over a period of three years.Teams of from one to four engineers gathered requirements for a large laser control system, several separator control and diagnostic systems, a security system, and an engineering database system. These systems required gathering requirements data from physicists, electrical, mechanical and material engineers, and in the case of one security application system, police officers. The paper discusses team structure, the advantages of larger teams and problems with one person teams. It defines the interview, document, feedback and critique cycle used for requirements acquisition.All but one of these systems are operating. The paper concludes with a discussion on the usefulness of the requirements during system development.
Computer aided prototyping
Authors: Krista R. , Rozman I.
Published: July 2004

In this article a methodology for rapid prototyping is described. Modified data flow diagrams are used as a graphical tool and Prototyping System Description Language is deveoped.The advantages of the methodology and of the prototyping tool, which is being built, are as follows: a possibility to describe a system in an understandable graphical way without global data, a posibility to describe the system by parallel activities and a possibility to verify the whole system or only a part of it. A simple and understandable specification of the new system is enabled by decomposition.
Selection criteria for analysis and design CASE tools
Authors: Baram G. , Steinberg G.
Published: July 2004

Computer Aided Software Engineering (CASE) has been receiving increasing attention because of its potential for substantial productivity improvement of software development. Selecting CASE tools best suited to organizations needs can be a challenge because of wide variations among CASE features, completeness, terminology, and usage characteristics. This paper presents specific performance criteria of CASE tools and ranks them as required versus "nice to have." It is based on an in depth investigation of several packages.
Hyperbook: an experiment with PCTE
Authors: Kempe M.
Published: July 2004

PCTE (A Basis for a Portable Common Tool Environment) is a Public Tool Interface (PTI) intended to provide a basis on which to construct an Integrated Project Support Environment (IPSE). Thus, PTIs are primarily concerned with IPSE needs. This paper shows that applications other than IPSEs also benefit from PTIs, by examining the design, on PCTE, of a management subsystem for structured documents It goes on to describe a prototype of such a subsystem, a hypermedia kernel named Hyperbook. Finally. in the light of this case study, we discuss the feasibility and adequacy of using PCTE for such non-IPSE applications.
Application development project support
Authors: Chroust G.
Published: July 2004

ADPS

(Application Development Project Support), developed in the IBM Vienna Software Development Laboratory, is an environment for the industrial development of application software. Crucial prerequisite for such an environment is the definition of a detailed process of how to proceed (a

Process Model

) and an appropriate instrumentation via computer support (a

Process Mechanism

) which not only helps the users to follow the established process but also provides the users with various support functions.This paper puts the Process Model (

ADPS/M

) and the Process Mechanism (

ADPS/P

) into the broader context of current software engineering concepts. It explains principles and reasons for the architecture of ADPS.
Views of software development environments
Authors: Stinson W.
Published: July 2004

This paper develops an abstract model of software development and then explores its implications for software development environments (SDEs). It explores the automation of engineering, i.e.,
what
to automate, and the engineering of automation, i.e.,
how
to automate. It explains the automation of engineering by deriving basic automation paradigms from the development model. It explains the engineering of automation in terms of principles which guide the architecture of an SDE.
Metamodels for system development
Authors: Kokol P.
Published: July 2004

Information management is critical in business and engineering applications. Many empirical studies indicates both technical and nontechnical problems with information systems which are briefly reviewed in this paper, together with possible causes and solutions. The formalization of the IS development process is described in more details. Some metamodels are presented next and explained on a case of the JSD methodology. A
NEW
metamodel which is a combination of existing ones is proposed at the end.
Structural testing of programs
Authors: Omar A. A. , Mohammed F. A.
Published: July 2004

Program testing may be performed using either one of two approaches; structural or functional. This paper is concerned with the structural testing approach of programs. Given a listing of the program, the first step is to construct its flowgraph. The flowgraph usually contains a very large number of paths, owing to the program loops, so testing all the paths is impossible. A subset of these paths are chosen, according to one criterion or another. Then, a set of test data is generated which causes the selected paths to be traversed when the program runs. Finally, the program runs, using the generated test data, and the output is analysed to detect program errors. The paper discusses the problems involved and the methods used in each step of the above mentioned structural testing methodology.
The data model of the configuration management assistant (CMA)
Authors: Ploedereder E. , Fergany A.
Published: July 2004

In an environment in which systems are configured by reusing existing subsystems, the determination of complete and consistent configurations is a non-trivial and error-prone task, although considerable information about the subsystems may already be available from previous configurations. The Configuration Management Assistant is a tool that supports tracking and exploiting such information in the difficult process of re-configuration on a large scale. Its data model was designed to be as independent as possible of configuration management policies and procedures and yet provide substantive assistance in this process. The most important elements of this data model are described in this paper.
1
Design management in base/OPEN
Authors: Lundholm P.
Published: July 2004

This paper presents aspects of a design management model. The area of design management may range from items such as users, access-rights, version- and configuration management to projects and tasks. This paper concentrates on the aspects of configuration management within Design Management Model (DMM). It is part of and implemented within a framework for engineering tool development and tool integration called Base/OPEN. The DMM is presented as an end-user views it through a tool called Browser.
Separate compilation in CHIPSY
Authors: Eidnes H. , Hallsteinsen D. O. , Wanvik D. H.
Published: July 2004

This paper describes a practical implementation scheme for separate compilation of strongly typed high-level languages. The scheme provides full inter-module type checking, while limiting the problems of “big inhale” and most redundant recompilations by employing smart recompilation at reasonable cost. It also provides type-safe link-time substitution of module variants.

The scheme has been implemented for CHILL
1
in CHIPSY®, and has been in use since 1983. The current host is VAX/VMS. Targets include VAX, Intel 8086 and 80286, both stand-alone and under MS-DOS. A Sun-386i and VAX/Ultrix hosted version is under development. CHIPSY is marketed by KVATRO A/S of Trondheim, Norway.
Illustrating interference in interfering versions of programs
Authors: Reps T. , Bricker T.
Published: July 2004

The need to integrate several versions of a program into a common one arises frequently, but it is a tedious and time consuming task to merge programs by hand. The program-integration algorithm recently proposed by S. Horwitz, J. Prins, and T. Reps provides a way to create a
semantics-based
tool for program integration. The integration algorithm is based on the assumption that any change in the
behavior
, rather than the
text
, of a program variant is significant and must be preserved in the merged program. An integration system based on this algorithm will determine whether the programs incorporate interfering changes, and, if they do not, will automatically create an integrated program that includes all changes as well as all features that are preserved in all variants.

In this paper we discuss how an integration tool can illustrate the causes of interference to the user when interference is detected. Our main technical result is an alternative characterization of the integration algorithm's interference criterion that is more suitable for illustrating the causes of interference. We then propose six methods for an integration system to display information to demonstrate the causes of interference to the user.
Change oriented versioning in a software engineering database
Authors: Lie A. , Conradi R. , Didriksen T. M. , Karlsson E.-A.
Published: July 2004

We present the change oriented model of versioning, which focuses strongly on functional changes in a software product and therefore can be seen as an alternative to the traditional, “version oriented” models. The change oriented model is used as a basis for the versioning in the EPOS software engineering database, which features an integrated transaction and versioning mechanism.
Conflict management in a source version management system
Authors: Mack-Crane B. , Pal A.
Published: July 2004

To support concurrent development a source version management system must support multiple programmers concurrently accessing shared source code, while maintaining the integrity of the source database. This problem is similar to the problem of concurrency control in database systems, but has a few significant differences. This leads us to view the possible solutions as variations on database transaction management and concurrency control. In particular we consider the possibility of letting transactions interact and managing the conflicts which result.
1
Commercial realtime software needs different configuation management
Authors: Gentleman W. M. , MacKay Stephen A. , Stewart D. A.
Published: July 2004

Arguments are presented as to why integrated, monolithic configuration management is not well suited to commercial realtime systems. An alternative approach to configuration management that over several years we have found to be effective and widely useable is described. This approach,
Database and Selectors Cel
(
DaSC
), separates treatment of versions that exist simultaneously from the evolution of those versions over time. Versions that exist simultaneously are represented by selectors from a common database. Evolution is represented by layers, as in the film animators cel.
Replacing version-control with job-control
Authors: Clemm G. M.
Published: July 2004

Version-control is a mechanism for managing the multiple versions of the software objects that are created during the software development process. Traditionally, version-control consists of providing tools for generating a branching tree of versions, with facilities for reserving a given version for modification. In the Workshop System the focus of version-control is shifted from the objects produced during the software process to the software process itself. Objects called
jobs
are created in a project database to explicitly instantiate the process information. The Workshop System then provides operations for manipulating jobs, with these manipulations providing the functionality normally associated with version-control.
An experimental investigation of the close procedure as a measure of program understanding
Authors: Ullrich J. R. , Cook C.
Published: July 2004

The cloze procedure consists of systematically replacing tokens from a computer program with blanks. The cloze score, the number of blanks filled in correctly, has been used as a measure of program understanding in many experiments because it is easy to construct and score. However, little is known about the process by which the subjects fill in the blanks. This paper describes a program that collects information about the process. The program allows the subject to take a cloze test on the computer; it records the keystrokes and time as the subject fills in the blanks. Use of the program in a program comprehension experiment provided insight about differences between the subjects, order of insertion of tokens, and possible chunking strategies used by the subjects.
Software engineering education in the associate-degree-level vocational/technical computer science program
Authors: Richmond E. R.
Published: July 2004

The need for software engineers has grown with the increased use of software and computers in our society. Presently, formal education of software engineers is being conducted at the graduate degree level. There are pressure to extend this education to other academic levels; in fact, many baccalaureate degree programs today include one or more software engineering courses. Difficulties confronting software engineering education at the associate-degree level include: limited educational and experience backgrounds of the students; faculty whose own education did not include software engineering; and severe time and content constraints imposed on such two-year programs. The author concludes that the two-year associate-degree-level vocational/technical computer science program should continue to focus on producing graduates with sound programming and problem-solving skills with which to gain entry level employment, and upon which those graduates can build, with further experience and education, toward a software engineering career, Software engineering education in the two-year vocational/technical program, then, should be restricted to that which directly enhances the development of these basic skills; specific recommendations are offered for consideration.
Using cumulative graphic traces in the visualization of sorting algorithms
Authors: Stone D. C.
Published: July 2004

Some instructionally oriented graphic displays of algorithm execution can be enhanced by the use of a cumulative graphic trace, which presents a stylized visual representation of the history of the algorithm's operation on a data structure. This graphic trace can convey information about the order in which operations were done or elements were processed, information which is often not available in dynamic displays of algorithm execution. It can also in some cases serve as in "icon" to help students remember the algorithm or contrast it with similar algorithms. The use of cumulative graphic traces in the study of various sorting algorithms is illustrated.
Effective group interactions: some aspects of group projects in computer science courses
Authors: Van Meer G. L. , Sigwart C. D.
Published: July 2004

Having students work in groups in a computer science course is excellent preparation for the realities of the jobs thestudents are likely to be doing upon graduation. Most software systems are of a large enough size that it is not reasonable for one person to do. Hence team formation is the usual response to a problem that cannot be solved by one person.We have taught a number of group project courses in software engineering and systems analysis and design, and have discovered that an understanding of the specific interactions that occur in a group environment can be immeasurably helpful. The principles that follow [4, 5, 9, 10, 11, 12] apply to group projects generally.
Capturing software processes through the generated objects
Authors: Rueher M. , Ladret D. , Legeard B.
Published: July 2004

This paper mainly focusses on the representation of actual specification processes. However, the proposed scheme can be extended to the whole software process.

The specification process is the sequence of operations required for building up a complete specification. Performing these operations mainly yields information objects that can be as various as informal statements, exploratory prototypes, test cases, axiomatic descriptions, user constraints for the elaboration process, etc.

Thus, we propose to materialise the specification process through the representation of all the useful characteristics of these objects. The reason for this choice is the fact that objects are easier to comprehend than processes [Ost87].
Validating programs without specifications
Authors: Howden W.
Published: July 2004

This work was supported by the Office of Naval Research and the Naval Weapons Center
A practical approach to semantic configuration management
Authors: Moriconi M.
Published: July 2004

A configuration management (CM) tool is supposed to build a consistent software system following incremental changes to the system. The notion of consistency usually is purely syntactic, having to do with the sorts of properties analyzed by compilers. Semantic consistency traditionally has been studied in the field of formal methods and has been considered an impractical goal for CM.

Although the semantic CM problem is undecidable, it is possible to obtain a
structural approximation
of the semantic effects of a change in a finite number of steps. Our approximation technique is formalized in logic and is based on information-theoretic properties of programs. The method in its present form applies to many but not all software systems, and it is programming-language independent. To the best of our knowledge, the semantic CM problem has not been formalized previously in nonsemantic terms, and we believe that our simplified formulation offers the potential for considerably more powerful debugging and configuration management tools.
Interprocedual data flow testing
Authors: Harrold Mary Jean , Soffa Mary Lou
Published: July 2004

As current trends in programming encourage a high degree of modularity, the number of procedure calls and returns executed in a module continues to grow. This increase in procedures mandates the efficient testing of the interactions among procedures. In this paper, we extend the utility of data flow testing to include the testing of data dependencies that exist across procedure boundaries. An interprocedural data flow analysis algorithm is first presented that enables the efficient computation of information detailing the locations of definitions and uses needed by an interprocedural data flow tester. To utilize this information, a technique to guide the selection and execution of test cases, that takes into account the various associations of names with definitions and uses across procedures, is also presented. The resulting interprocedural data flow tester handles global variables, reference parameters and recursive procedure calls, and is compatible with the current intraprocedural data flow testing techniques. The testing tool has been implemented on a Sun 3/50 Workstation.
The implications of program dependencies for software testing, debugging, and maintenance
Authors: Podgurski A. , Clarke L.
Published: July 2004

This paper presents a formal, general model of program dependencies. Two generalizations of control and data dependence, called weak and strong syntactic dependence, are presented. Some of the practical implications of program dependencies are determined by relating weak and strong syntactic dependence to a relation called semantic dependence. Informally, one program statement is semantically dependent on another if the latter statement can affect the execution behavior of the former. It is shown that weak syntactic dependence is a necessary condition for semantic dependence, but that neither weak nor strong syntactic dependence are sufficient conditions. The implications of these results for software testing, debugging, and maintenance are then explored.
Estimating the number of test cases required to satisfy the all-du-paths testing criterion
Authors: Bieman J. , Schultz J.
Published: July 2004

The all-du-paths software testing criterion is the most discriminating of the data flow testing criteria of Rapps and Weyuker. Unfortunately, in the worst case, the criterion requires an exponential number of test cases. To investigate the practicality of the criterion, we develop tools to count the number of complete program paths necessary to satisfy the criterion. This count is an estimate of the number of test cases required. In a case study of an industrial software system, we find that in eighty percent of the subroutines the all-du-paths criterion is satisfied by testing ten or fewer complete paths. Only one subroutine out of 143 requires an exponential number of test cases.
Integrated concurrency analysis in a software development enviornment
Authors: Young M. , Taylor R. , Forester K. , Brodbeck D.
Published: July 2004

The inherent difficulties of analyzing concurrent software make reliance on a single technique or a single monolithic tool unsatisfactory. A better approach is to apply multiple analysis and verification techniques by coordinating the activities of a variety of small tool components. We describe how this approach has shaped the design of a set of tool components to support concurrency analysis in the Arcadia-1 software development environment. Implementation and experience with key components is described.
Reengineering of database intensive application
Authors: Agarwal Rakesh , Sarangi Ajit , Das Swati
Published: July 2004

Reengineering databases has been a challenge since ages and it requires process mapping to understand better and significantly improve the business processes and performance. In this paper we describe a generic architecture for reengineering legacy databases, which is an outcome of working on a real software project. The goal of this research is to formalize a process that is applicable to different database reengineering scenarios and requirements. We elaborate the steps that were actually done for implementing the project.
The liquid architecture
Authors: Bayrak Coskun , Davis Chad
Published: July 2004

In terms of benefiting from the potential to be gained from full distribution, today's most common implementations of distributed systems follow only limited linear versions of distribution such as client-server or n-tier models. Even many "peer to peer" systems still rely on centralized servers to provide the message passing connectivity between the peers. While these systems do provide increased robustness and computational speedup, they fail to realize the full measure of what fully distributed architectures offer.With many of the techno-historical reasons behind these linear distributed systems becoming obsolete, we should try to think of new, more truly distributed models. Fully distributed architectures should demonstrate the ability to move functionality to a completely contingent set of machines determined at or just prior to run time. Under such an architecture -- a" liquid" architecture, functionality and data are completely freed from any fixed locations or functional paths and may flow at will. Especially in the domain of shared space applications such as chat and pseudochat (i.e. instant messaging) services, and virtual collaboration, the flexibility and security to be gained from the full distribution of a liquid architecture represent not only premium benefits but possibly core requisites to their essential purpose and functionality.This paper examines the notion of a liquid architecture and explores a case study implementation of such an architecture via the Virtual Collaboration Tool introduced below.