bluuebunny/crossref_metadata_2025 huggingface dataset:
A unifying model for consistent distributed software development environments
Authors: Walpole J. , Blair G. S. , Malik J. , Nicol J. R.
Published: July 2004

The increase in size and complexity of software projects over recent years has lead to the need for Software Development Environments (SDEs). SDEs are intended to provide assistance in the development of large software systems involving teams of people. It is generally agreed that SDE's should be built on a distributed base. However, the distribution of computer systems introduces several problems which make it very difficult to maintain the
consistency
of data.

To ensure that changes to data are made consistently the concept of atomic transactions is usually adopted. However, existing transaction mechanisms are unsuitable for use in a distributed SDE. Furthermore, transactions are not the only mechanism concerned with controlling changes to the SDE database. The control of change is also a task for version and configuration control mechanisms. Traditionally, the functions of version control, configuration control and transactions have been treated as separate, unrelated issues.

This paper presents a new model which unifies all three concepts in a distributed SDE. Mechanisms for supporting the new model are presented and the application of the model to the Cosmos Distributed SDE is discussed.
Version management in Gypsy
Authors: Cohen Ellis S. , Soni Dilip A. , Gluecker Raimund , Hasling William M. , Schwanke Robert W. , Wagner Michael E.
Published: July 2004

This paper describes the Version Manager of the Gypsy programming support environment, and its integration with the object-oriented extension of Unix
1
on which it is built.
Object management issues for software engineering environments workshop report
Authors: Penedo Maria H. , Ploedereder Erhard , Thomas Ian
Published: July 2004

During recent years, several research efforts in the area of software development environments have focused on the provision of uniform Object Management Systems (OMS) as a framework for tool integration and communication. This paper summarizes discussions of an OMS Workshop on the issues that arise in defining an appropriate data model for an OMS.
The design tree: a visual approach to top-down design and data flow
Authors: Carrasquel Jacobo , Roberts Jim , Pane John
Published: July 2004

Top-down design, an accepted technique for program development in most teaching environments, is an integral part of the introductory computing courses taught at Carnegie Mellon University. Although this planning technique works well for experts, it's application among less experienced users is limited: many novices abandon this technique as soon as implementation begins, focusing their attention instead on low-level details. This paper proposes a solution to this problem: the Design Tree, a simple graphic tool used to represent the top-down decomposition of a problem. This tool can be used by instructors, as well as students, independent of the software used to build their programs. The Design Tree not only facilitates top-down decomposition of problems, but also help students decide what type of control structures and data flow to use in implementation.
Preparing students for programming-in-the-large
Authors: Werth Laurie Honour
Published: July 2004

A variety of applications to improve the use of software tools are described with emphasis placed on using tools as software engineering projects. Tool use incorporates quantitative and qualitative benefits, while better preparing students to meet the increasing demands of programming-in-the-large. Improved university-industry cooperation and resource-sharing are other advantages. Some inexpensive approaches to major problems are suggested together with future directions.
Identifying the gaps between education and training
Authors: Moore Freeman L. , Streib James T.
Published: July 2004

This paper discusses some of the issues concerning education in the academic environment and training in the industrial work environment. Recent college graduates, “new-hires”, must realize as they enter the workforce, that even though they have completed four year degree programs, they are beginning at an entry-level position. They will need job specific training to make them productive software engineers from their employer's perspective.

The aspects of distinguishing between education and training are discussed along with an understanding of how college prepares graduates for employment in the computer industry; specifically, the field of military software development as developed at Texas Instruments.
Teaching the abstract data type in CS2
Authors: Lang Joseph E. , Maruyama Robert K.
Published: July 2004

Teaching the abstract data type in CS2 is made difficult by the fact that the topic is intertwined with issues of language support, dynamic data structures and implementation techniques for dynamic data structures. When we switched to Ada to teach CS2, details of the language support for data abstraction caused us to restructure the CS2 course. By pushing the topic of the abstract data type toward the beginning of the course, we have found that it is covered more successfully.
Integrating desktop publishing into a systems analysis and design course
Authors: Jordan Donald L.
Published: July 2004

This paper describes an experiment to incorporate the new Desktop Publishing technology into our traditional Systems Analysis and Design course. The experiment was first conducted during the Fall 1987 semester and is being repeated and expanded in the Spring 1988 term. The course is considered to be a Junior level Computer Science course. Desktop Publishing systems are sometimes hard to learn and use but are very powerful and flexible tools for developing system reference manuals that contain text, graphics, line art and images. It was difficult to determine the amount of time to spend on this topic and to place this material in its proper place in the course curriculum. Some of our experiences, both positive and negative, are reported for those responsible for conducting similar courses and may be interested in implementing this new technology.
Testing student micro computer skills through direct computer use
Authors: Delaney Michael M.
Published: July 2004

This paper introduces the concept of testing students' microcomputer skills through direct computer use. Techniques are discussed which make it feasible for the instructor to grade the disk and printout that are produced by each student. The process can be generally applied to testing many different skill areas, and has been effectively used for tests on DOS and utilities, wordprocessing, spreadsheet work, and data base. Practical examples of test creation and grading of spreadsheet tests are presented. Further developments of the technique are suggested.
The effect of high school computer science, gender, and work on success in college computer science
Authors: Taylor Harriet G. , Mounfield Luegina C.
Published: July 2004

Researchers have often linked factors such as mathematics ability and overall academic achievement to success in computer science. In this study, a group of students with common mathematics backgrounds was examined to determine if some other new factors were also involved in success in computer science. In particular, the roles of prior computing experience, work, and sex are discussed. A composite picture of the typical successful student is drawn and the implications for computer science departments are identified.
Toward an ideal competency-based computer science teacher certification program: the Delphi approach
Authors: Chen J. Wey
Published: July 2004

The downward migration of computer science courses from university to secondary and even junior high school level is accelerated by the increasing computer usage in schools and the increasing demands of both parents and students for quality computer education. Teacher training is a major vehicle to the success of this migration. However, at this time, there is no consensus concerning how the secondary school computer science teacher should be certified and what should be included in the study of a computer science teacher certification program. This paper collects data from various computer expert groups through the use of Delphi technique to provide valuable guidelines for establishing a computer science teacher certification program as well as a model curriculum based on the minimum competency required of a successful secondary school computer science teacher.
Discrete mathematics for computer science majors—where are we? How do we proceed?
Authors: Marion William
Published: July 2004

It has been nine years since Anthony Ralston and Mary Shaw called for a rethinking of the importance of sound mathematical training for undergraduate computer science majors [14]. In their paper they stressed the need to develop a two-year sequence in discrete mathematics for beginning computer science majors. Since that time numerous articles about such a sequence have appeared in both mathematics and computer science journals [4], [9], [12] and [13] and a number of panel sessions at professional meetings of SIGSCE and of the Mathematical Association of America (MAA) have been held. After all this time questions about the place of discrete mathematics in the undergraduate curriculum are still being debated. One question that is no longer being asked is: should discrete mathematics be part of a computer science major's undergraduate program? The questions that are being asked now and for which there are no easy answers are: at what level should discrete mathematics be taught? should there be one course, two courses or even three courses? what should the prerequisites be for these courses? and what topics should be presented in these courses? Computer scientists and mathematicians who have read the literature, listened to the debates, examined the textbooks or taught a course in discrete mathematics or discrete structures know that there appears to be little agreement as to how and what works and when it works best. This paper attempts to analyze the current situation in more detail and to offer a few suggestions to keep the dialogue alive.
An undergraduate course in applied data communications
Authors: Brumbaugh Larry J.
Published: July 2004

This paper describes a different type of data communications course than that presently offered in most computer science programs. Several justifications for such a course are provided.
Teaching recursion as a problem-solving tool using standard ML
Authors: Henderson Peter B. , Romero Francisco J.
Published: July 2004

Standard ML is a state of the art functional programming language, with features that make it excellent for teaching recursion and problem solving at the introductory level. Among the many pedagogically interesting characteristics of ML are its simple and uniform syntax, its type polymorphism and type inferencing system, and datatype declaration facilities. With little formal ML instruction, after several weeks first year students were able to use recursively defined data structures and to define fairly powerful recursive functions in ML. Standard ML is highly recommended as a tool for teaching recursive problem solving in the context of a course on the foundations of computer science.
The TRY system -or- how to avoid testing student programs
Authors: Reek Kenneth A.
Published: July 2004

This paper discusses TRY, a software package for the UNIX
1
operating system that tests student programs. The motivation for developing the system is established by describing problems associated with traditional grading methods and electronic program submission. The design and use of the TRY system is discussed, along with the advantages it provides to both the student and the instructor.
A CASE primer for computer science educators
Authors: Mynatt Barbee T. , Leventhal Laura Marie
Published: July 2004

The continuing demand for the development of new software and maintenance of existing software has made productivity an important issue in the software industry. In the past, increases in productivity have come from the introduction of software engineering techniques. Today, software engineers are looking to CASE (computer-aided software engineering) tools as a possible source of further improvements in productivity. This paper provides an overview of current CASE tools, with a focus on three types of tools: framing environments, programming environments and general environments. Two specific CASE systems are discussed in some detail. CASE systems in the context of software engineering education are also discussed.
AIDE: an automated tool for teaching design in an introductory programming course
Authors: Schweitzer Dino , Teel Scott C.
Published: July 2004

The Department of Computer Science at the United States Air Force Academy teaches an introductory Pascal programming and problem solving course to 1400 freshman a year. Although the students have a wide range of prior programming experiences, very few have any practice with program design. To encourage proper solution design and alleviate the burdensome and demotivating reams of design documentation, the Department of Computer Science has developed an automated tool, the Automated Interactive Design Editor (AIDE). This paper will provide some background on the problems associated with student design documentation, describe how AIDE attempts to address this problem, and discuss future directions for the tool.
Success with the project-intensive model for an undergraduate software engineering course
Authors: Northrop Linda M.
Published: July 2004

There is a tremendously increasing need for software in all areas of society (the software crisis) and hence a need for increased numbers of software engineers as well as increased productivity of the current software engineers [1]. Improving the productivity of software engineers necessitates new ways of viewing software, better procedures for creating it, and most importantly, better education of current and prospective software engineers regarding the development process [2]. Software engineering is thus rapidly being incorporated into undergraduate and graduate computer science curricula and is emerging as a separate discipline. In particular, the senior level project course has received much attention as a way to provide a software engineering experience at the undergraduate level. Project teams in such courses usually consist of two to four students. This paper describes a project-intensive software engineering course in which twenty-three students worked effectively as a single project team.
Use of the Cloze procedure in testing a model of complexity
Authors: van Verth P. B. , Bakalik L. , Kilcoyne M.
Published: July 2004

This paper describes an experiment designed and conducted by undergraduate students as part of a senior research project in Computer Science. The experiment tested whether the program comprehension of a set of Fortran 77 programs can be predicted by the Oviedo/Van Verth model of program complexity. In the study, student programmers were asked to demonstrate their ability to understand programs through use of the cloze procedure. Three different kinds of Fortran 77 programs were used at three different levels of complexity determined by the model. It was hypothesized that program comprehension would decrease, i.e. the number of incorrect answers would increase, as the complexity of the programs increased. Due to a variety of reasons, the results were inconclusive. The purpose of this paper is to discuss the experiment, the method selected, and implications for future experiments.
Concurrent programming in an upper level operating systems course
Authors: Silver J. L.
Published: July 2004

Since 1983, we have been covering concurrent programming as a central feature of a senior-level course in operating systems. This paper describes the content of that course, the mechanism used to implement concurrency, and the programming projects which provide students with practical experience in concurrency.
Performance experiments for the performance course
Authors: Shub C. M.
Published: July 2004

This paper describes a newly instituted laboratory in the Computer Science Department at the University of Colorado at Colorado Springs. The reasons for developing the laboratory are delineated. The equipment is then described. This is followed by a brief description of initial experience with the laboratory. A collection of experiments performed within the laboratory is delineated in detail. Finally some brief thoughts on the future use of the laboratory and the conclusions drawn at this point in the lab's history are presented.
MPX-PC: an operating system project for the PC
Authors: Lane M. G. , Ghosal A. k.
Published: July 2004

This paper describes a student operating system project, MPX-PC, that can be implemented on an IBM PC-compatible computer. Seven modules make up the project, with the seventh module being the completion of a “stand-alone” student multiprogramming operating system. The project is implemented in Turbo C.
Neural networks and artificial intelligence
Authors: Sondak N. E. , Sondak V. K.
Published: July 2004

Neural networks have been called “more important than the atomic bomb” and have received a major funding commitment from DARPA. Nevertheless, it is difficult to find even a mention of neural network concepts and applications in many computer science or information systems curricula. In fact, few computer science or information systems faculty are aware of the profound implications of neurocomputing on the future of their field. This paper contends that neural networks must be a significant part of any artificial intelligence course. It illustrates how neural network concepts can be integrated into traditional artificial intelligence course material. Two programming packages for simulating neural networks on personal computers are recommended.
Never mind the language, what about the paradigm?
Authors: Luker P. A.
Published: July 2004

There is increasing discussion about the primary programming language used for undergraduate courses in Computer Science. In particular, the language used for CS1 and CS2 is regarded as a crucial factor in students' subsequent progress in the discipline, not to mention their mental well-being. It is argued here that instead of focussing our attention on whether we should be teaching Ada™ or MODULA-2, we should be asking if these languages belong to the right class. There is mounting evidence that “small” languages are not only beautiful but that they lead to more easily verifiable programs, more predictable implementations, and a better foundation for “programming in the large”. I do not pretend to answer any more questions than I ask.
Software engineering team project group member evaluations: some empirical results
Authors: Dunsmore Hubert E. , Moffet David P. , Ward Steven T.
Published: July 2004

Students in a software engineering course at Purdue University in the Fall of 1987 participated in team projects during and after which they completed Group Member Evaluation Forms. These evaluations revealed that: (1) project work load distribution is an area for improvement, (2) our students liked working in a team software development environment, (3) they were happy with their 4-5 person group sizes, (4) contribution critiques were very consistent (including self-critiques) and seemed to correlate well with perceived amount of work done, and (5) there was no consensus about how to handle parasites (i.e., students who do not contribute adequately to the team effort).
The USC system factory project
Authors: Scacchi W.
Published: July 2004

Developing the next generation of large-scale software systems will change the patterns of work in system development organizations. We therefore expect the major systems engineering problems to be solved will require
organizational solutions
that accomodate
advanced software development tools, flexible manufacturing techniques for system life cycle engineering
, and
knowledge-intensive strategies for managing large system development projects
. Over the past seven years, we have created an experimental organizational environment for developing large software systems that allow us to encounter these problems, and find effective solutions or interventions. We call this organizational environment the
System Factory
. We have developed and evolved the System Factory through seven generations of graduate student staff, totaling more than 500 in number. In this report, we describe what the System Factory is, the problems we have investigated, the results and example products of this research, potential future applications of the System Factory approach, and finally our experiences in transferring this technology.
On teaching operating systems
Authors: Yun-Lin Su
Published: July 2004

This paper discusses teaching an Operating Systems Course. Different approaches to teaching the course are presented. An operating systems course is one of the kernel courses in computer curriculum of both China and other countries. This course is of critical importance for students to understand the working procedures and principles of modern computer systems, to understand the methodology and approach of the design of system software, and to gain an appreciation for the requirements of other large-scale software projects.
The impact of structured editing on introductory computer science education: the results so far
Authors: Goldenson D. R.
Published: July 2004

Properly done, introductory computer science courses have great potential, both for preparing future computing professionals and for the broad goals of general education. Yet the performance all too often lags well behind the promise. Poor grades, high failure and drop out rates are all too common at both the collegiate and pre-collegiate levels. However the advent of seamless programming environments based on structure editing provides us with an opportunity to change the situation in fundamental ways. Initial studies show dramatic differences between students who do and do not use a structure editor based environment.
Comparing test data adequacy criteria
Authors: Weiss S. N.
Published: July 2004

Test data adequacy criteria have been compared in a multitude of ways in the literature, ranging from the relative difficulty of satisfying them to the relative probability that test sets that satisfy them will expose errors in programs. Each method of comparison gives rise to an ordering of criteria, many of which differ significantly from the others. We investigate the various methods of comparing criteria, and show how the induced orderings are related. There are presently no methods of comparison that are based on the cost of using criteria; we propose a formal model of cost comparison of criteria. We categorize methods of comparison as being satisfiability based, correctness based, or complexity based.
Selecting a CASE tool
Authors: Zucconi L.
Published: July 2004

Selecting a Computer-Aided Software Engineering (CASE) tool can be a bewildering task, considering the number and variety of systems on the market. This paper presents a rigorous step-by-step selection process for choosing CASE tools. This algorithm requires that a set of CASE requirements be developed to meet the needs of the software development organization. Other selection steps include contacting vendors for information, conducting a preliminary screening of vendors to obtain a list of semi-finalists, and requesting a written response to the CASE requirements from the vendors and a loan of the tools for evaluation. The last steps inlcude site visits or non-disclosure meetings with the finalist vendors, and then the final selection.
On the design of the amoeba configuration manager
Authors: Baalbergen E. H. , Verstoep K. , Tanenbaum A. S.
Published: July 2004

The program
Amoeba Make
, or
Amake
, is being designed to fulfil the need of a
make
-like configuration manager capable of exploiting the potentials of the Amoeba distributed operating system. The major design goal is to create a software configuration manager that is both easy to use and efficient. The specification and maintenance of a large configuration should be easy, and should be automated as much as possible. Furthermore, the build process should exploit Amoeba's capabilities and resources when creating or updating a target. In this paper we show how a smart file server can contribute to
Amake's
efficiency. We also show how a declarative configuration description allows
Amake
to take full advantage of parallelism and to determine the commands needed for building and maintaining targets.
A schema for configuration management
Authors: Miller T. C.
Published: July 2004

Sun's Network Software Environment (NSE) provides configuration management services for engineering applications [1] [2] [3]. This paper describes the NSE and the object schema it was based on. It emphasizes the design decisions we made in constructing the system.
Edge concentration: a method for clustering directed graphs
Authors: Newbery F. J.
Published: July 2004

The display of a directed graph is a commonly used visual aid for representing relationships. However, some graphs contain so many edges that their display by traditional graph layout algorithms is virtually impossible because of the overwhelming number of crossings. Graphs representing large software systems and their configurations are particularly prone to this problem. Examples of such graphs include: graphs depicting a system's configuration, call graphs, graphs depicting import and export relationships between modules, and graphs depicting the “includes” relation among a system's source files.

This paper proposes the elimination of some edges by replacing sets of edges that have the same set of source and target nodes by a special node called an
edge concentration node
. Reducing the number of edges often has the desirable side effect of reducing the number of crossings. An algorithm that determines a reasonable set of edge concentrations of a graph in Ο(
n
4
) operations for each level in the graph is presented where
n
is the number of nodes in that level. Several examples from the area of software configuration management are shown to demonstrate the effectiveness of using edge concentrations.
Revision control in an integrated software development environment
Authors: Westfechtek B.
Published: July 2004

We present a graph-based formal approach to revision control that takes consistency relations between revisions of different documents into account. We use a new powerful graph grammar specification language, called PROGRESS, for the rule-based specification of consistency preserving changes to revision graphs. In addition to coarse-grained relations between revisions, we also deal with fine-grained relations between increments which belong to revisions of different documents. Our work provides the formal basis for the construction of a syntax-directed hypertext editor which supports control of revisions and their interrelations.
Maintaining the evolution of software objects in an integrated enviornment
Authors: Gustavsson A.
Published: July 2004

This paper discusses the organization of software objects in an integrated environment from the software configuration management view. We will emphasize organization by evolution, by membership and by composition. The paper introduces program base objects which are version controlled in order to maintain the evolution of software objects. Different specializations of such objects make it possible to maintain source objects and to support organization of software objects by membership and by composition in a uniform way.
Object-oriented configuration control
Authors: Ambriola V. , Bendix L.
Published: July 2004

In this paper we show how configuration management and version control can be integrated and automated. Our approach is to use an object-oriented paradigm for the environment and to consider dependencies between modules to be a property local to every single version rather than a global property of the whole version group. In our proposed model configuration control depends on the dynamic evolution of the system rather than on a static description.
Orthogonal version management
Authors: Reichenberger C.
Published: July 2004

One part of the “Software Configuration Management” — software version control — is the task of controlling different versions of documents. Most existing version control systems accomplish this task by managing variant and revision trees of single documents. The structure of these trees depends on the chronological evolution of the software project. We call this form of organization “intermixed organization” of variants and revisions. This paper points out the disadvantages of that organization, introduces a new way of version management - the “orthogonal organization” - and then compares the two organizations by means of an example.
Aladdin/lamp: Configuration management tools for distributed computer control systems
Authors: Pakstas A.
Published: July 2004

The problem of the automation of the development of distributed software configuration (DSC) in the distributed computer control systems (DCCS) is discussed. The present paper deals with the building technology of the organisation of the interactions environment of applicational programs through the constructions like “information transport port” (ITP); On the basis of the DCCS structural model the system architects' language ALADDIN is developed. It is designated for the control of ITP work and for the linkage of DSC. The ALADDIN/LAMP software development system is described.
Object derivation and validation from a data base definition
Authors: Dinsart A. , Hucq B. , Piperakis N. , Thollembeck P. J.
Published: July 2004

The MONSYS (MONtage SYStem) method and tool has been developed by the SIEMENS Systems Development . Division with the objective to increase the efficiency and quality of the integration process for the BS2000 System Software. Presently MONSYS is used to integrate new BS2000 versions. This paper does not detail all the MONSYS features. It focuses on the management of the object code level. The derivation of a software configuration is detailed with emphasis on the derivation environment concept, the use of the MONSYS Data Base, and feed back from that industrial experience.
Applying process programming to the model
Authors: Boeh B. , Belz F.
Published: July 2004

The primary thesis of this position paper is that process programming is analogous to programming in an key respect not previously emphasized: that it will proceed more effectively if preceded by a set of activities to determine the requirements, architecture, and design of the process.
Real-time interval logic for reasoning about executions of real-time programs
Authors: Razouk R. , Gorlick M.
Published: July 2004

Research on the testing and debugging of distributed real-time programs now focuses on more formal approaches to specification and testing. Temporal logic is a natural candidate for this since it can specify properties of event and state sequences. However, the absence of any concept of real-time limits the application of temporal logic to non real-time behavior. This paper presents an extension of the interval logic of Schwartz et al. [SMSVP83], by increasing the expressive power of the logic (with respect to real time) while retaining its intuitive appeal and understandability. The extensions are added in a “layer” that can be stripped away if formal verification is the goal, or retained if timing behavior must be tested. The extensions include: the ability to deal with real time (as in [JM86b, JM86a, OW87, NA88]); more powerful interval specification mechanisms; a limited form of quantification; and the direct expression of event predicates (as in [LeD86]). Since our work is intended to yield practical tools for software testers, we emphasize the ease of expressing the complex timing properties of real-time software (e.g. periodic behavior, performance constraints), and we demonstrate the use of the interval logic on some real-time examples that represent a test of the expressiveness and understandability of the notation.
Theoretical comparison of testing methods
Authors: Hamlet R.
Published: July 2004

Comparison of software testing methods is meaningful only if sound theory relates the properties compared to actual software quality. Existing comparisons typically use anecdotal foundations with no necessary relationship to quality, comparing methods on the basis of technical terms the methods themselves define. In the most seriously flawed work, one method whose efficacy is unknown is used as a standard for judging other methods! Random testing, as a method that
can
be related to quality (in both the conventional sense of statistical reliability, and the more stringent sense of software
assurance)
, offers the opportunity for valid comparison.
Cesar: a static sequencing constraint analyzer
Authors: Olender K. , Osterweil L.
Published: July 2004

This paper relates experience with building and using a programmable sequencing analyzer based on data flow analysis algorithms. An earlier paper described both the motivation for and the specification of Cecil, a powerful language for defining constraints on the sequencing of events and gave an algorithm for mapping the sequencing specifications defined by Cecil to data flow analysis algorithms. In this paper, we sketch the architecture of Cesar, a system for carrying out the analysis of Cecil sequencing constraints, describe the problems arising in the analysis of real-world programs, and indicate how we resolved these problems. Finally, we describe our experience in using Cesar, citing speed and efficiency characteristics of the current implementation, and suggesting the error-detection features and powers of Cesar.
The logic of propagation in the inscape environment
Authors: Perry D.
Published: July 2004

The Inscape Environment research project addresses issues in supporting the development of large systems by large numbers of programmers. One aspect of this research is the “constructive use” of formal module interface specifications - that is, given that you have formal specifications, what can you do with them. In Inscape, the specifications form the basis for providing an environment that is knowledgeable about the process of developing and evolving software systems, an environment that works in symbiosis with the programmer to develop and evolve a software system.

In this discussion, I present how Inscape uses operation specifications (based on Hoare's input/output predicate approach) as the basis for synthesizing the interfaces for such complex languages statements as sequence, selection and iteration. In each of these statements, the synthesized interface is a function of the component interfaces.

I first present the basic rules for interface specification use and the logical framework for interface propagation and error detection. I then define the rules for propagating the interfaces for sequence, selection, iteration and operation. Finally, I define notions of “implementation completeness and correctness”.
Experiments in automated analysis of concurrent software systems
Authors: Avrunin G. , Wileden J. , Dillon L.
Published: July 2004

It is unlikely that any single approach to analysis of concurrent software systems will meet all the needs of software developers throughout the development process. Thus, experimental evaluation of different analysis techniques is needed to determine their relative strengths and practical limitations. Such evaluation requires automated tools implementing the analysis techniques.

This paper describes a prototype toolset automating the constrained expression approach to the analysis of concurrent software systems. The results of preliminary experiments with the toolset are reported and the implications of these experiments are discussed.
How scalable is J2EE technology?
Authors: Brebner Paul , Gosper Jeffrey
Published: July 2004

ECperf, the widely recognized industry standard J2EE benchmark, has attracted a large number of results submissions and their subsequent publication. However, ECperf places little restriction on the hardware platform, operating systems and databases utilized in the benchmarking process. This, combined with the existence of only two primary metrics, makes it difficult to answer critical questions such as "Is there a limit to J2EE scalability?" and "Is scale-up or scale-out more effective?". By mining the full-disclosure archives for trends and correlations we have discovered that J2EE technology is very scalable, both in a scale-up and scale-out manner. Other observed trends include, a linear correlation between middle-tier total processing power and throughput, as well as between J2EE Application Server license costs and throughput. However, the results clearly indicate that there is an increasing cost per user with increasing capacity systems, and scale-up is proportionately more expensive than scale-out.
Heavyweight extensions to the UML metamodel to describe the C3 architectural style
Authors: Pérez-Martínez Jorge Enrique
Published: July 2004

UML is widely accepted as the standard for representing the various software artifacts generated by a development process. For this reason, there have been attempts to use this language to represent the software architecture of systems as well. Unfortunately, these attempts have ended in the same representations (boxes and lines) already criticized by the software architecture community.In this work we propose an extension to the UML metamodel that is able to represent the syntactics and semantics of the C3 architectural style. This style is derived from C2. The modifications to define C3 are described in section 4. This proposal is innovative regarding UML extensions for software architectures, since previous proposals where based on light extensions to the UML meta-model, while we propose a heavyweight extension of the metamodel. On the other hand, this proposal is less ambitious than previous proposals, since we do not want to represent in UML any architectural style, but only one: C3.
Quantification of structural information
Authors: Heering Jan
Published: July 2004

We introduce the notion of
generative software complexity
to illustrate some of the problems one may run into when trying to tackle a special case of a question recently raised by Brooks.
Fostering the growth of a software quality culture
Authors: Howles Trudy
Published: July 2004

Instructors often discuss assessment of the technical skills students must acquire in a typical computer science program. Often times, the technical skills and the required body of knowledge are mandated through standards or curricular requirements. How are non-technical skills assessed? Are computer science educators teaching and encouraging the development of other critical skills needed in the workplace such as personal accountability, a strong work ethic, and an ability to deliver on-time and correct work? This paper describes the results of a student survey, designed to provoke some thoughts about the evolving work ethic and the level of a quality-centered culture in students today.
Information characteristics for the curriculum
Authors: Grable Ross
Published: July 2004

A technical capstone course integrates course knowledge, underscores the scientific nature of computer science, and introduces professional and graduate school topics. A capstone course brings together knowledge from many subjects. An experiment brings together many topics from the standard curriculum that are hard to integrate into standard courses. A common thread in state machines ties together the diverse topics under the theme of information characteristics. Each subject area is related to a state machine view of information and uses some specific mathematics skill. The experiment with this approach has been successful.
The treatment of deep vs. shallow copy in introductory C++ textbooks
Authors: Carl Stephen P.
Published: July 2004

The default behavior of C++ compilers is to generate a destructor, copy constructor, and assignment operator for each class defined in source code, if that class does not provide such. The constructor and assignment operator generated perform a shallow copy of objects, which is incorrect behavior for most objects that contain pointers. Students must be taught to provide these operators, and to write the copy constructor and assignment operator such that they perform a deep copy of objects. A survey of introductory C++ texts shows that some authors do not explain this important topic in a consistent or thorough way. Any instructor beginning to teach C++ needs to understand this or face the prospect of long hours debugging what otherwise would seem to be a straightforward assignment.
The Flo-and-Mac problem
Authors: Bernick Jonathan P.
Published: July 2004

It has historically been difficult to persuade undergraduates to become involved in research, in part due to the difficulty of making meaningful research problems accessible to such students. This paper describes the Flo-and-Mac problem, an open-ended research problem specifically designed to be accessible to undergraduates, and to enable them to make a meaningful contribution to a scientifically interesting investigation. Perspectives from which the Flo-and-Mac problem can be investigated are examined, and the use of the problem as a pedagogical tool and tournament problem is discussed. It is concluded that Flo-and-Mac problem is a viable tool for these purposes, and further investigation is recommended.
Teaching programming in the OOP era
Authors: Burton Philip J. , Bruhn Russel E.
Published: July 2004

This paper argues in favor of teaching a course in Procedural Programming first before a course in Object Oriented Programming. The basis of the argument is that considered as a paradigm, Object Oriented Programming comes in addition to the Procedural Programming paradigm and not as a replacement for it. In addition, we discuss the mathematics prerequisites required for programming and argue that Information Science departments should insist that students receive a firm foundation in traditional mathematical skills and that the use of instructional technology should reinforce these skills and not detract from them.
Exploring the role of visualization and engagement in computer science education
Authors: Naps Thomas L. , Rößling Guido , Almstrum Vicki , Dann Wanda , Fleischer Rudolf , Hundhausen Chris , Korhonen Ari , Malmi Lauri , McNally Myles , Rodger Susan , Velázquez-Iturbide J. Ángel
Published: July 2004

Visualization technology can be used to graphically illustrate various concepts in computer science. We argue that such technology, no matter how well it is designed, is of little educational value unless it engages learners in an active learning activity. Drawing on a review of experimental studies of visualization effectiveness, we motivate this position against the backdrop of current attitudes and best practices with respect to visualization use. We suggest a new taxonomy of learner engagement with visualization technology. Grounded in Bloom's well-recognized taxonomy of understanding, we suggest metrics for assessing the learning outcomes to which such engagement may lead. Based on these taxonomies of engagement and effectiveness metrics, we present a framework for experimental studies of visualization effectiveness. Interested computer science educators are invited to collaborate with us by carrying out studies within this framework.
Materials development in support of mathematical thinking
Authors: Henderson Peter B. , Hitchner Lew , Fritz Sister Jane , Marion Bill , Scharff Christelle , Hamer John , Riedesel Charles
Published: July 2004

Our ITiCSE 2002 working group 'Materials Development in Support of Mathematical Thinking' identified the development of an on-line repository as the best mechanism for organizing and disseminating materials promoting mathematical thinking in computer science education.
The role for framework libraries in CS2
Authors: Collins William , Tenenberg Josh , Lister Raymond , Westbrook Suzanne
Published: July 2004

The recent emergence of object-oriented framework libraries of classic data structures and algorithms such as the Standard Template Library and Java's Collection classes provides a set of general and efficient data structure components for use by practicing software developers. A number of textbook writers are beginning to incorporate the use of these frameworks into "CS2", the traditional first course in data structures at the university level.There has scarcely been a discussion of how these frameworks should best be incorporated into CS2, if they should be used at all. The proposed panel will examine the role of standardized framework libraries in the first data structures course at the university level. Panelists will focus on the following questions. What are the fundamental objectives of CS2, and what role might frameworks have in meeting these objectives? How does an instructor balance student needs for additional instruction in programming basics (e.g. arrays and pointers) versus practice in larger scale design and code reuse? What would be given up to incorporate frameworks into CS2? And to what extent is it important for students to construct elementary data structures from first principles? What assumptions about student cognition and learning does a pro- or con-frameworks approach imply.By trying to articulate answers to some of the above questions, we hope to raise the level of discussion concerning the evolution of the introductory computer science curriculum. This panel will thus try to make explicit, and hence available for critical examination, some of the arguments and assumptions that inform this debate.
Keynote address
Authors: Roberts Eric
Published: July 2004

According to prevailing labor projections, the demand for well-trained computer scientists and software developers will continue to grow in the coming years, in spite of the dot-com collapse. For the most part, the people who fill these positions -- and particularly those that require high levels of creativity and independence of thought -- will be trained by colleges and universities. Unfortunately, many highly talented students never investigate computer science as an academic option, either because they have not been exposed to what computing has to offer or because they feel themselves outside of the traditional computer science milieu. As computer science teachers, we have a collective responsibility to ensure that this discipline remains open to the widest possible range of students. In this talk, I will describe several strategies and tactics for achieving that goal.
Teaching human-computer interaction
Authors: Barnes Julie , Bryant Rob , McCracken Daniel D. , Reiser Susan
Published: July 2004

Most schools introduce HCI into the CS curriculum through a bootstrapping process. There are many excellent HCI programs at universities around the world, and some new faculty with HCI graduate degrees are starting to appear. But the extreme shortage of faculty forces most schools now starting to teach HCI to use the time-honored method of learning a subject by teaching it.Consensus: Insert HCI into any opening you can find. Learn more about the subject yourself. Let colleagues get comfortable with the idea. A required course in HCI may be some years off, or maybe you will never do exactly that, but you will have laid the foundation for getting HCI into your curriculum.