bluuebunny/crossref_metadata_2025 huggingface dataset:
Data-flow analysis of program fragments
Authors: Rountev Atanas , Ryder Barbara G. , Landi William
Published: July 2004

Traditional interprocedural data-flow analysis is performed on whole programs; however, such
whole-program analysis
is not feasible for large or incomplete programs. We propose
fragment data-flow analysis
as an alternative approach which computes data-flow information for a specific program fragment. The analysis is parameterized by the additional information available about the rest of the program. We describe two frameworks for interprocedural flow-sensitive fragment analysis, the relationship between fragment analysis and whole-program analysis, and the requirements ensuring fragment analysis safety and feasibility. We propose an application of fragment analysis as a second analysis phase after an inexpensive flow-insensitive whole-program analysis, in order to obtain better information for important program fragments. We also describe the design of two fragment analyses derived from an already existing whole-program flow- and context-sensitive pointer alias analysis for C programs and present empirical evaluation of their cost and precision. Our experiments show evidence of dramatically better precision obtainable at a practical cost.
Structural specification-based testing
Authors: Chang Juei , Richardson Debra J.
Published: July 2004

In this paper, we describe a testing technique, called
structural specification-based testing
(SST), which utilizes the formal specification of a program unit as the basis for test selection and test coverage measurement. We also describe an automated testing tool, called ADLscope, which supports SST for program units specified in Sun Microsystems' Assertion Definition Language (ADL). ADLscope automatically generates coverage conditions from a program's ADL specification. While the program is tested, ADLscope determines which of these conditions are covered by the tests. An uncovered condition exhibits aspects of the specification inadequately exercised during testing. The tester uses this information to develop new test data to exercise the uncovered conditions.

We provide an overview of SST's specification-based test criteria and describe the design and implementation of ADLscope. Specification-based testing is guided by a specification, whereby the testing activity is directly related to what a component under test is supposed to do, rather than what it actually does. Specification-based testing is a significant advance in testing, because it is often more straightforward to accomplish and it can reveal failures that are often missed by traditional code-based testing techniques. As an initial evaluation of the capabilities of specification-based testing, we conducted an experiment to measure defect detection capabilities, code coverage and usability of SST/ADLscope; we report here on the results.
CHIME
Authors: Dossick Stephen E. , Kaiser Gail E.
Published: July 2004

We introduce CHIME, the Columbia Hypermedia IMmersion Environment, a metadata-based information environment, and describe its potential applications for internet and intranet-based distributed software development. CHIME derives many of its concepts from Multi-User Domains (MUDs), placing users in a semi-automatically generated 3D virtual world representing the software system. Users interact with project artifacts by “walking around” the virtual world, where they potentially encounter and collaborate with other users' avatars. CHIME aims to support large software development projects, in which team members are often geographically and temporally dispersed, through novel use of virtual environment technology. We describe the mechanisms through which CHIME worlds are populated with project artifacts, as well as our initial experiments with CHIME and our future goals for the system.
FACADE
Authors: Grimaud Gilles , Lanet Jean-Louis , Vandewalle Jean-Jacques
Published: July 2004

The use of smart cards to run software modules on demand has become a major business concern for application issuers. Such down-loadable executable content needs to be trusted by the card execution environment in order to ensure that an instruction on a memory area is compliant with the definition of the data stored in this area (
i.e.
its type). Current solutions for smart cards rely on three techniques. For Java Card, either an off-card verifier-converter performs a static verification of type-safety, or a defensive virtual machine performs the verification at runtime. For other types of open smart cards, no type-checking is carried out and the trust is only based on the containment of applications. Static verification is more efficient and flexible than dynamic techniques. Nevertheless, as the Java verifier cannot fit into a card, the trust is dependent on an external third-party. In this way, the card security has been partly turned to the outside. We propose and describe the
FACADE
language for which the type-safety verification can be performed statically on-card.
International Workshop on Testing Distributed Component-Based Systems
Authors: Ulrich Andreas , Chrobok-Diening Gunther
Published: July 2004

This summary reports on the one-day Workshop on Testing Distributed Component-Based Systems (TDCS) that took place in affiliation with the International Conference on Software Engineering (ICSE) in Los Angeles in May 1999. The workshop dealt with new advances in test methods and test technologies for the emerging class of distributed component-based systems that are built on basis of middleware software like COM, CORBA, or Java RMI, including systems comprising Commercial-Off-The-Shelf (COTS) components. The around thirty workshop attendees discussed what efforts in software technology and research are required to cope with testing such systems. Twelve papers out of nineteen submissions were presented.
Roles in the maintenance process
Authors: Polo Macario , Piattini Mario , Ruiz Francisco , Calero Coral
Published: July 2004

Software maintenance is the most expensive and least predictable stage of the software life cycle, representing in some cases between 67% and 90% of total costs.On the other hand, it is well known that the structure of a work team influences on the productivity of its members. We can help to decrease costs of maintenance through the definition of an adequate structure of the work team and with the clear identification of the tasks which every member must execute.In this work we expose the results that, in this sense, we have obtained from the application of MANTEMA to real projects. MANTEMA is a methodology for supporting software maintenance, developed jointly by our university and Atos ODS, an international enterprise among whose primary business activities is the outsourcing of software maintenance. Atos ODS is using MANTEMA in big projects of Spanish banking.
Design and analysis of algorithms reconsidered
Authors: Levitin Anany
Published: July 2004

The paper elucidates two views (models) of algorithmic problem solving. The first one is static; it is based on the identification of several principal
dimensions
of algorithmic problem solving. The second one is dynamic, i.e., it catalogs main steps in the
process
of solving a problem with a computer. The models are used to identify several important issues in teaching design and analysis of algorithms and to suggest ways of rectifying the shortcomings identified.
Cogito, Ergo sum! cognitive processes of students dealing with data structures
Authors: Aharoni Dan
Published: July 2004

A research that has just recently been finished, investigated thinking processes that occur in the minds of students dealing with data structures. The research findings are pointed out in this paper, and two of them are elaborated. One is the phenomenon of
programming-context thinking
. This type of thinking stems from comparatively low level of abstraction gained by students in a data structures course. Programming-context thinking is the cause of other phenomena found in the research, and one such phenomenon —
perception of a data structure as static or dynamic
— is also elaborated. Implications for data structures instruction are discussed.

Apart from presenting the research results, this paper serves as an example of cognitive research — a kind of research that is still not broadly enough done in Computer Science Education. It is one purpose of this paper to manifest the need for more such research.
Powers of 10
Authors: Cunningham Steve
Published: July 2004

The growing maturity of computer graphics technology now makes it possible to view the introductory graphics course in a general computer science curriculum in a new light. Instead of requiring highly specialized techniques and a great deal of mathematics before a student can produce significant work, the course can now be built around generally-accepted standard graphics standard APIs. This opens the door to making computer graphics available to a wider audience and moves the introductory computer graphics course in exciting new directions.
An innovative university program on management and ICT
Authors: Lemmen Karel , Mulder Fred , Smit Wim
Published: July 2004

In the mid nineties the idea came up to introduce a University program on information and communication Technology (ICT) and management aspects as a unique operative project of the Open University of the Netherlands, together with some colleges of higher Professional education and other universities in the Netherlands. The program is meant to meet the growing demand for people mastering the mixture of ICT and management. It aims at a specific target group of students, @@@@mely experienced professionals who have already finished a higher professional education program in @@@@ormatics. Through the so-called MICT program they can @@@@end and upgrade their management & ICT knowledge, @@@@ich effort — after successful completion — is leading to a higher) university degree. In this paper we will describe @@@@ philosophy behind the MICT program and its contents. @@@@ so we will discuss its position as a university program @@@@d some of the results that have emerged to date.
Parallel computing to start the millennium
Authors: Adams Joel , Nevison Chris , Schaller Nan C.
Published: July 2004

We describe the experience of three undergraduate computer science programs offering courses on parallel computing. In particular, we offer three different solutions to the problem of equipping a lab and discuss how those solutions may impact the content of the course.
Design early considered harmful
Authors: Buck Duane , Stucki David J.
Published: July 2004

We have recognized that the natural tendency to teach according to the structure of one's own understanding runs contrary to established models of cognitive development. Bloom's Taxonomy has provided a basis for establishing a more efficacious pedagogy. Emphasizing a hierarchical progression of skill sets and gradual learning through example, our approach advocates teaching software development from the inside/out rather than beginning with either console apps or monolithic designs.
Experiences in using animations in introductory computer science lectures
Authors: Rößling Guido , Freisleben Bernd
Published: July 2004

Algorithm animation has received much interest over the last few years. In this paper, we discuss the experiences gained in integrating animations into introductory computer science courses with large audiences of more than 200 students. After providing a short introduction to the animation tool we developed, we describe why and how we used animations in our lectures and present some example animations.
Supporting reflection in introductory computer science
Authors: Fekete Alan , Kay Judy , Kingston Jeff , Wimalaratne Kapila
Published: July 2004

Educational theory suggests that student learning is enhanced when students pay attention to their own learning. In this paper, we describe a range of innovative techniques that we use to encourage students to reflect on the state of their knowledge, and on the process by which they acquire it. Examples include providing web-based arrangements for students to practice assessing material based on the criteria we use in marking, and allocating marks in assessment for reflective writing.
Pedagogically sound responses to economic rationalism
Authors: Greening Tony
Published: July 2004

Economic rationalism, which rests decision-making power with market forces, has established a ubiquitous presence on a global scale. Certainly, educational administrators are feeling the effects of economic rationalist policies and in turn make managerial decisions that reflect this essence to the practising academic and, ultimately, to the classroom. The effect is often one of despair. Teaching - long pitted against other roles of the academic, such as research - now faces additional threats from the pressures to operate in this environment, often regarded as antagonistic to the traditional values of liberal university education. This paper discusses the nature of economic rationalism using the Australian context as an example, and presents some means by which teaching in computer science may respond to this threat in pedagogically sound ways. Such negotiations are essential in approaching a future for CS education in which this policy context is almost guaranteed.
Encouraging students in large classes
Authors: Andersson Roy , Roxå Torgny
Published: July 2004

Our experiences and results of encouraging our students in a large CSI course to keep up with the pace of the course at a reasonable cost for us are presented. We have successfully managed to pinpoint students who are about to fall into the anonymity and passivity trap and give them the extra attention they need to avoid the trap
when
they need it. Since we managed to pinpoint the most needing students we can give them the extra personal recognition and encouragement they need at a very reasonable cost in the perspective of the whole course. For the two years we have tried our concept we can see a significant increase in the pass rate of the final exam.
Toolkits in first year computer science
Authors: Rasala Richard
Published: July 2004

Traditional first year computer science courses teach the principles of computing using the basic features of some chosen programming language such as C, C++, Java, Ada, Scheme, Eiffel, etc. Abstraction and encapsulation focus on entities such as algorithms, functions, data structures, classes, objects, and closures that can be built directly on top of the raw language. If a facility such as windows and graphics is not directly available in the language then it is not used. This means that student exercises tend to look inward at computer science issues rather than outward to the exciting applications that show the breadth and power of computing.

The fundamental thesis of this article is that teaching students in the framework of powerful toolkits is essential to maintain student interest and is pedagogically important precisely because toolkits are a rich source of examples that illustrate the principles of computation. We hope to convince computer science faculty that the use of toolkits is imperative in a modern first year curriculum.

We will first discuss in general why toolkits are important. We will spice this discussion with some simple illustrations and with references to the use of toolkits by faculty at other institutions.

We will then describe the toolkits we have developed at Northeastern University and explain both what they do and why they are pedagogically valuable. We will see how toolkits enable students to do more interesting and effective work and how principles of design and algorithms can be demonstrated by the key components of the toolkits.

We will conclude with some general remarks and explain why the arguments made against toolkits do not have sufficient weight to change our conclusions. We will also give the web site address where our toolkits are available.
Real-world program design in CS2
Authors: Rebelsky Samuel A. , Flynt Clif
Published: July 2004

Recent curricular recommendations (e.g., [7,9]) encourage the early and regular use of significant group projects in the introductory computer science sequence. In this paper, we report on a group project that we used in two courses during the second half of the semester. Rather than having each group work on the same project (or even individual projects), the groups build parts of a larger project: a distributed auction system to be used by art shows at conventions. Students reacted quite positively to the experience, in spite of reporting that they spent upwards of twenty hours on the project in many weeks. Students also learned important software design principles from experience.
Empirical investigation throughout the CS curriculum
Authors: Reed David , Miller Craig , Braught Grant
Published: July 2004

Empirical skills are playing an increasingly important role in the computing profession and our society. But while traditional computer science curricula are effective in teaching software design skills, little attention has been paid to developing empirical investigative skills such as forming testable hypotheses, designing experiments, critiquing their validity, collecting data, explaining results, and drawing conclusions. In this paper, we describe an initiative at Dickinson College that integrates the development of empirical skills throughout the computer science curriculum. At the introductory level, students perform experiments, analyze the results, and discuss their conclusions. In subsequent courses, they develop their skills at designing, conducting and critiquing experiments through incrementally more open-ended assignments. By their senior year, they are capable of forming hypotheses, designing and conducting experiments, and presenting conclusions based on the results.
A primer for applying service learning to computer science
Authors: Sanderson Pete , Vollmar Ken
Published: July 2004

Service learning is an educational philosophy that promotes active learning through community service. We have recently applied this approach in our computer science curriculum, specifically to our software engineering course. In order that other computer science departments can benefit from our experience, we have developed a primer one can follow to establish a program for service learning in the computer sciences. We also describe and assess our experience after one year of applying service learning to software engineering.
A fundamentals-based curriculum for first year computer science
Authors: Sanders Ian , Mueller Conrad
Published: July 2004

At Wits we are concerned about offering a good computer science degree but at the same time making our degree programme accessible to all students who have the potential or ability to cope with the material. This paper discusses a new first year curriculum which has been developed to address some of the problems which the course that we offered from 1990 to 1998, with minimal changes, has begun to encounter. The most important of these problems is that of student perceptions of our old course. The new course stresses fundamentals of computer science and is structured around teaching basic principles and competencies.
Myths about object-orientation and its pedagogy
Authors: Lewis John
Published: July 2004

Object-orientation continues to find a home in computing curricula, especially in early courses such as CS1. As this trend continues, some ideas seem to take on a life of their own, despite being fundamentally incorrect. Unfortunately they propagate most quickly among those who are relatively new to the ideas of object-oriented development. This paper enumerates and debates the underlying issues of several myths regarding object-orientation and its pedagogy.
Recursively speaking
Authors: Levy Dalit , Lapidot Tami
Published: July 2004

Recursion is a powerful concept, appearing in almost every introductory course in computer-science (CS). CS educators and educational researchers often refer to difficulties in learning recursion, and suggest methods for teaching recursion. However, the research literature barely addresses the unique ways in which students relate to this interdisciplinary concept and the particular learners' language concerning recursive phenomena. The gap is most apparent when seen through a constructivist lens, where the students' prior knowledge and idiosyncratic conceptions should be referred to and reflected upon in order to serve as a basis for further knowledge construction. This paper reports on a study in which a collaborative classification of several recursive phenomena is used to facilitate the construction of recursion. The students' discourse was analyzed, as a step toward understanding the students' ways of speaking recursively. Preliminary results indicate some basic aspects of recursion in the student discourse, although the students apparently talk a very different language from that of the experts, as used by books and teachers.
Multimedia
Authors: Ross John Minor
Published: July 2004

After several years of using videodisc systems as a topic in a Current Directions course for seniors, a sophomore-level Multimedia course (D250) was added in the fall of 1995. The course includes hands-on experience with multimedia development and multimedia presentation software. In its first five years (fourteen sections averaging twenty students), D250 has been successful on two fronts. First, it has proven feasible, albeit challenging, to offer this somewhat technology-intensive course on a shoestring budget. Second, in addition to the Information System majors who are required to take D250, a diverse group of non-majors are taking the course as an elective. Guided in part by the advice presented, a similar course could be implemented by other schools.
Checkmate
Authors: Pike Scott M. , Weide Bruce W. , Hollingsworth Joseph E.
Published: July 2004

Pointer errors are stumbling blocks for student and veteran programmers alike. Although languages such as Java use references to protect programmers from pointer pitfalls, the use of garbage collection dictates that languages like C++ will still be used for real-time mission-critical applications. Pointers will stay in the classroom as long as they're used in industry, so as educators, we must find better ways to teach them. This paper presents
checked pointers
, a simple wrapper for C++ pointers that prevents pointer arithmetic and other common sources of pointer errors, and detects all dereferencing and deallocation errors, including memory leaks. The syntax of checked pointers is highly faithful to raw C++ pointers, but provides run-time error detection and debugging information. After debugging, changing one #include is all that is required to substitute a non-checking implementation that is as fast as raw C++.
Enhancing student learning through on-line quizzes
Authors: Woit Denise , Mason Dave
Published: July 2004

We have experimented with the use of weekly on-line quizzes to enhance student learning in our first-year computer science courses. In our experiments we compared the effectiveness of using quizzes to the alternative of using weekly marked laboratory assignments. The results of our experiments show that student learning and retention increase with on-line quizzes. Weekly quizzes would be impossible if they were administered and marked in the traditional fashion; thus, we developed and used a secure, online environment for administering, writing, and marking the quizzes, with most of the marking performed automatically via simple marking programs. In this paper we describe our experiment, present our observations about student learning, outline student opinion, relate problems we encountered and our solutions, and provide technical details of our closed-quiz and marking environment.
Assessing the benefits of interactive prediction using Web-based algorithm animation courseware
Authors: Jarc Duane J. , Feldman Michael B. , Heller Rachelle S.
Published: July 2004

This study used educational software—courseware—that contained algorithm animations and data structure visualizations that were implemented with the programming language Java, and were embedded in a collection of World Wide Web pages. The objective of this study was to determine whether the interactive prediction facility provided by this courseware produced a significant learning advantage. Two experiments were conducted. The results indicated that the students who used the interactive version of the courseware spent significantly more time using it than those who used the noninteractive version. Students who used the interactive version scored better on several of the questions that tested the more difficult lessons, but performed more poorly overall. None of the differences were statistically significant.
Future faculty development seminar in ethics, social impact and alternative teaching strategies (seminar session)
Authors: Lee John A. N. , Bowyer Kevin
Published: July 2004

This seminar/workshop on ethics and the social impact in computer science, supported by studies of the applicability of alternative teaching and learning strategies, is targeted towards doctoral candidates in computer science whose life-goal is to teach in a university or college setting. Based on the concept of “ethics across the curriculum” the seminar/workshop will prepare future faculty to incorporate ethical and social impact concerns in their technical courses. At the same time they will be exposed to modern teaching and learning techniques that will assist them in making a good start in their teaching careers.
Report on a workshop on software change and evolution
Authors: Rajlich V. T. , Rank S. , Wilde N. , Bennett K. H.
Published: July 2004

This paper provides a brief overview and report on the main out-comes of the software change and evolution (SCE99) workshop held in Los Angeles on May 17, 1999, as part of the International Conference on Software Engineering 1999.The purpose of the workshop was to gather the most active of researchers and practitioners in the field of software evolution and change. The overall conclusion of the workshop was that this is a topic of enormous importance to industry, and there is a growing community of both practitioners and researchers who are working in the field. It would therefore make sense to arrange further workshops to support this expanding community.
Specification formalisms for component-based concurrent systems
Authors: Cleaveland Rance
Published: July 2004

This project builds on my ongoing research into design formalisms for, and the automatic verification of, concurrent systems. The difficulties such systems pose for system engineers are well-known and result in large part from the the complexities of process interaction and the possibilities for nondeterminism. My work is motivated by a belief that mathematically rigorous specification and verification techniques will ultimately lead to better and easier-to-build concurrent systems.My specific research interests lie in the development of fully automatic analysis methods and process-algebraic design formalisms for modeling system behavior. I have worked on algorithms for checking properties of, and refinement relations between, system descriptions [CH93, CS93]; the implementation and release of a verification tool, the CWB- NC [CS96] (see http://www.cs.sunysb.edu/~rance to obtain the distribution); case studies [BCL99, ECB97]; and the formalization of system features, such as real time, probability, and priority, in process algebra [BCL99, CDSYar].The aims of this project include the development of expressive and usable formalisms for specifying and reasoning about properties of
open, component-based
concurrent systems. More specifically, my colleagues and I have been investigating new approaches for describing component requirements and automated techniques for determining when finite-state components meet their requirements. The key topics under study include the following.
A temporal logic for open systems.
We are working on a notation for conveniently expressing properties constraining the behavior of open systems.
Implicit specifications.
Implicit specifications
use system
contexts,
or "test harness," to define requirements for open systems. We are studying expressiveness issues and model-checking algorithms for such specifications.
Automatic model-checker generation.
We have been developing a
model-checker generator
that, given a temporal logic and "proof rules" for the logic, automatically produces an efficient model checker.
The essence of objects
Authors: Pierce Benjamin C.
Published: July 2004

"The Essence of Objects" is an ongoing program of research in programming languages, type systems, and distributed programming at the University of Pennsylvania, supported by the National Science Foundation under Career grant CCR-9701826,
Principled Foundations for Programming with Objects.
Papers on most of the topics discussed in this outline can be found via http://www.cis.upenn.edu/bcpierce/papers.
Parallel and distributed execution of constraint programs
Authors: Pontelli Enrico
Published: July 2004

The goal of this research project is to study techniques and methodologies for execution of Constraint logic programs on parallel and distributed architectures. These models will be applied to implicit and explicit parallelization of complex and irregular symbolic applications, such as those arising in Natural Language Processing, Knowledge-based Systems, and Digital Libraries, and to provide novel frameworks for advanced World-Wide Web programming and coordination of software components.
Improving the design of interactive software
Authors: Redmiles David F.
Published: July 2004

This NSF sponsored CAREER project combines elements of research in human-computer interaction with research in software engineering. Three objectives are 1) to develop a model of software development as a process of on-going communication; 2) to support this model through active mechanisms in software tools; and 3) to improve the accessibility and acceptance of usability methods by software practitioners. In general, the objectives reflect a theory of
human-centered software development.
General strategies for dynamic reconfiguration
Authors: White Elizabeth L.
Published: July 2004

In recent years there has been a great deal of attention in the software engineering community on the development of techniques and tools that provide support for
dynamic reconfiguration,
the ability to make changes to a running application. The changes of interest include 1) adding/removing/moving components; 2) adding/removing bindings (communication channels); 3) changing the characteristics of the components or bindings. My work in this area has focused both on software support for dynamic reconfiguration of parallel applications and on frameworks and static software analysis techniques for determining the validity of component-level adaptations in the context of dynamic reconfiguration.
Reliability growth modeling from fault failure rates
Authors: Zeil Steven J.
Published: July 2004

A variety of reliability growth models provide quantified measures of test effectiveness in terms that are directly relevant to project management [Lyu96], but at the cost of restricting testing to
representative
selection, in which test data is chosen to reflect the operational distribution of the program's inputs. During testing, data is collected on the observed times between program failures (or, similarly, numbers of failures within a time interval). These observations are fitted to one of various models, which can then be used to estimate the current reliability of the program.
Evolutionary design of complex software (EDCS) demonstration days 1999
Authors: Stidolph Wayne
Published: July 2004

This report summarizes the Product/Technology demonstrations given at Defense Advanced Research Projects Agency (DARPA) Evolutionary Design of Complex Software (EDCS) Program Demonstration Days, held 28-29 June 1999 at the Sheraton National Hotel, Arlington, VA.
A whole new kind of engineering
Authors: Raccoon L. B. S.
Published: July 2004

There is a lot of momentum for software engineering to become a title act branch of engineering. A brochure from McMaster University (www.cas.mcmaster.ca/cas/undergraduate/SEbrochure.pdf, Fall 1999), reads, "At McMaster we have taken the position that software engineering is a branch of engineering and have applied well established principles of engineering education in this new specialty." And, the Texas Board of Professional Engineers is certifying software engineers as title act engineers, today. If other states follow then software engineering will become a title act branch of engineering by fiat.While I agree that software engineering resembles traditional engineering in many ways, I also believe that software engineering is a whole new kind of engineering that is equal to, parallel to, and independent of traditional engineering. I believe that if software engineers want to be licensed, they should recognize their unique reality and become licensed in a way that reflects this reality. Software engineers should be professionalized on their own terms, with their own regulatory structure. Software engineers should create a whole new kind of engineering, and not just follow the path trodden by traditional engineers.In the first section, I argue that software engineering is a real profession that stands on its own and that its culture differs substantially from that of traditional engineering. Software engineering is big: it counts nearly as many practitioners as traditional engineering; diverse: it has many areas of specialized practice; and enduring: it has grown steadily for more than fifty years. Every facet of software engineering, from technology to attitude to origins, differs from traditional engineering, which profoundly affects the culture of software engineering. Software engineering is not a branch of traditional engineering.In the second section, I argue that all-of-software-engineering-combined should resemble all-of-traditional-engineering-combined. Four kinds of traditional engineering regulation are practiced today that software engineering can emulate: unregulated, title-act, practice-act, and all-of-engineering-combined. Of these four kinds, title-act and all-of-engineering-combined are the most likely outcomes. There is a lot of momentum to regulate software engineering as a title-act branch of engineering. However, regulating software engineering like all-of-engineering-combined will give software engineers more control over their destiny, let them define their own identity and culture, wield their own power, and set their own curriculum and immigration policy.
Documentation testing
Authors: Mamone Salvatore
Published: July 2004

One definition of documentation is 'Any written or pictorial information describing, defining, specifying, reporting, or certifying activities, requirements, procedures, or results.' (1). Documentation is as important to a product's success as the product itself. If the documentation is poor, non-existent, or wrong, it reflects on the quality of the product and the vendor.At the Bell Atlantic Systems Integration & Testing Center documentation testing is an important function that receives as much attention as the testing of software and hardware. Because the Bell Atlantic Systems Integration & Testing Center is ISO9001 certified, an enormous effort was undertaken to ensure quality assurance of all products including documentation. Both a test procedure and test plan for documentation has been implemented to ensure this quality.This article will describe what documentation is, why document testing is important, and how document testing is performed at the Bell Atlantic Systems Integration & Testing Center.Other information pertaining to documentation, such as human factors, how to achieve document comprehensiveness, and comprehensibility, although important, are beyond the reach of this report.
A complementary approach to requirements engineering—software architecture orientation
Authors: Mei Hong
Published: July 2004

This paper presents the idea of Software Architecture Oriented Requirements Engineering, a complementary approach to existing requirements engineering processes and methods. The main objective is to introduce concepts and principles of software architecture into requirement analysis and requirement specification, supporting requirement reuse, traceability between requirement specifications and system design, and consistency in the whole software development process more effectively. The paper views connectors as the first-class entities in the problem space, not just in the solution space as most of current research on software architecture does, hence the connector recognition and specification are same important as component recognition and specification in requirements engineering. Based on this idea, the paper presents a new software development process and corresponding requirements engineering process, gives some guidelines for connector recognition, and borrows the notations of software architecture description to specify the functional and behavioural requirements at a high abstraction level. It must be pointed out that the approach presented in this paper is not a substitute for existing ones, but a complement to them from another perspective and at a different abstraction level.
Latency in distributed, sequential application designs
Authors: Ramaswamy Ramkumar
Published: July 2004

Despite advances in hardware, communications and software technology, latency remains a pressing problem for designers of distributed applications. Even after application functionality has been carefully distributed amongst multiple sites, there is the problem of the detailed design of client requests so that network trips are efficiently made. Most solution approaches (or compromises) for detailed design that are encountered in practice either tend to be ad-hoc, or are intended for use with a specific class of development environment, such as object-oriented languages. In this paper we take a fresh look at the problem of designing client requests in the presence of latency. We treat the client machine as a black box, thus ignoring the details of intra-machine communication and staying clear of specific environments such as OO. We propose a generic, intuitively appealing principle for the sequential design of client requests that allows a designer to systematically work around latency to meet response-time requirements. Applicability of this principle is shown using some simple but realistic examples of business transactions.
An object-oriented model of access control based on role
Authors: Han Yan , Fengyu Liu , Hong Zhang
Published: July 2004

At present, majority access control models mainly deal with data-protection at the back-end of applications. However, they are not applicable for large and complex multi-user applications. Though Object Technology has turned into one of the mainstream approaches for large and complex applications development, it still lacks a general model of application-level access control. While the existing models of role-based access control could simplify privilege management, they neglect the dynamic features of activated roles. This paper proposes an object-oriented model in Unified Modeling Language supporting application-level access control based on users' roles. In the model, an interface type is provided containing a set of operations as user services, which are authorized to users via their roles. To represent the activated roles, Role-Playing is introduced, and it is modeled as an active class. Every object of Role-Playing runs in particular context, which restrict users' rights dynamically and control users' interaction actively. The model is suitable for multi-user interactive computing and distributed information-processing systems.
Verisim
Authors: Bhargavan Karthikeyan , Gunter Carl A. , Kim Moonjoo , Lee Insup , Obradovic Davor , Sokolsky Oleg , Viswanathan Mahesh
Published: July 2004

Why are there so few successful "real-world" programming and testing tools based on academic research? This talk focuses on program analysis tools, and proposes a surprisingly simple explanation with interesting ramifications.

For a tool aimed at developers or testers to be successful, people must use it - and must use it to help accomplish their existing tasks, rather than as an end in itself. If the tool does not help them get their job done, or the effort to learn and/or use the tool is too great, users will not perceive enough value; the tool will not get significant usage, even if it is free.

This talk focuses on the often-overlooked consequences of this seemingly basic statement in two major areas: program analysis, and the work beyond core analysis that must be done to make a successful tool. Examples will be drawn from tools that have been successfully used in industry (sold commercially, and developed for internal use).
Automated Testing of Classes
Authors: Buy Ugo , Orso Alessandro , Pezze Mauro
Published: July 2004

Programs developed with object technologies have unique features that often make traditional testing methods inadequate. Consider, for instance, the dependence between the state of an object and the behavior of that object: The outcome of a method executed by an object often depends on the state of the object when the method is invoked. It is therefore crucial that techniques for testing of classes exercise class methods when the method's receiver is in different states. The state of an object at any given time depends on the sequence of messages received by the object up to that time. Thus, methods for testing object-oriented software should identify sequences of method invocations that are likely to uncover potential defects in the code under test. However, testing methods for traditional software do not provide this kind of information.

In this paper, we use data flow analysis, symbolic execution, and automated deduction to produce sequences of method invocations exercising a class under test. Since the static analysis techniques that we use are applied to different subproblems, the method proposed in this paper can automatically generate information relevant to testing even when symbolic execution and automated deduction cannot be completed successfully.
Classification schemes to aid in the analysis of real-time systems
Authors: Kolano Paul Z. , Demmerer Richard A.
Published: July 2004

This paper presents three sets of classification schemes for processes, properties, and transitions that can be used to assist in the analysis of real-time systems. These classification schemes are discussed in the context of ASTRAL, which is a formal specification language for real-time systems. Eight testbed systems were specified in ASTRAL, and their proofs were performed to determine proof patterns that occur most often. The specifications were then examined in an attempt to derive specific characteristics that could be used to statically identify each pattern within a specification. Once the classifications were obtained, they were then used to provide systematic guidance for analyzing real-time systems by directing the prover to the proof techniques most applicable to each proof pattern. This paper presents the set of classification schemes that were developed and discusses how they can be used to assist the proof process.
Which pointer analysis should I use?
Authors: Hind Michael , Pioli Anthony
Published: July 2004

During the past two decades many different pointer analysis algorithms have been published. Although some descriptions include measurements of the effectiveness of the algorithm, qualitative comparisons among algorithms are difficult because of varying infrastructure, benchmarks, and performance metrics. Without such comparisons it is not only difficult for an implementor to determine which pointer analysis is appropriate for their application, but also for a researcher to know which algorithms should be used as a basis for future advances.

This paper describes an empirical comparison of the effectiveness of five pointer analysis algorithms on C programs. The algorithms vary in their use of control flow information (flow-sensitivity) and alias data structure, resulting in worst-case complexity from linear to polynomial. The effectiveness of the analyses is quantified in terms of compile-time precision and efficiency. In addition to measuring the direct effects of pointer analysis, precision is also reported by determining how the information computed by the five pointer analyses affects typical client analyses of pointer information: Mod/Ref analysis, live variable analysis and dead assignment identification, reaching definitions analysis, dependence analysis, and conditional constant propagation and unreachable code identification. Efficiency is reported by measuring analysis time and memory consumption of the pointer analyses and their clients.
Simplifying failure-inducing input
Authors: Hildebrandt Ralf , Zeller Andreas
Published: July 2004

Given some test case, a program fails. Which part of the test case is responsible for the particular failure? We show how our
delta debugging
algorithm generalizes and simplifies some failing input to a
minimal test case
that produces the failure.

In a case study, the Mozilla web browser crashed after 95 user actions. Our prototype implementation automatically simplified the input to 3 relevant user actions. Likewise, it simplified 896~lines of HTML to the single line that caused the failure. The case study required 139 automated test runs, or 35 minutes on a 500 MHz PC.
Finite state verification (abstract only)
Authors: Clarke Lori A.
Published: July 2004

Ever since formal verification was first proposed in the late sixties, the idea of being able to definitively determine if a program meets its specifications has been an appealing, but elusive, goal. Although verification systems based on theorem proving have improved considerably over the years, they are still inherently undecidable and require significant guidance from mathematically astute users. The human effort required for formal verification is so significant that it is usually only applied to the most critical software components.

Alternative approaches to theorem proving based verification have also been under development for some time. These approaches usually restrict the problem domain in some way, such as focusing on hardware descriptions, communication protocols, or a limited specification language. These restrictions allow the problem to be solved by using reasoning algorithms that are guaranteed to terminate and by representing the problem with a finite state model, and thus these approaches have been called finite state verification. Systems based on these approaches are starting to be effectively applied to interesting software systems and there is increasing optimism that such approaches will become widely applicable.

In this presentation, I will overview some of the different approaches to finite state verification. In particular I will describe symbolic model checking, integer necessary constraints, and incremental data flow analysis approaches. The strengths and weaknesses of these approaches will be described. In addition, I will outline the major challenges that must be addressed before finite state verification will become a common tool for the typical well-trained software engineer.
Black-box test reduction using input-output analysis
Authors: Schroeder Patrick J. , Korel Bogdan
Published: July 2004

Test reduction is an important issue in black-box testing. The number of possible black-box tests for any non-trivial software application is extremely large. For the class of programs with multiple inputs and outputs, the number of possible tests grows very rapidly as combinations of input test data are considered. In this paper, we introduce an approach to test reduction that uses automated input-output analysis to identify relationships between program inputs and outputs. Our initial experience with the approach has shown that it can significantly reduce the number of black-box tests.