bluuebunny/crossref_metadata_2025 huggingface dataset:
Creating an authentic learning experience in introductory programming courses
Authors: Herrmann Nira , Popyack Jeffrey L.
Published: July 2004

We have developed an integrated, software-based course in scientific and statistical programming consisting of an introduction to computer programming and data analysis concepts. This course is being taught in an innovative way to non-majors: “stretched” over two quarters rather than taught in a single term. Classes meet in a computer classroom so students have a seamless lecture/laboratory experience to reinforce the concept that the computer should be made use of whenever needed, rather than only at specified lab times.

In addition to presenting key programming and data analysis concepts, we are giving the course an applied research focus to illustrate to students the importance and utility of programming and statistical concepts totheir own fields. This focus provides motivation for students to learn material they often perceive to be difficult and not relevant to them. It also provides a mechanism for addressing the increasing perception of faculty in a variety of technological fields that many students have problems with abstraction, the use of symbolic notation to understand or express ideas (e.g., through mathematical models), the interpretation of graphical information, and written communication, since all of these skills are needed in applied research.

The software-based approach to teaching programming concepts dovetails nicely with the applied research orientation of the course in that the software we use is widely applicable to a variety of activities, from word-processing to data handling and analysis.
Restructuring the introductory computer science course for engineers
Authors: Lambert Joseph M.
Published: July 2004

In Engineering curricula, the introductory course in computer science is an essential component of the lower division preparation of all engineers. Unfortunately, there is absolutely no consensus what should be included in an introductory computer science course for engineers. Moreover, limited energy has been given by the departments who deliver this introductory course to the currency and vitality of the course.

The focus of this paper is to promote a discussion regarding the design and implementation of a three credit course that meets the overriding concerns voiced by Engineering faculties and by students who enroll in the courses. We present a prototype of a course that addresses the concerns of language preference expressed by Engineering faculty as well as their concern regarding the selection of the ever changing software packages to be presented to the students.

Our design presents a course that will challenge all students regardless of their background in computing. This course would set in place a continuing mechanism to insure relevancy of the course to the students.
A three paradigm first course for CS majors
Authors: Reinfelds Juris
Published: July 2004

This paper presents a curriculum designed for a two semester foundation course for Computer Science majors. Our course distributes the widely accepted basic toolbox of algorithms and data structures over functional, logic and imperative programming. In this way the programming paradigm becomes a problem solving tool instead of a monolingual impediment to a wider view of problem solving patterns. A strong laboratory component is essential for the success of this approach.
Executing an SECD machine using logic programming
Authors: Slonneger Ken
Published: July 2004

Students usually find formal methods of describing programming languages very difficult because of the cryptic notation, the complexity of the techniques, and the size of the specifications. The SECD abstract machine provides a small but clear description of the operational semantics of the lambda calculus. By implementing the SECD machine in Prolog, we give students a tool for testing specifications and for experimenting with alternate language semantics in an interactive setting.
Enhancing generic skills in the computer organization course
Authors: Fekete Alan
Published: July 2004

Universities have always claimed that as well as educating students in particular content, they have “developed the students' minds”. A current trend is asking instructors to justify this claim, by ensuring that students have “generic skills” that are useful in all fields. Examples include communication skills, flexibility to apply their understanding to new situations as they arise, problem-solving skills, ability to transfer concepts between domains, and capacity to evaluate alternatives and provide reasoned explanations for their choices. This paper describes a course which covers most of the material from a typical computer organization or systems programming course, but uses closed laboratories in ways that enhance the students' generic skills as well as their expertise in the technical material.
Introducing formal methods through role-playing
Authors: Dean Neville , Hinchey Michael G.
Published: July 2004

By acting as a client, the instructor in a formal methods course can interact with students to develop general attitudes and skills, particularly modeling skills. The students learn to appreciate that formal methods comprise a range of tools and ideas which can greatly enhance software development at all stages, especially in requirements capture. A realistic case study is used which does not depend on an over-simplified file processing system.
Integrating a formal specification course with a software projects course via an editing tool
Authors: Gamble R. F.
Published: July 2004

This paper reports on a two-course sequence for undergraduate students that provides them with an intensive course in formal specification methods and a traditional software design course. The specification course provides an appreciation for the use of rigorous specification methods within the software lifecycle. The manual nature of developing a formal specification provides the appropriate justification for the projects in the software design course in which the students create useful tools to aid the development of a formal specification. Within the project course, the students developed the first prototype of a graphical editor for building Z specifications. We discuss the building of the editing tool and its integration into the software engineering curriculum.
Modula-2 versus C++ as a first programming language—some empirical results
Authors: Hitz Martin , Hudec Marcus
Published: July 2004

The success of an experiment of using C++ as a first programming language for students of a specific type of computer science is presented.

The paper motivates the shift from Modula-2 to C++ in the curriculum, shortly describes the course and discusses the statistical evaluation of the results of the last Modula-2 course and the first C++ course, respectively.

The main findings of the study are the fact that in contrast to most expectations, the shift from a typical “educational” language to a much “dirtier” language had no significant effect to the performance of the students taking the course.
Logic programming based curriculum for high school students
Authors: Scherz Zahava , Haberman Bruria
Published: July 2004

Logic programming and AI based courses have been taught during the last few years to Israeli high school students as part of a computer science curriculum. A special curriculum aimed at teaching concepts of logic programming and AI principles, using Abstract Data Types (ADTs) in Prolog environment was developed in the Weizmann Institute of Science. This curriculum is based on a flexible instructional model according to which the processes of problem solving and knowledge representation are carried out through several main phases while using ADTs. The flexibility of the model is achieved by encapsulating the ADTs' implementation in distinct computer programs. The curriculum was successfully implemented in Israeli high schools and was found to be suitable for a wide range of students.
TIC-TAC-TOE
Authors: Pilgrim Robert A.
Published: July 2004

Machines that play simple games have been a part of the development and promotion of computers for years. Charles Babbage conceived of a machine to play tic-tac-toe in an effort to obtain funding for his Analytical Engine. As part of the Summer Computer Science Workshop, participants design and implement a rule base for an expert system that plays the game of X's and O's (tic-tac-toe). This simple game was selected because most middle school age students are already domain experts. The participant has to select and order six or fewer rules with a seventh catch-all rule, “Take any available position.” The designers debug their own expert systems by playing the game and modifying their rule bases. Once they are satisfied with thier own design, they play against each other's expert systems in a round-robin tournament.

The development environment, written in Pascal to run under MS-DOS, displays the current state of the game board and lists the rules with the most recently “fired” rule being highlighted. This program is far from a complete expert system, but it does illustrate a number of principles of expert systems design.

Like most expert systems, a reasonable solution to the tic-tac-toe problem can be embodied in a surprisingly small rule base. No more than seven rules are needed to play a perfect game of tic-tac-toe, and the same rule base is valid whether the opponent or the computer makes the first move.
Laboratory projects for promoting hands-on learning in a computer security course
Authors: Huss Janice E.
Published: July 2004

This paper describes two laboratory projects which were developed for use in a computer security course. The first project requires that students examine and analyze an existing computer network environment in order to find security flaws. A sample network environment containing numerous flaws was developed for this purpose. The second project requires students to analyze the security needs of a hypothetical college with respect to its academic computing network and establish a secure computing environment which meets those needs. The environment for both projects consisted of a network of IBM compatible computers running Artisoft's LANtastic Network Operating System for DOS.
Transparent running and contextual help to learn and to teach an imperative language
Authors: Brette Jean-François
Published: July 2004

This paper presents the design choices and the realization of an imperative programming learning tool. This tool follows a Guided Discovery Learning line and is concentrated on the dynamic processes. On the one hand, transparent runnings enable a better understanding of the roles of the variables: proper reactive interfaces will help the student to compare his own conceptions with the actual behavior of the program. On the other hand, a contextual 'intelligent' help on types constraint errors highlights the domain structuration through different suggestions of the system.
A gentle introduction to algorithm complexity for CS1 with nine variations on a theme by Fibonacci
Authors: Martín-Sánchez Óscar , Pareja-Flores Cristóbal
Published: July 2004

In this paper, we propose our ideas about didactic methods and a few examples appropriate to motivate in students the comprehension of the basic principles related to algorithm complexity. Emphasis is put on avoiding formalisms and presenting gradually every new concepts. This paper as well provides for both: an organisation of these ideas and a collection of, we hope, useful examples and experiences that show these concepts in a natural way.
A programming project
Authors: Klemetti Harri , Lapinleimu Ismo , Mäkinen Erkki , Sieranta Mika
Published: July 2004

Graph drawing problems provide excellent material for programming projects. As an example, this paper describes the results of an undergraduate project which dealt with hypergraph drawing. We introduce a practical method for drawing hypergraphs. The method is based on the spring algorithm, a well-known method for drawing normal graphs.
Integrative assignments for CS1 and CS2 through libraries of abstract data types
Authors: Gojenola Koldo , Pérez Tomás A. , Jaime Arturo
Published: July 2004

As a way to avoid quick student concentration on implementation and computer language issues we have elaborated an integrative set of programming assignments for CS1 and CS2 courses.Our strategy relies on a top-down methodology to develop programming skills and problem-solving capabilities through the use of libraries with high-level Abstract Data Types (ADT). In a first medium-size assignment the novice programmer experiences high-level modular programming, and at a later stage the student is addressed to lower-level programming and data structure concerns.Ada has been used as the programming language, mainly because of its built-in capabilities to use and define reusable libraries of ADTs.Results indicate that this arrangement of assignments successfully reinforces the learning of fundamental concepts such as program design, modularity, testing techniques and increases student satisfaction.
Attitudes toward the teaching of formal methods of software development in the undergraduate computer science curriculum
Authors: Palmer Thomas V. , Pleasant James C.
Published: July 2004

This paper reports on a survey related to current views concerning the feasibility and importance of teaching formal methods of software development at the undergraduate level. Principle areas of interest considered include formal logic, formal specification, and formal proofs of correctness of programs. After alluding to several points of contact with current literature on this topic, the paper reports on a questionnaire designed by the authors that was mailed to computer science departments of selected colleges and universities in the United States and Canada. The principle goal of the survey is to determine attitudes of computer science faculty concerning the teaching of formal methods at the undergraduate level.
Software development using domain-specific software architectures
Authors: Taylor Richard N. , Tracz Will , Coglianese Lou
Published: July 2004

The objective of software development using domain-specific software architectures (DSSA) is reduction in time and cost of producing specific application systems within a supported domain, along with increased product quality, improved manageability, and positioning for acquisition of future business. Key aspects of the approach include software reuse based on parameterization of generic components and interconnection of components within a canonical solution framework. Viability of the approach depends on identification and deep understanding of a selected domain of applications. The DSSA approach, to be effectively applied, requires a variety of support tools, including repository mechanisms, prototyping facilities, and analysis tools. This curriculum module describes the DSSA approach, representative examples, supporting tools, and processes.
A reengineering framework for small scale software
Authors: Philip Thomas , Ramsundar Ramani
Published: July 2004

Reengineering software is approached in different ways, even though the basic process remains the same: reverse engineering followed by forward engineering. Tools are available to aid during reverse engineering and reengineering. This paper presents a framework we used to reengineer a small scale software system from a partial structured implementation to an object-oriented implementation. The framework uses function matrix to organize the extracted abstractions, algorithm tables, and data dictionary during its initial phase. Components for the target system object model are retrieved from the matrices and the dictionary. An empirical reuse metric was applied to the matrix to identify reusable parts. Application of this framework is also discussed.
On ICSE's “most influential” papers
Authors: Parnas David Lorge
Published: July 2004

The International Conference on Software Engineering has established a tradition of looking back 10 conferences and selecting papers that have stood the test of time. The remarks below were prepared in connection an acceptance speech at ICSE 17 where two colleagues and I received the award for the best paper of ICSE 7.
DSSA (Domain-Specific Software Architecture)
Authors: Tracz Will
Published: July 2004

A Domain-Specific Software Architecture (DSSA) has been defined as:• "an assemblage of software components, specialized for a particular type of task (domain), generalized for effective use across that domain, composed in a standardized structure (topology) effective for building successful applications" [Hay94] or, alternately• "a context for patterns of problem elements, solution elements, and situations that define mappings between them [Hid90].The following small example illustrates these definitions as well as provides the reader with some insight into the types of processes and tools needed to support the creation and use of a DSSA.
Architectural issues in software reuse
Authors: Shaw Mary
Published: July 2004

Effective reuse depends not only on finding and reusing components, but also on the ways those components are combined. The informal folklore of software engineering provides a number of diverse styles for organizing software systems. These styles, or architectures, show how to compose systems from components; different styles expect different kinds of component packaging and different kinds of interactions between the components. Unfortunately, these styles and packaging distinctions are often implicit; as a consequence, components with appropriate functionality may fail to work together. This talk surveys common architectural styles, including important packaging and interaction distinctions, and proposes an approach to the problem of reconciling architectural mismatches.
Confessions of a used-program salesman
Authors: Tracz Will
Published: July 2004

Software reuse is the second oldest programming profession. Ever since the first program logic board was wired, people have been looking for ways of saving time and money by building upon other's efforts and not “not re-inventing any wheels.” This article summarizes the lessons I have learned as used-program salesman. Using this analogy, I will examine efforts made to institutionalize software reuse.
Building reusable components in the public administration domain
Authors: Castano S. , Antonellis V. De , Pernici B.
Published: July 2004

The paper proposes methods and tools for building reusable components from families of Information System conceptual schemas, based on the identification of similar components in different schemas, and on their engineering into normalized descriptions. Clustering and abstraction techniques to help identifying similar components, and techniques to build corresponding reusable components are described in the paper.
Formal specification of reusable interface objects
Authors: Alencar P. S. C. , Cowan D. D. , Lucena C. J. P. , Nova L. C. M.
Published: July 2004

In this paper we present a formal approach of a new object-oriented design concept to support reuse-in-the-large called Abstract Data Views (ADVs). The ADV approach was created to specify clearly and formally the separation of interfaces from the application components of a software system. Such an approach should lead to high degree of reuse of designs for both interface and application components.

Our specification framework is based on descriptive schemas for both ADVs and ADOs, that are the basic building blocks for the system specification, design, and implemention using the ADV approach. These schemas describe the structural, static, and dynanmic features of each system object, and include the specification of the concurrent operation of system components. Additionally, such schemas can be seen as an underlying structure to support the development of a specification language that describes the interconnection between interface and application components.
Reuse dimensions
Authors: Dusink Liesbeth , van Katwijk Jan
Published: July 2004

In recent years, there have been much publications on reuse. In order to bet an overview of the whole field and also a good impression of the state of the reuse art, we studied reuse literature of the last few years. As basis for comparison, we classified literature according to four (more or less orthogonal) dimensions, based on the actions and knowledge of the reuser, i.e. the software engineer. The dimensions are: actions to be taken to get an existing reusable item; knowledge to be applied to find an existing reusable item; actions to be taken to build the complete system needed; knowledge to be applied to get the complete system needed.

The survey shows that research on reuse from the viewpoint of needed system, receives far less attention than research from the viewpoint of reusable artifacts. We expect reuse to live up to its promise if this topic is addressed was well.
A hybrid approach to software reuse
Authors: Bhansali Sanjay
Published: July 2004

We describe a hybrid approach to software reuse in an ongoing project that addresses a challenging software engineering task. The approach is driven by an architectural design and makes use of both code components and program synthesis technology. We describe criteria that were used in choosing the reuse strategy for different parts of the application and argue that to be successful a reuse strategy must be driven by the needs of an application program instead of adapting a software development strategy around a reuse program.
Research directions in software reuse
Authors: Gall Harald , Jazayeri Mehdi , Klösch René
Published: July 2004

Software reuse is no longer in its infancy. We are able to look back at more than 15 years of research and should use the opportunity of such a symposium to critically evaluate the past research in order to identify promising future research areas in software reuse.

In this paper, we give a broader view of reuse and some of the so far less-considered areas, which we believe may support software reuse to get off the ground. We mention our ongoing research in software reuse, discussing reuse experiments in the areas of long-term software evolution and component programming.

Furthermore, we indicate the critical importance of interactions among the reuse and related communities within software engineering, such as the object-oriented and the software maintenance communities.
Exploiting domain architectures in software reuse
Authors: Gacek Cristina
Published: July 2004

This paper provides motivation towards the use of domain specific repositories and DSSA's. It shows many of the positive side-effects this usage brings about.

An extension to the faceted approach to components classification [Prieto-Diaz and Freeman 1987] is introduced. Our extension suggests a natural way of further benefiting from the use of domain specific repositories.
Cohesion and reuse in an object-oriented system
Authors: Bieman James M. , Kang Byung-Kyoo
Published: July 2004

We define and apply two new measures of object-oriented class cohesion to a reasonably large C++ system. We find that most of the classes are quite cohesive, but that the classes that are reused more frequently via inheritance exhibit clearly lower cohesion.
A methodology for high-level software specification construction
Authors: Jing Ying , Zhijun He , Zhaohui Wu , Jiangyun Li , Weicheng Fan , Zhaohui Xu
Published: July 2004

This paper puts forward a kind of novel methodology for software system development, from the point of view of the problem existed in software development -- the gap between the requirement specification level and the program implementation level. We attempt to begin from the specification level of software development to touch the process of high-level specification construction profoundly. We propose a specification language to support multiple semantic dimensions and based on which build a unified functional model of software system in a specific domain. On the bases of these, we apply transformation and refinement methods to the model and transit it from the specification level to the implementation level. We expect such a process can change the current software producing procedure in nature. We also put this methodology into the application of the software development in real-time serving domain we focus on, which turns out to be encouraging.
Towards a conceptual framework for object oriented software metrics
Authors: Churcher Neville I. , Shepperd Martin J.
Published: July 2004

The development of software metrics for object oriented (OO) languages is receiving increasing attention. We examine the reasons why this is a much more challenging problem than for conventional languages. It seems premature to develop and apply OO metrics while there remains uncertainty not only about the precise definitions of many fundamental quantities and their subsequent impact on derived metrics, but also a lack of qualitative understanding of the structure and behaviour of OO systems. We argue that establishing a standard terminology and data model will help provide a framework for both theoretical and empirical work and increase the chances of early success. One potential benefit is improvement of the ability to perform independent validation of models and metrics. We propose a data model and terminology and illustrate the importance of such definitions by examining the seemingly straightforward concept of the number of methods per class. We discuss the implications of ambiguities in definitions for a suite of metrics which has recently been proposed. Preliminary results from our analysis of industrial systems are presented.
Models and languages for component description and reuse
Authors: Whittle Ben
Published: July 2004

This paper brings together the current research on reusable component models and component description languages for reuse. The paper contains a description and comparison of the 3C and REBOOT component models. The importance and further development of the 3C model is discussed. The component description language field is surveyed, and an introduction is given to the languages LIL, ACT TWO, Π, Meld, CDL, CIDER, LILEANNA, and RESOLVE. All of these languages are aimed at describing reusable components in the design stages of development. Criteria for examining component description languages are introduced and used as the basis of a comparison of the languages. The paper concludes with suggestions for the convergence of these developments, and suggestions for further work in this field.
Workshop summary first international workshop on requirements engineering
Authors: Pohl Klaus , Starke Gernot , Peters Peter
Published: July 2004

As achieving high quality means the realization of customers needs, requirements engineering (RE) is the most crucial phase within software development. In the RE process not only the functional requirements but also the so-called 'non-functional' or 'quality' requirements of the planned software system have to be elicited from the customer and represented in a requirements document in order to provide the software designer a complete and correct specification. Conventional RE methods usually support only parts of this process or help stating only specific kinds of requirements.These methodological problems were the prime motivation for the REFSQ'94 workshop held in conjunction with the CAiSE '94 Conference on Advanced Information Systems Engineering in Utrecht, The Netherlands on June 6th and 7th 1994. In order to find solutions which handle the described deficiencies, it was the goal of the workshop to improve the understanding of the relations between both areas of research in software engineering and not to give new definitions of either requirements engineering or software quality.On the Call for Papers addressing the above problems we received 24 submissions. After the reviewing process, we accepted 14 papers which have high quality and cover the research areas related to the workshop. Finally, 13 full and position papers were presented at REFSQ '94 and discussed with the 23 participants (including the organizers) coming from eleven different countries.
Daistish
Authors: Hughes Merlin , Stotts David
Published: July 2004

Daistish is a tool that performs systematic algebraic testing similar to Gannon's DAISTS tool [2]. However, Daistish creates effective test drivers for programs in languages that use side effects to implement ADTs; this includes C++ and most other object-oriented languages. The functional approach of DAISTS does not apply directly in these cases. The approach in our work is most similar to the ASTOOT system of Doong and Frankl [1]; Daistish differs from ASTOOT by using Guttag-style algebraic specs (functional notation), by allowing aliasing of type names to tailor the application of parameters in test cases, and by retaining the abilities of DAISTS to compose new test points from existing ones. Daistish is a Perl script, and is compact and practical to apply. We describe the implementation and our experiments in both Eiffel and C++. Our work has concentrated on solving the semantics-specific issues of correctly duplicating objects for comparison; we have not worked on methods for selecting specific test cases.Daistish consists of a perl script and supporting documentation. The current distribution can be obtained via WWW at URLhttp://www.cs.unc.edu/~stotts/Daistish/
Unconstrained duals and their use in achieving all-uses coverage
Authors: Marré Martina , Bertolino Antonia
Published: July 2004

Testing takes a considerable amount of the time and resources spent on producing software. It would therefore be useful to have ways 1) to reduce the cost of testing and 2) to estimate this cost. In particular, the
number of tests
to be executed is an important and useful attribute of the entity "testing effort".
All-uses coverage
is a data flow testing strategy widely researched in recent years. In this paper we present
spanning sets of duas
for the all-uses coverage criterion. A spanning set of duas is a minimum set of duas (definition-use associations) such that a set of test paths covering them covers every dua in the program. We give a method to find a spanning set of duas using the relation of subsumption between duas. Intuitively, there exists a natural ordering between the duas in a program: some duas are covered more easily than others, since coverage of the former is automatically guaranteed whenever the latter are covered. Those duas that are the most difficult to be covered according to this ordering are called
unconstrained.
A spanning set of duas is composed of unconstrained duas. Our results are useful for reducing the cost of testing, since the generation of test paths can be targeted to cover the smaller spanning set of duas, rather than all those in a program. On the other hand, assuming that a different path is taken to cover each dua in a spanning set, the cardinality of spanning sets can be used to estimate the cost of testing. Other interesting uses of spanning sets of duas are also discussed.
Software error analysis
Authors: Daran Murial , Thévenod-Fosse Pascale
Published: July 2004

The paper reports on a first experimental comparison of software errors generated by real faults and by 1st-order mutations. The experiments were conducted on a program developed by a student from the industrial specification of a critical software from the civil nuclear field. Emphasis was put on the analysis of errors produced upon activation of 12 real faults by focusing on the mechanisms of error creation, masking, and propagation up to failure occurrence, and on the comparison of these errors with those created by 24 mutations. The results involve a total of 3730 errors recorded from program execution traces: 1458 errors were produced by the real faults, and the 2272 others by the mutations. They are in favor of a suitable consistency between errors generated by mutations and by real faults: 85% of the 2272 errors due to the mutations were also produced by the real faults. Moreover, it was observed that although the studied mutations were simple faults, they can create erroneous behaviors as complex as those identified for the real faults. This lends support to the representativeness of errors due to mutations.
An approach to verification and validation of a reliable multicasting protocol
Authors: Callahan John R. , Montgomery Todd L.
Published: July 2004

This paper describes the process of implementing a complex communications protocol that provides reliable delivery of data in multicast-capable, packet-switching telecommunication networks. The protocol, called the Reliable Multicasting Protocol (RMP), was developed incrementally using a combination of formal and informal techniques in an attempt to ensure the correctness of its implementation. Our development process involved three concurrent activities: (1) the initial construction and incremental enhancement of a formal state model of the protocol machine; (2) the initial coding and incremental enhancement of the implementation; and (3) model-based testing of iterative implementations of the protocol. These activities were carried out by two separate teams: a design team and a V&V team. The design team built the first version of RMP with limited functionality to handle only nominal requirements of data delivery. In a series of iterative steps, the design team added new functionality to the implementation while the V&V team kept the state model in fidelity with the implementation. This was done by generating test cases based on suspected errant or off-nominal behaviors predicted by the current model. If the execution of a test was different between the model and implementation, then the differences helped identify inconsistencies between the model and implementation. The dialogue between both teams drove the co-evolution of the model and implementation. Testing served as the vehicle for keeping the model and implementation in fidelity with each other. This paper describes (1) our experiences in developing our process model; and (2) three example problems found during the development of RMP.
Towards a structural load testing tool
Authors: Yang Cheer-Sun D. , Pollock Lori L.
Published: July 2004

Load sensitive faults cause a program to fail when it is executed under a heavy load or over a long period of time, but may have no detrimental effect under small loads or short executions. In addition to testing the functionality of these programs, testing how well they perform under
stress
is very important. Current approaches to stress, or load, testing treat the system as a
black box,
generating test data based on parameters specified by the tester within an operational profile. In this paper, we advocate a
structural
approach to load testing. There exist many structural testing methods; however, their main goal is generating test data for executing all statements, branches, definition-use pairs, or paths of a program at least once, without consideration for executing any particular path extensively.Our initial work has focused on the identification of potentially
load sensitive
modules based on a static analysis of the module's code, and then limiting the stress testing to the regions of the modules that could be the potential causes of the load sensitivity. This analysis will be incorporated into a testing tool for structural load testing which takes a program as input, and automatically determines whether that program needs to be load tested, and if so, automatically generates test data for structural load testing of the program.
Compositional verification by model checking for counter-examples
Authors: Bultan Tevfik , Fischer Jeffrey , Gerber Richard
Published: July 2004

Many concurrent systems are required to maintain certain safety and liveness properties. One emerging method of achieving confidence in such systems is to statically verify them using
model checking.
In this approach an abstract, finite-state model of the system is constructed; then an automatic check is made to ensure that the requirements are satisfied by the model. In practice, however, this method is limited by the
state space explosion problem.
We have developed a compositional method that directly addresses this problem in the context of multi-tasking programs. Our solution depends on three key space-saving ingredients: (1) checking for counter-examples, which leads to simpler search algorithms; (2) automatic extraction of interfaces, which allows a refinement of the finite model --- even before its communicating partners have been compiled; and (3) using propositional "strengthening assertions" for the sole purpose of reducing state space.In this paper we present our compositional approach, and describe the software tools that support it.
A logic-model semantics for SCR software requirements
Authors: Atlee Joanne M. , Buckley Michael A.
Published: July 2004

This paper presents a simple logic-model semantics for Software Cost Reduction (SCR) software requirements. Such a semantics enables model-checking of native SCR requirements and obviates the need to transform the requirements for analysis. The paper also proposes modal-logic abbreviations for expressing conditioned events in temporal-logic formulae. The Symbolic Model Verifier (SMV) is used to verify that an SCR requirements specification enforces desired global requirements, expressed as formulae in the enhanced logic. The properties of a small system (an automobile cruise control system) are verified, including an invariant property that could not be verified previously. The paper concludes with a discussion of how other requirements notations for conditioned-event-driven systems could be similarly checked.
Separate computation of alias information for reuse
Authors: Harrold Mary Jean , Rothermel Gregg
Published: July 2004

Interprocedural dataflow information is useful for many software testing and analysis techniques, including dataflow testing, regression testing, program slicing and impact analysis. For programs with aliases, these testing and analysis techniques can yield invalid results, unless the dataflow information accounts for aliasing effects. Recent research provides algorithms for performing interprocedural dataflow analysis in the presence of aliases; however, these algorithms are expensive, and achieve precise results only on complete programs. This paper presents an algorithm for performing alias analysis on incomplete programs, that lets individual software components such as library routines, subroutines, or subsystems be independently analyzed. The paper also presents an algorithm for reusing the results of this separate analysis when linking the individual software components with calling modules. The primary advantage of our algorithms is that they let us analyze frequently used software components, such as library routines or classes, independently, and reuse the results of that analysis when analyzing calling programs, without incurring the expense of completely reanalyzing each calling program.
A strategy for mapping from function-oriented software models to object-oriented software models
Authors: George Joseph , Carter Bradley D.
Published: July 2004

Because of being in transition or because of choice, many software development environments make use of both the function-oriented and object-oriented approaches in their software development process. In some cases, object-oriented and function-oriented approaches are used in the development of the same system, such as when using function-oriented analysis with object-oriented design, necessitating a transition or mapping from one model to the other. This paper reviews the issues involved in mapping from a function-oriented software model to an object-oriented software model and presents a strategy for accomplishing the mapping in a consistent and partially automatable manner. The effectiveness of the strategy is assessed with four different applications drawn from the literature. It is concluded that the mapping strategy is feasible and reasonably automatable.
Teaching and learning essential computer science skills
Authors: Greening Tony
Published: July 2004

The sources of difficulty in learning particular concepts are not always identifiable by either the educators or the students. While the theme of this paper may initially be UNIX, this is used as a mechanism for discussing the main thrust of the paper, which is concerned with general issues relating to the teaching and learning process. Difficulties may arise which are inherent to the subject matter, a product of the teaching/learning experience, or as the result of existing misconceptions. Some of these factors are discussed in terms of the UNIX example, and generically in terms of a qualitative approach to teaching and learning. It makes a case for the adoption of a teaching perspective that addresses the student perception of their own learning.
A computer science freshman orientation course
Authors: Cook Curtis R.
Published: July 2004

This paper describes an orientation course for beginning computer science majors. The course is different from the CS 1 or computer literacy courses, but similar in intent and content to orientation courses in engineering, business, and other fields. Its purpose is to give students an overview of computer science and an idea of what computer professionals do so that students can make an informed career decision. Other emphases for the course are practice in problem solving, experience working in groups, teaching basic technical (non-programming) skills, social and ethical issues, and making students aware of the resources and opportunities available to them such as internship programs. Influences and constraints on the design of the course and suggested changes the next time the course is taught are also described.
A report on the Durham program transformations workshop
Authors: Bull Tim , Bennett Keith
Published: July 2004

A Workshop on Program Transformation Systems was held in the Centre for Software Maintenance at University of Durham on 1st and 2nd April 1996.The Workshop was intended as a follow up for the successful event held on the same topic at ICSE in Seattle in 1995. Twenty-three people attended the Workshop, and this is a short report on the proceedings.
Estimating understandability of software documents
Authors: Laitinen Kari
Published: July 2004

Software developers and maintainers need to read and understand source programs and other kinds of software documents in their work. Understandability of software documents is thus important. This paper introduces a method for estimating the understandability of software documents. The method is based on a language theory according to which every software document is considered to contain a language of its own, which is a set of symbols. The understandability of documents written according to different documentation practices can be compared using the rules of the language theory. The method and the language theory are presented by using source programs with different naming styles as example documents. The method can, at least theoretically, be applied to any kind of document. It can also be used to explain the benefits of some well-known software design methods.
Programming pedagogy—a psychological overview
Authors: Winslow Leon E.
Published: July 2004

Can we turn novices into experts in a four year undergraduate program? If so, how? If not, what is the best we can do? While every teacher has his/her own opinion on these questions, psychological studies over the last twenty years have started to furnish scientific answers. Unfortunately, little of these results have been incorporated into curricula or textbooks. This report is a brief overview of some of the more important results concerning computer programming and how they can affect course design.
Shaping the focus of the undergraduate curriculum
Authors: Paprzycki Marcin , Zalewski Janusz
Published: July 2004

This paper outlines an approach to reshape the existing undergraduate CS curriculum. Based on software engineering and parallel computing concepts, the details of the new curriculum are presented in terms of educational objectives, core courses, innovations in the teaching method, and early experiences.
A comparison of the model-based & algebraic styles of specification as a basis for test specification
Authors: Denney Richard
Published: July 2004

The use of formal specifications as a basis for specifying functional tests has been discussed by a numbers of researchers with most work focusing on one style of specification or another separately. But is any single style an adequate basis for writing functional tests? The strengths, weaknesses and complementary nature of two popular styles of software specification, model-based and algebraic, are examined as a basis for functional test specification.
A taxonomy of domain-specific reuse problems and their resolutions—version 1.0
Authors: Lam Wing , Whittle Ben
Published: July 2004

This paper presents a taxonomy of problems related to domain-specific reuse. The taxonomy identifies seven major problem categories (such as domain, modeling notation and viewpoints) and their sub-categories. A description of each problem in the taxonomy is given, illustrated where appropriate, with an example taken from an industrial case-study performed by the authors for Rolls-Smiths Engine Controls Limited (RoSEC). A resolution matrix is also presented, which suggests practical strategies for resolving each kind of problem described in the taxonomy.
The mathematical validity of software metrics
Authors: Henderson-Sellers B.
Published: July 2004

Mathematical modelling, especially in software engineering metrics, requires more emphasis to be placed on the validity of the selected mathematical tools and techniques to be used. There are a plethora of occurrences in the recent literature of the misapplication of quantitative techniques together with errors in the underlying mathematics. Software engineering metrics needs to take more care in its use of mathematics if it is to gain credence in the scientific and engineering communities.
An unlevel playing field
Authors: Sackrowitz Marian Gunsher , Parelius Ann Parker
Published: July 2004

This study looks at students in introductory computer science courses at two major universities in order to understand some of the reasons behind the recent sharp decline in the number of female computer science majors. The study focuses on gender differences in preparation and skills and the implications of these differences on success in the introductory course.The study showed that despite the proliferation of computers in many areas of daily life, female students still enter introductory computer science classes with weaker programming skills and less involvement with computers than their male counterparts.Prior familiarity with programming concepts emerged as the most useful predictor of success in the course and a high level of success was difficult to achieve without this prior knowledge. The mean grades were comparable for men and women but the women were underrepresented among the highest achievers.This study suggests that the above factors combine to place women at a disadvantage in introductory computer science classes and that some adjustments to the pace and/or structure of this course might be necessary to attract and retain more women in the major.
A system-based sequence of closed labs for computer systems organization
Authors: Parker Brenda C. , Drexel Peter G.
Published: July 2004

The closed-lab environment has been used successfully in the Computer Science curriculum. This paper proposes a set of laboratories, that combine the use of hands-on techniques and logic simulation. During a semester, students in Computer Systems Organization classes design and implement a working model of a complete system: OBC.
A software infrastructure to support introductory computer science courses
Authors: Reek Kenneth A.
Published: July 2004

This paper describes the software developed to support the first two years of the Computer Science curriculum at the Rochester Institute of Technology. The system supports student retrieval of files and data; on-line submission with immediate, automated testing and archiving of student work; and assists in grading the work and the associated record keeping.