bluuebunny/crossref_metadata_2025 huggingface dataset:
Providing a laboratory for instruction set design
Authors: Nerheim-Wolfe Rosalee
Published: July 2004

Computer architecture classes do not provide students with laboratory experience in the design of instruction set architectures. Projects that compare designs have not been possible due to a lack of support software. The design and evaluation of a new instruction set requires an assembler, a symbolic debugger, and a statistics gatherer. Every new instruction set requires changes to all three programs. It would be unrealistic to expect that either students or instructor would (re)write such software in order to evaluate each new design.

A new, flexible software package called the Instruction Set Testbed (IST) provides for the comparison of instruction set architectures without writing any of the support software. IST's table-driven assembler uses a student-supplied architecture definition to assemble programs. IST's interactive debugger and a statistics gatherer also have access to the architecture definition. This allows symbolic debugging of the assembly language programs and automatic histogramming of instruction usage in the student-defined architecture.

IST has been used in both undergraduate and graduate architecture classes to investigate such topics as orthogonality, choice and number of operands, addressing modes, and RISC philosophy.
A multi-disciplinary approach for digital systems design curricula
Authors: Neumann William T. , Woodfill Marvin C.
Published: July 2004

Historically, Digital Systems Design curricula have focused principally on the hardware design aspects of systems development. At Arizona State University, we have expanded our Digital Systems Design program to include aspects of computer architecture, assembly language programming, and operating systems fundamentals, as well. We feel that this larger focus provides the students with a comprehensive understanding of the overall system development process. In this paper, we discuss our philosophy and examine a course sequence that incorporates this multi-disciplinary approach.
An introductory course on the use of operating systems
Authors: Bareiss Catherine C.
Published: July 2004

One very frustrating problem that students often have while working on computers is the lack of ability to do productive work. They often find themselves either not being able to do something or doing it in a very complex way when there is a simpler or shorter way to accomplish the task. This is a common experience because most students do not have a structured time of learning the operating system(s) on which they work. This often occurs because the use of an operating system is not considered an academic pursuit so that a course teaching the computer science majors how to use the operating system(s) is not offered. However, the benefits of such a course can be great. The students can find the rest of their work on computers much more productive than if they had to pick up almost everything on their own.
A laboratory for building computers
Authors: Reid Richard J.
Published: July 2004

A workstation laboratory allows undergraduate students to build complete, functioning computers--in simulation. The simulation extends down to the gate and signal levels, with effective modeling of delays and transitions, so reasonable assurance of the validity of the designs can be obtained. The computers constructed in this laboratory are complete with peripheral equipment including tapes and disks, and the students furnish a rudimentary operating system. The student operating-systems receive executable binary objects on the tapes, transfer them to the disk, and initiate their execution. The executable objects and the operating system are produced by a standard C compiler. Students must limit their C-language source code and data types used so the compile binaries will be executable on the 16-bit wide, Motorola 680X0-like computer they construct. The computers are constructed in an hierarchical manner from the gates and medium-scale components available in the digital simulator used in this laboratory.
The evolution of the programming languages course
Authors: King K. N.
Published: July 2004

This paper examines the past, present, and future of the programming languages course as reflected by its textbooks.
Case studies in the classroom
Authors: Clancy M. J. , Linn M. C.
Published: July 2004

We and others have created
case studies
to engage students in the process of designing solutions to complex programming problems. Case studies involve learners in activities of expert programmers such as identifying decisions, justifying choices among alternatives, and evaluating the consequences of these choices. Case studies improve computer programming courses by emphasizing the process rather than the product of problem solving. This paper describes specific uses of case studies in freshman and sophomore-level courses.
Creating programming projects with visual impact
Authors: Robergé James
Published: July 2004

One of the challenges facing educators in computer science is to develop programming projects which not only engage students intellectually, but which also excite and motivate them. Given the highly visual orientation of today's students, if is important that we consider not only the conceptual underpinnings of our programming projects, but also their visual impact. This paper focuses upon a set of programming projects which use the traditional elements from a data structures course to produce visually engaging applications.
Learning HCI design
Authors: Hartfield B. , Winograd Terry , Bennett John
Published: July 2004

We describe the role of mentors in an experimental course on human-computer interaction (HCI) taught in the Computer Science Department at Stanford University for the past two years. Students practice design within the course by collaborating in small groups on 12-week projects, in which they analyze a work environment, design and implement a prototype user interface, and evaluate the prototype with project clients. As part of our experiment in providing contact with the world of practical design, we invited people from local industry to serve as mentors for the student groups. These unpaid volunteers have been important adjuncts in guiding students as they developed their HCI projects. We discuss: the background for the projects; the role of mentors in the learning process; what is required of mentors and what benefits they get; how to support the mentoring process; and what we have learned from the experience so far. We consider mentors to be a critical part of the design project within the course, and we welcome a sharing of experience with other people who may have developed similar courses where mentors played an important role.
Designing interactive visualization tools for the graphics classroom
Authors: Schweitzer D.
Published: July 2004

Student comprehension of the concepts and algorithms in computer graphics requires a thorough visual understanding of the processes involved. To assist this understanding in the computer graphics course at the Air Force Academy, a set of interactive visualization programs were created for classroom use. These programs demonstrate key graphic concepts using various visual metaphors. The process of creating and using these tools in the classroom highlighted several design guidelines when creating classroom visualization tools. This paper describes these design guidelines, and the way in which the tools are used in the classroom to support lecture material. The paper concludes with our experience using these tools and future plans.
Teaching computer graphics using RenderMan
Authors: Owen G. Scott
Published: July 2004

A computer graphics course is extremely hardware system dependent, even more than most computer science courses. To produce high quality graphics images requires a high resolution system with extensive color capability and a fast cpu. Fortunately, the computer graphics capabilities of inexpensive systems have continued to increase. As this trend continues we need to consider changing the way we teach our computer graphics courses. In this paper I discuss a major shift in my teaching methods in the past year. Whereas, previously my students developed their own programs to create images, I have switched to the use of the Pixar RenderMan graphics package in the second graphics course and use it at the end of the first graphics course. I will discuss the rational for this change, mine and the students' experiences with it, and future planned modifications of the courses.
Writing about programming in CS1
Authors: Curl L. A.
Published: July 2004

Students in CS1 were assigned to groups that met during class time to study one member's work on one complex programming problem. When the program was complete, each student wrote a paper describing various aspects of the program. The class response to the writing project was varied and intense.
Yet another analysis of algorithms laboratory
Authors: Epp Ed C.
Published: July 2004

Laboratory assignments can reinforce material given in lecture by making it come alive in practice. A prime example is the time complexity of algorithms. However, laboratories that confirm the time complexity of algorithms can be tedious exercises that do not really challenge a student to think about the algorithms they are testing. By giving students a set of unknown executables, the laboratory becomes more of a detective problem. Students are required to apply what they know about the sort algorithms so that they can identify them.
A geometric approach to presenting computer representations of integers
Authors: Benham James W.
Published: July 2004

The student's first serious exposure to computer arithmetic typically occurs in a sophomore course in machine architecture or assembler language. A glance at several excellent and widely used texts for these courses (for example [M], [Sh], [St], [T]) shows that this material is often presented as an unmotivated set of mechanical rules to, for example, add numbers using one's complement notation or compute the two's complement representation of a negative integer. This paper describes a way to motivate these topics by relating them to the computer's "natural " arithmetic.
Database and artificial intelligence integration
Authors: Taylor Pamela A. , Wyatt Dana L.
Published: July 2004

Database (DB) and Artificial Intelligence (AI) courses have been long-standing offerings in computer science curriculums. Due to the present-day need for "intelligent" databases and "knowledge-base" management systems, the technologies of database and artificial intelligence are increasingly being integrated in research. Academia can give recognition to this important movement toward integration. An approach to teaching database and artificial intelligence concepts emphasizing their capabilities, limitations, and the need for integrating their technologies is proposed. An introduction gives a brief history of past and current practices. Reasons why the current routine should be modified are discussed. State-of-the-art information concerning current research in this area is presented, and finally, a course outline is suggested.
Foundations for the study of software architecture
Authors: Perry Dewayne E. , Wolf Alexander L.
Published: July 2004

The purpose of this paper is to build the foundation for software architecture. We first develop an intuition for software architecture by appealing to several well-established architectural disciplines. On the basis of this intuition, we present a model of software architecture that consists of three components: elements, form, and rationale. Elements are either processing, data, or connecting elements. Form is defined in terms of the properties of, and the relationships among, the elements --- that is, the constraints on the elements. The rationale provides the underlying basis for the architecture in terms of the system constraints, which most often derive from the system requirements. We discuss the components of the model in the context of both architectures and architectural styles and present an extended example to illustrate some important architecture and style considerations. We conclude by presenting some of the benefits of our approach to software architecture, summarizing our contributions, and relating our approach to other current work.
Parameterized specifications for software reuse
Authors: Cheng Jingwen
Published: July 2004

Software reusability is believed to be the key to improving software development productivity, while specification plays an important part in software reuse. From a modern object oriented view, the reusable software components can be grouped into three categories. Procedural components, abstract data types and concrete data objects. Both procedural components and abstract data types can be parameterized in many Object-Oriented languages. Specifications for reuse of these components are discussed in detail in this paper. The reusable software components and their specifications will form a reusable software library, and the information extracted from the specifications forms a knowledge base. Based on the knowledge base and the reusable software library, a new software development paradigm with software reusability can be realized.
Reveng
Authors: Debest Xavier A. , Knoop Rüdiger , Wagner Jürgen
Published: July 2004

Like many other Software Engineering buzzwords, "Reverse Engineering" emerges as an attempt to formalize some specific tasks, which have long been performed by almost every software development or maintenance team, but which were not judged worth before to be considered an engineering discipline. The emergence of powerful Computer Aided Software Engineering (CASE) tools opens new opportunities for the cost-effective re-use of the investments made in existing software systems, and thus for the development of specific tools and techniques to recover the original design of these systems.While most of the current discussion is centered around the development and utilization of tools to automate the Reverse Engineering Process, our attention focuses on the practical application of these tools and techniques under conditions found in real world entreprises. From this view-point, the scope of the Reverse Engineering Techniques appears to be much broader than implied by the characteristics of individual tools.Our approach is based on experiences gained by CMG in projects, either directly related to Reverse Engineering or dealing with tasks, where specific Reverse Engineering Techniques and Tools were advantageously used (e.g. Software Maintenance, Re-Design, Down-Sizing, Conversion). It also evidentiates some pitfalls, which may lead to the failure of some Reverse Engineering projects.
Slow sorting
Authors: Julstrom Bryant A.
Published: July 2004

Sorting is one of the most common and important computing operations. In analyzing and comparing sorting algorithms, we consider their execution times, as indicated by the number of operations they execute as they sort
n
elements. The simplest algorithms have times that grow approximately as
n
2
, while more complex algorithms offer times that grow approximately as
n
log
n
. This paper pursues a contrary goal: a sorting algorithm whose time grows
more quickly
than that of the well-known algorithms. The paper exhibits and analyzes such an algorithm.
Protocol analysis of a novice programmer
Authors: Bishop-Clark Catherine
Published: July 2004

This study examined the problem solving of a novice programmer writing a first draft of an elementary computer program. The latter stages of entering and debugging the program were not part of the analysis. A detailed analysis of the tape-recorded protocol confirmed the major themes of the research on novice problem solving. Some characteristics specific to programming were also identified. In particular, the subject emphasized the syntax of the language, showed little advanced planning, and organized her programming information in the order it had been presented in class. There were distinct phases of (a) understanding the problem, (b) devising a plan, and (c) carrying out the plan. There was also evidence of both positive and negative transfer from what the student had previously learned in class. A number of practical guidelines for teaching novices to program emerged from the analysis and the literature.
Teaching instructional software design
Authors: Kearsley Greg , Heller Rachelle
Published: July 2004

This article describes our approach to teaching graduate students in education and computer science about the design of instructional software. The course is taught by instructional television (ITV) and involves the use of a computer bulletin board system. Students complete software projects using a variety of commercial authoring tools. Student reactions to the nature of the course are described as well as lessons learned.
Game playing as a technique for teaching parallel computing concepts
Authors: Kitchen Andrew T. , Schaller Nan C. , Tymann Paul T.
Published: July 2004

Blackboard tracing of algorithms, while an effective tool for the teaching of sequential programming, is singularly ineffective and confusing when applied to parallel computing. The use of classroom games to illustrate concepts and pathologies proves to be a useful alternative technique. Games in which students play the role of processors can be used to illustrate simple parallel algorithms as well as more complex concepts. Live demonstrations are stimulating for both the participants and the class as a whole. This paper discusses guidelines regarding the development of such exercises and presents several examples.
Operation-based merging
Authors: Lippe Ernst , van Oosterom Norbert
Published: July 2004

Existing approaches for merging the results of parallel development activities are limited. These approaches can be characterised as state-based: only the initial and final states are considered. This paper introduces operation-based merging, which uses the operations that were performed during development. In many cases operation-based merging has advantages over state-based merging, because it automatically respects the data-type invariants of the objects, is extensible for arbitrary object types, provides better conflict detection and allows for better support for solving these conflicts. Several algorithms for conflict detection are described and compared.
A geometric view of mutual exclusion and deadlock in computer system
Authors: Parhami Behrooz
Published: July 2004

A set of eight simple diagrams with accompanying explanations has proved quite effective as a tool for teaching the concepts of mutual exclusion and deadlock in an operating systems course. This note presents the diagrams in a manner suitable for direct reproduction as viewgraphs or class handouts and touches upon the major points in explaining the diagrams to students.
Abstraction & modual decomposition—an example
Authors: Gittleman Arthur
Published: July 2004

The design and prototype implementation of an interpreter for a small BASIC-like language makes an excellent project illustrating the value of abstraction and modular decomposition. Such a project can be assigned in several different courses, either as a sequence of short assignments or as a term project.
OMEGA: A database management system for academic use
Authors: Deegan Colleen , Atkins John , Henry Mike
Published: July 2004

This paper describes an implementation of the relational database management system, OMEGA. OMEGA is designed to be "query language independent" in order to promote the investigation of experimental query languages by graduate students. OMEGA also supports the query language SQL and as such, is used in undergraduate database courses to demonstrate the features of SQL.
A robotics course using hero I robots
Authors: Gips James
Published: July 2004

An undergraduate Computer Science course in Robotics has been offered for the past two semesters. Supporting the course is a laboratory with six Hero I robots. Students learn how to program the robots in 6808 assembly language.
Cognitive style, personality type, and learning ability as factors in predicting the success of the beginning programming student
Authors: Corman Larry S
Published: July 2004

The Myers-Briggs Type Indicator, Group Embedded Figures Test, the Learning Style Inventory, and a Type A-B Questionnaire were administered to introductory COBOL students along with marketing students to determine if results from these instruments would improve the predictability of student success in computer science. Demographic data was also gathered on the 83 subjects similarly to prior studies. No significant new findings were found in this study; the strongest variable was a student's major grade point average.
Dealing with independent studies courses—an effective methodology
Authors: Bailes Gordon , Sayer Jerry
Published: July 2004

Independent studies courses can be an effective means of providing the flexibility for a serious student with a well-planned career path to tailor his or her curriculum to meet the special requirements of the career plan, and to permit the students to experience and learn about subjects for which there is insufficient demand or resources to offer a regular course. The potential for abuse of this course is high as we found at East Tennessee State University. In addressing this issue, we found that we were also able to strengthen the written and oral communications skills which are so important to today's computing professionals. This paper describes the experiences we have had and the solution we discovered.
Interactive digital simulation
Authors: Reid Richard J
Published: July 2004

Simulation of digital networks can be enhanced by interactive graphics to provide an experimental environment that rivals breadboarding as a "hands-on" logic-design experience.The simulator described here allows interactive keyboard entries during the simulation interval providing activation of network switches and pulsers, restarting or slowing the simulation, graphical expansion of modules in terms of their internal components, graphical pan and zoom for better resolution of sub-networks, and multiple viewing windows onto the virtual space of the network. The simulation is three-level and event driven, and allows the specification of periodic clock signals of unlimited duration.A pre-processor allows the macro definition of modules and provides the necessary independence of local variables that is required for multiple instantiation. Although inherently recursive, the macro processor can be supplemented with library macros that support iterative specification. This feature allows the construction of networks with interated cell structures.
The skills needed to teach computer-science courses HHHHHHHHHHHH
Authors: Abshire Gary M
Published: July 2004

Certain skills are needed to teach computer-science course effectively. These skills range from the ability to write clear course objectives to the ability to present material well and to counsel students ably. Most of us need some assistance in sorting out these skills and creating from them a surefire, step-by-step teaching procedure. The suggestions that follow will help you do just that, enabling you to prepare and present your ideas in less time and with better results.Use this information as a checklist before, during, and after your course. During the course, you will probably want to obtain some feedback on your performance. You may want to either conduct a trial run with an audience of your colleagues or have someone sit in on your first few class meetings and check your performance. You could also read over the list before each class (always a good idea) and check your own performance right after each class.
The experience of women in undergraduate computer science
Authors: Howell Kathy
Published: July 2004

In recent years the discipline of computer science has become recognized as a male dominated field. Attempts have been made to encourage more women to participate but, have such efforts been supported or directed by the available research? This article presents a description of the current situation and reviews the existing body of research related to the undergraduate experience of women in computer science. Based on the research, some implications for computer science education are outlined. Suggestions are also given for further research needed to more completely describe the current situation and direct changes.
Integrating total quality management with software engineering education
Authors: Skelton Gordon W.
Published: July 2004

During the past several years Total Quality Management (TQM) has become a driving force in the service and manufacturing industries. TQM and Total Quality Control (TQC) are very applicable to the software development industry and thereby, applicable to software engineering instruction. This article focus on the need for integration of TQM concepts into the regular computer curriculum of the computer science and software engineering program.
A discussion of special characteristics for software package development life cycle models
Authors: Carmel Erran
Published: July 2004

Software package development (SPD) is playing an increasingly important role in the software market. Traditionally, most software has been developed for custom purposes which differs somewhat from SPD in some Life Cycle Model (LCM) characteristics. Five special characteristics for SPD are discussed: accommodating the unknown user, formalizing customer requirements, supporting multiple platforms and versions, facilitating speed of development and reacting to market pressures, and incorporating risk minimization.
Metamodeling
Authors: Kokol Peter
Published: July 2004

The metamodeling is analyzed in the context of three crucial questions: How, why and What? This analysis showed that albeit the great advancement of process modeling in last years at least one important question still remains unsolved: How to design new process models? In this paper we introduce a metaparadigm as a possible solution to this question. Metaparadigm is a metadesign paradigm based on Checklands Soft System Methodology.
Understanding and improving the user interface design process
Authors: Fisch Eric A.
Published: July 2004

Over the past few years user interfaces, especially graphical ones, have been emphasized in the design of computer systems [1]. Users often take for granted the interfaces of today's computer systems. The person entering data or typing up a report does not even consider the work that has gone into making the system and its applications as easy to use as a pen and paper. The difficulty that does go into creating the "perfect" user interface begins from the systems inception and does not end until the system becomes obsolete. Even then, the lasting effects of the interface on its users will make future designers work more laborious. This paper will discuss the design process of the user interface. It concludes with some suggestions that future designers may wish to consider to make their jobs easier.
The missing link in requirements engineering
Authors: Kaindl Hermann
Published: July 2004

Especially the early phase of requirements engineering is one of the most important and least supported parts of the software life cycle. Since pure natural language has its disadvantages, and directly arriving at a formal representation is very difficult, a link through a mediating representation is missing. We use
hypertext
for this purpose, providing also links among requirements statements and the representation of objects in a domain model. This possibility of explicit representation of links allows the users and analysts to make relationships and dependencies explicit and helps to be aware of them. Actually, our approach and the tool supporting it use a combination of various technologies, including also
object-oriented approaches
and a grain of
artificial intelligence
(in particular
frames
). Therefore,
inheritance
is provided by our tool already in the early phase of requirements engineering. In particular, we found it very useful to view requirements as objects. A key idea is to support the ordering of ideas especially through classification already in the early stages. While our approach is not intended to substitute useful existing techniques emphasizing more formal representations, it can be combined with them.
Using object oriented structured development to implement a hybrid system
Authors: Vazquez Federico
Published: July 2004

Object Oriented Analysis, Design and Programming are increasingly impacting the development approach to Computer Systems. Although these methodologies are not new, their use in industry is increasing and they have had a large impact in both System Analysis and System Design. Some People think that object oriented techniques will be the new predominant methodologies used in the 90s and there is no relationship with Structured Design. Others believe that there is indeed a relationship between Structured Analysis and Object Oriented Design. During my work with the development of computer systems I have found a certain degree of compatibility between Object Oriented Analysis and Structured Analysis. I did not however find compatibility between Structured Design and Object Oriented Design. This paper deals with the use of both techniques in a successful system development effort with a hybrid approach. It is possible to work with hybrid systems where object Oriented and Structured development are combined and complement each other.
A note on inheritance and state machines
Authors: McGregor John D. , Dyer Douglas M.
Published: July 2004

The inheritance relationships in an object-oriented program have been shown to be a natural structure for facilitating reuse in a number of areas such as test cases. This note reports on a technique for incrementally building the state machine for a class from the state machines of its base classes. Using a style of state diagram similar to object charts provides a graphical means of displaying the resulting state machine. This incremental technique allows more complex machines to be built with less effort.
Improving the software reusability in object-oriented programming
Authors: Cheng Jingwen
Published: July 2004

One of the promises which OOP (Object-Oriented Programming) holds is that it enhances software reusability. Indeed, software components designed in OOP is easier to be reused than those designed in conventional programming. But the state-of-the-art software reusability in most OOP environments is still very limited. This paper examines how OOP enhances software reusability, what are the limitations of software reuse in current state, and how to improve software reusability.
Integrated support for software reuse in Computer-Aided Software Engineering (CASE)
Authors: Poulin Jeffrey S.
Published: July 2004

The success and acceptance of reuse tools and libraries depends on their integration into existing software development environments. However, the addition of large libraries of reusable components to software design databases only exacerbates the problem of design data management. Object-oriented databases originated to meet the requirements of design data management that relational databases could not satisfy. This paper describes a semantic data model for an object-oriented database supporting an integrated Computer Aided Software Engineering environment (CASE). The data model promotes reuse by providing objects that match program design requirements to existing components in the reuse library.
Process and measurement support in SEEs
Authors: Lott Christopher M.
Published: July 2004

Software evolution processes are well-known to be difficult to manage. Some software engineering environments (SEEs) can use models of these processes to guide their enaction. A few of these SEEs can additionally collect and use measurement data to guide processes precisely. Measurement-based guidance is intended to improve the manageability of the guided processes. This paper contributes an overview of many process-centered SEEs, with special emphasis on those that support the systematic collection of process, product, and resource data for the purpose of process guidance.
The CSedRes toolbox
Authors: Almstrum Vicki L. , Wu Cheng-Chih
Published: July 2004

We introduce the notion of a "CSedRes Toolbox" for educational research in the field of computer science. The Toolbox should include a repertoire of instruments and methodologies that instructor-researchers can use in planning well-designed and valid studies. We propose an on-going project for the SIGCSE membership: to incrementally add appropriate tools to the Toolbox. In this article, we motivate the existence of such a repository and describe our vision for the Toolbox. As our starting point in building up the Toolbox, we discuss the characteristics of instruments used to measure phenomena of interest in educational research, with focus on instruments developed by other researchers and how to locate these existing tools. The balance of the paper presents an instrument for assessing individuals' learning styles, Kolb's LSI-1985.
PC graphics packages for Modula-2
Authors: Detmer Richard C.
Published: July 2004

Modula-2 is the implementation language used in Northwest Missouri State University's graphics course. Two locally produced modules of graphics procedures provide the interface for most of these programs. These modules run under TopSpeed Modula-2 on a PC system with a VGA display. The module of two-dimensional procedures provides functionality similar to a minimal GKS package. The module of three-dimensional procedures is parallel to, but simpler than, the two-dimensional module. Students have benefitted both from using and from extending these modules.
Direct update of data flow representations for a meaning-preserving program restructuring tool
Authors: Griswold William G.
Published: July 2004

Automated assistance for meaning-preserving global restructuring is an approach for helping software engineers improve the structure of programs, thus lowering the costs of maintenance. The consturction of a restructuing tool encounters many conflicting goals---such as simplicity. extensibility, and good performance---that cannot be met without some compromise. In particular, the current technique for assisting restructuring uses a costly program representation---a Program Dependence Graph (PDG) with alias information---that is not practical to recompute from scratch after each restructuring transformation. There are at least two possible solutions. A commonly suggested approach for efficiently updating data flow representations is to use a generic incremental algorithm that does not make use of the special nature of the restructuring. This approach is general, but it does not yet handle aliasing fully. By taking advantage of the special nature of the restructuring transformations it is possible to implement a more efficient update than generic update that also handles aliasing. The idea is to implement direct updates to the PDG that are analogous to the changes on the program text. The downsides to direct update are that it is application-specific, applies only to semantically restricted applications like restructuring, and may be more complex. The choice between the two techniques requires an understanding of the current and future needs of the tool's users.This paper describes the direct approach of updating the PDG and related representations for restructuring, provides techniques for managing its complexity, critiques its advantages and shortcomings relative to generic incremental update, and presents performance results.
A practical approach to software engineering using Z and the refinement calculus
Authors: Wood Kenneth R.
Published: July 2004

We present a methodology for the formal specification and development of software systems using Z and the refinement calculus. The methodology combines the data structuring capabilities and the codified discrete mathematics of Z with the data encapsulation properties and development style of the refinement calculus, and it aims to provide a formal path from design to implementation without unnecessary transformations of notation or the definition of a new calculus. It is illustrated here by the development of two systems, a simply diary and (part of)a text editor, and is contrasted with the use of Z on its own. We discuss related and future work and conclude with some general comments on applied formal methods.
Partition testing, stratified sampling, and cluster analysis
Authors: Podgurski Andy , Yang Charles
Published: July 2004

We present a new approach to reducing the manual labor required to estimate software reliability. It combines the ideas of
partition testing
methods with those of
stratified sampling
to reduce the sample size necessary to estimate reliability with a given degree of precision. Program executions are stratified by using automatic
cluster analysis
to group those with
similar features
. We describe the conditions under which stratification is effective for estimating software reliability, and we present preliminary experimental results suggesting that our approach may work well in practice.
Signature matching
Authors: Zaremski Amy Moormann , Wing Jeannette M.
Published: July 2004

Software reuse is only effective if it is easier to locate (and appropriately modify) a reusable component than to write it from scratch. We present
signature matching
as a method for achieving this goal by using signature information easily derived from the component. We consider two kinds of software components, functions and modules, and hence two kinds of matching, function mathcing and module matching. The signature of a function is simply its type; the signature of a module is a multiset of user-defined types and a multiset of function signatures. For both functions and modules, we consider not just
exact
match, but also various flavors of
relaxed
match. We briefly describe an experimental facility written in Standard ML for performing signature matching over a library of ML functions.
Analyzing refinements of state based specifications
Authors: Felder Miguel , Ghezzi Carlo , Pezzè Mauro
Published: July 2004

We describe how formal specifications given in terms of a high-level timed Petri net formalism (TB nets) can be analyzed to check the temporal properties of bounded invariance (the systems stays in a given state until time τ) and bounded response (the system will enter a given state within time τ). In particular, we concentrate on specifications given in a hierarchical, top-down manner, where one specification level refines a more abstract level.

Our goal is to define the conditions under which the properties that are proven to hold at a given abstraction level are preserved at the next refined level. To do so, we define the concept of correct refinement, and we show that bounded invariance and bounded response are preserved by a correct refinement. We also provide a set of constructive rules that may be applied to refine a net in such a way that the resulting net is a correct refinement.
Implementation-based analysis and testing of Prolog programs
Authors: Belli B. , Jack O.
Published: July 2004

In this paper, we describe the PROTest II (PROlog Test Environment, Version 2) system to test logic programs in an interactive support environment. Logic programs are augmented with declarative information about the types and modes of the arguments of a predicate. Modes correspond to in, out, and in-out parameters. With this information PROTest II statically checks the types of Prolog programs, generates test cases, executes Prolog programs, and produces reports summarizing results including information about new test coverage metrics. Thus, PROTest II enables both static analysis and dynamic testing uniformly using a Prolog-based test language DTL/1. The strength of PROTest II stems from its idea of defining coverage in real logic programming terms, rather than adapting imperative programming ideas.
Load testing software using deterministic state testing
Authors: Avritzer Alberto , Larson Brian
Published: July 2004

In this paper we introduce a new load testing technique called Deterministic Markov State Testing and report on its application. Our approach is called “deterministic” because the sequence of test case execution is set at planning time, and “state testing” because each test case certifies a unique software state. There are four main advantages of Deterministic Markov State Testing for system testers: provision of precise software state information for root cause analysis in load test, accommodation for limitations of the system test lab configuration, higher acceleration ratios in system test, and simple management of distributed execution of test cases. System testers using the proposed method have great flexibility in dealing with common system test problems: limited access to the system test environment, unstable software, or changing operational conditions. Because each test case verifies correct execution on a path from the idle state to the software state under test, our method does not require the continuous execution of all test cases. Deterministic Markov State Testing is operational-profile-based, and allows for measurement of software reliability robustness when the operational profile changes.
Improved serial algorithms for mutation analysis
Authors: Weiss Stewart N. , Fleyshgakker Vladimir N.
Published: July 2004

Existing serial algorithms to do mutation analysis are inefficient, and descriptions of parallel mutation systems pre-suppose that these serial algorithms are the best one can do serially. We present a universal mutation analysis data structure and new serial algorithms for both strong and weak mutation analysis that on average should perform much faster than existing ones, and can never do worse. We describe these algorithms as well as the results of our analysis of their run time complexities. We believe that this is the first paper in which analytical methods have been applied to obtain the run time complexities of mutation analysis algorithms.
An information flow model of fault detection
Authors: Thompson Margaret C. , Richardson Debra J. , Clarke Lori A.
Published: July 2004

RELAY is a model of how a fault causes a failure on execution of some test datum. This process begins with introduction of an original state potential failure at a fault location and continues as the potential failure(s) transfers to output. Here we describe the second stage of this process, transfer of an incorrect intermediate state from a faulty statement to output.

Transfer occurs along information flow chains, where each link in the chain involves data dependence transfer and/or control dependence transfer. RELAY models concurrent transfer along multiple information flow chains with transfer sets, which identify possible interaction between potential failures, and with transfer routes, which identify actual interactions. Transfer sets, transfer routes, and control dependence transfer are unique to the RELAY model.

The model demonstrates that the process of potential failure transfer is extremely complex and full analysis of real programs may not be practical. Nonetheless, RELAY provides insight into testing and fault detection and suggests an approach to fault-based testing and analysis that may be warranted for critical systems software.
Reverse engineering questionnaire
Authors: Kontogiannis Kostas A. , Tilley Scott R.
Published: July 2004

This is a questionnaire on program understanding and reverse engineering. It may be filled out manually or on-line. The results of the questionnaire will be used to guide the research of the two authors, both of whom are Ph.D. students working in this area. Copies of the resulting report will be mailed to all who participate, and a summary of the results will be published in an appropriate forum.
A possible approach to object-oriented reengineering of Cobol programs
Authors: Tomic Marijana
Published: July 2004

Reengineering is rapidly becoming a recognized and important component of future computer-aided systems-engineering (CASE) environment. This paper presents framework for analyzing Object-Oriented Reengineering process of COBOL programs. The process embody software engineering principles that concern module interactions such as low coupling and high cohesion.
The European Space Software Development Environment Reference Facility Project
Authors: Favaro John , Coene Yves , Casucci Marco
Published: July 2004

The ESSDE Reference Facility Project, whose goal is to provide a uniform, open environment for software development at the European Space Agency (ESA), has just completed the architectural design phase. A software engineering environment based upon the Portable Common Tool Environment (PCTE) interfaces has been specified, including a complete data model supporting all activities and products in the ESA standard software development life cycle. Several issues of much current interest have been addressed including scalability, configurability and the integration of commercial tools into an existing framework.
Self-sufficiency and critical thinking in the programming languages course
Authors: Bloom Bard , Fekete Alan
Published: July 2004

We describe a project in a standard course in Programming Languages. This project forces students to display self-sufficiency and critical thinking skills. The students are given the documentation and interpreter for smeagol, a small invented language which resembles the control language for many text-processors, spreadsheets, and so forth. They are expected to learn (within two days) enough to write working non-trivial programs. They then must write an evaluation of the language, documentation, and system. In this paper, we explain many specific features of the project, and discuss its effectiveness.
Software engineering project work in combined distance and on campus modes
Authors: Oliver Dave
Published: July 2004

This paper describes the delivery of a Software Engineering subject taught in both Distance and On Campus modes. Rotated group working and Computer Mediated Communication were involved.
Connect 4 as a problem in artificial intelligence and robotics
Authors: Stuart Brian L.
Published: July 2004

This report presents work done by the Artificial Intelligence and Robotics class of Summer Scholars 1993 at Rhodes College. Summer Scholars provides college credit for intensive two-week courses taken by high school students. The goal of this course was to develop software to play the game Connect 4 and to control a robotic arm making the moves.
Women and computers
Authors: Kerner Janet T. , Vargas Kathy
Published: July 2004

The phenomenon of pipeline leakage exhibited in the field of computer science is also observed in all the sciences and mathematics. We can take advantages of the similarities between computer science and all the sciences to share the knowledge that has been gained to reverse this phenomenon. Two important factors that have been identified are (i) the number of math and science courses taken in high school and (ii) the view that many young women have of careers in science and computer science as being antisocial in nature. Our program addresses these factors by exposing the young women to the challenges of scientific and technical topics and by making role models and mentors readily accessible to young women who demonstrate an interest in science. After the common factors have been extracted to make all science more attainable and more attractive to women, each of the individual sciences, mathematics, and computer science can address any problems that are unique to that field.