bluuebunny/crossref_metadata_2025 huggingface dataset:
The IEEE standard for software maintenance
Authors: Mamone Salvatore
Published: July 2004

Maintenance, traditionally the last phase of the Software Life Cycle, is usually overlooked, under documented, and never appreciated. Maintenance is usually thought of as "something that's done after the work is done" and is usually delegated to junior programmers. As a result the modified system can many times contain more defects that the original system.This article will describe the Software Maintenance Standard and how it can provide the foundation for better control of Maintenance.
Software metrics and measurement principles
Authors: Roche John M.
Published: July 2004

Software measurement is widely advocated as a fundamental constituent of an engineering approach to planning and controlling software development. Unfortunately, there is a dichotomy between the quantity of developed metrics and those used. This paper provides a tutorial review of software engineering measurement indicating the depth and breadth of the field. Individual metrics are not described due to the interest of this paper being on the measurement process and not the products of that process. Generic problems have been identified within existing measurement processes, these provide learning points for the expression of measurement principles. These principles are classified and described according to their position within the formulation, analysis and application stages of measurement. Conclusions are elaborated that suggest that existing measurement frameworks for applying measurement - often called measurement methods - do not provide sufficient support for the principles and their continued use will only serve to replicate the problems. In order to improve the products i.e. metrics, the measurement process requires improvement through inclusion of these principles in a new method.
The stage one Turing test as an artificial intelligence class exercise
Authors: Tinkham Nancy Lynn , Provine Darren F.
Published: July 2004

This paper describes an implementation of the man-woman Turing test as a class exercise in an artificial intelligence course. The exercise helps students to understand more clearly the difficulties and challenges involved in designing an artificially intelligent computer to pass the more famous person-computer Turing test.
An innovative software reengineering tools workshop—a test of market maturity and lessons learned
Authors: Bourque Pierre , Abran Alain
Published: July 2004

Practitioners still feel ill at ease regarding an evaluation process for reengineering tools. To address this issue, a Québec-based special interest group in software engineering reused a case study workshop format that had been previously implemented to compare CASE products. This case study format had to be substantially modified to allow both vendors and participants to properly position the reengineering tools. For example, the workshop committee had to prepare reengineering frameworks, including a taxonomy of tools as well as legacy system selection criteria for the case study. This article also reports on the challenges met during the project as well as lessons learned: within a context of an immature reengineering market, the time has not yet come for a full real-life case study at an acceptable economic cost.
M.E.R.O.DE.: a model-driven entity-relationship object-oriented Development method
Authors: Dedene G. , Snoeck M.
Published: July 2004

Object Orientation has as primary goal to improve the software construction process. Object Oriented analysis, design and software construction should yield software of a high quality: software that is reliable, maintainable, extensible, adaptable. However, delivering large OO software systems in a qualitative way is a significant challenge. Scaling up requires formal precision of the semantics of the modelling techniques and languages used by the development team. And when the target system contains an abundance of parallelism, the problem of validation becomes unfeasible if it is not supported by formal techniques. With the incorporation of formal techniques in the development process, we can expect significant benefits in terms of software quality.For this reason, one might expect a high level of formality in current OOAD methods [9]. Unfortunately, most current OOAD methods are characterised by a low level of formality. The M.E.R.O.DE. methodology addresses this void. By making use of algebra, the methodology has been provided with a formal basis at several levels with a significant improvement of the quality of the software development process as a result.Before presenting M.E.R.O.DE. to the reader in the second section, the first section motivates the development of still another OOA method. The final section demonstrates how exactly the formal definition of M.E.R.O.DE. results in a gain of quality at the software specification level.
An annotated bibliography on software process improvement
Authors: Fuggetta Alfonso , Picco Gian Pietro
Published: July 2004

Software process improvement is a critical problem that is currently addressed both at the academic and industrial level. The field is relatively young, and there is no "ultimate approach" to the problem. The related scientific literature is rapidly growing, and is more and more difficult to make our way in the plethora of different perspectives, approaches, and case studies.
This paper provides
a guide to the process improvement literature: we think that both newbies and experts of this field can take advantage from it.
Isomorphism and the N-Queens problem
Authors: Cull Paul , Pandey Rajeev
Published: July 2004

The N-Queens problem is commonly used to teach the programming technique of backtrack search. The N-Queens problem may also be used to illustrate the important concept of isomorphism. Here we show how the N-Queens problem can be used as a vehicle to teach the concepts of isomorphism, transformation groups or generators, and equivalence classes. We indicate how these ideas can be used in a programming exercise. We include a bibliography of 29 papers.
Testing student-made compilers
Authors: Guimarães José de Oliveira
Published: July 2004

This article presents a few guidelines and examples for testing Pascal compilers designed by students in introductory courses. A standard Pascal subset with little alteration is used, and the possible sources of errors are divided into eight categories. Examples and probable sources of error are exposed for each category.
A tool for operating system teaching
Authors: Cartereau Michel
Published: July 2004

This paper presents a simulation tool designed to aid operating system teaching. It is an example of software for production of pedagogical simulations with a view to cooperative learning. The presentation of its use for teaching operating system shows its potential and includes a description of the educational context and the students' reactions.
The progress of undergraduate software engineering education
Authors: Ford Gary
Published: July 2004

Although U.S. universities do not yet offer undergraduate degrees named "Bachelor of Science in Software Engineering," several schools are making progress in that direction. Efforts at eleven schools are described.
The power of integrated methods
Authors: Gelperin David
Published: July 2004

Improving software quality is easy. Just do three things: (1) Insert fewer bugs, (2) Find them earlier, and (3) Find more of them. Modern test and evaluation methods are very effective at all three. What is even more effective is to integrate these methods into a modern T&E process and to integrate this process with acquisition and development methods into a software engineering program. Integration multiplies the impact of effective methods and is a major theme in modern approaches.On most projects, developers are responsible for testing as well as designing, and coding the software components. For a new component or change to an existing component, one person usually carries out all software engineering tasks. This note describes an activity sequence that is very effective at both avoiding and detecting defects when a single individual does all the software engineering. The order as well as the specific tasks in this sequence is important in maximizing effectiveness. Understanding the principals behind this process will make it easy to modify when more than one person is assigned to the development of a sinle component.
The Automated Student Advisor
Authors: Harlan Robert M.
Published: July 2004

The paper examines a large project for an Expert Systems course, the Automated Student Advisor, which assists students in selecting courses for the next semester. The system was designed and implemented in the last third of a semester course by students and the instructor working as a software group. The result was a software system that is now in use at the university.
The top 10 reasons why object-oriented programming can't be taught in CS 1
Authors: Decker Rick , Hirshfield Stuart
Published: July 2004

Over the past year we have changed our CS 1 course from a standard Pascal-based, procedural programming course into one that emphasizes C++ and object-oriented programming (OOP). While our experience to date indicates that this was a good decision for both our students and our department, the decision did not come easy. We struggled long and hard with many, if not most, of the questions and issues that have come to be associated with teaching OOP to undergraduates. This paper recounts our struggles, and presents our responses to the more serious of the pedagogical questions that we considered. In hindsight, many of the reasons we came up with for not using OOP in CS1 are seen to reflect our lack of understanding of the paradigm, our fear of the language, and our past experience teaching Pascal and the procedural paradigm. Furthermore, we believe that our reservations (which appear to be quite common) stemmed from a growing body of misleading OOP folklore that is contrary to our experience and that this paper attempts to dispel.
Professional literacy
Authors: Etlinger Henry A. , Lutz Michael J.
Published: July 2004

Our contention is that there now exists a considerable body of lab exercises that may be used in conjunction with introductory courses. There are fewer models available for instructors of more advanced programming courses, especially those courses which attempt to introduce students to current practices in software engineering. In this paper, we report on our experiences in building a second-year programming course that includes a significant lab and project component. These labs and projects are the vehicle we use to introduce students to the world of professional practice in software development.
Team dynamics in student programming projects
Authors: Scott Thomas J. , Tichenor Lee H. , Bisland Ralph B. , Cross James H.
Published: July 2004

This paper focuses on the interpersonal issues, often referred to as “team dynamics,” that can become quite important as students construct a large-scale programming project. Differing methods in which teams can develop phases of such projects are presented with advantages and disadvantages for each topic discussed. Various methods of student team selection and team communication techniques are first considered. Then various methods that can be used to define large-scale student team projects are discussed. The effect of team dynamics on the classic software engineering phases of specification, implementation, testing, and evaluation phases of student projects is discussed. Four project scenarios that have been used in the authors' classes, as well as rationales for these project designs are discussed. The paper concludes with results derived from using these scenarios in the classroom.
Teaching programming to liberal arts students
Authors: Arnow David
Published: July 2004

Loop invariants have long been present in advanced undergraduate and graduate courses on programming methodology or program correctness. Recently there has been an increased interest in using loop invariants in teaching more elementary courses. In this paper, its successful use in teaching elementary programming in a computer literacy course for non-majors is described. The techniques described here, that are necessary in order to work successfully with this population, are also applicable to the teaching of programming to computer science majors.
ICONIC programming in BACCII vs. textual programming
Authors: Calloni Ben A. , Bagert Donald J.
Published: July 2004

This paper presents the empirical testing results on students' learning in the CS1 PASCAL programming course. This research is the continuation of a project begun in 1990. In 1991, creation of a prototype Windows based application for Personal Computers reached completion. That system, called BACCII, is used to teach beginning procedural programming. All but the most basic operations are accomplished using icons. When the algorithm is complete, the student can generate syntactically correct source code for PASCAL, C, FORTRAN, or BASIC. The system was evaluated with 126 college students in the Spring 1993 semester, randomly assigned to laboratory sections. Fifty-two used BACCII and VAX with the remaining 74 using VAX PASCAL alone. The results showed significant improvement in academic scores (and presumably learning) for the BACCII control group.
Computing χ
2
values
Authors: Dooley John F. , St. Clair Daniel C. , Bond William E.
Published: July 2004

Textbooks and courses on numerical algorithms contain numerous examples which lead students to believe that the algorithm of choice for computing the zeros of a function f(x) is Newton's algorithm. In many of these courses little or no time is spent in providing students with “real world” experiences where Newton's method fails.

The work presented in this paper describes a slow convergence problem encountered while trying to use Newton to estimate values for the χ
2
distribution. The problem occurred while the authors were trying to implement a well-known machine learning algorithm from the field of artificial intelligence. The function being evaluated and the convergence problem with Newton's method is described. Numerical results are given that indicate that a hybrid algorithm consisting of Newton and the nonderivative bisection algorithm not only provides good results but quickly and consistently converges.
Attracting (& keeping) the best and the brightest
Authors: Bruce Kim B.
Published: July 2004

This paper addresses the design of an exciting introductory course for entering college students who have some programming background. The key innovation of the course is the introduction of material pertaining to experimental graph reduction and dataflow architectures for highly-parallel computers. The success of the course is attributed to interesting, well-integrated material and the use of visually-oriented interactive simulators for the architectures.
eText
Authors: Rifkin Adam
Published: July 2004

How can parallel programming be made tractable for students in high schools and community colleges, to programmers in four-year colleges, to commercial and government employees, to interested independent users learning on their own, and as CASE tools for professional software designers? We aim not only to enable people to use more powerful computers, but also to enable people to use computers more powerfully, by nurturing the techniques that enable them to develop efficient, correct code with relative ease. This paper briefly presents the concept of an
Archetype
, a software engineering methodology developed at the Caltech for patterns of problem solving, and for providing media for quick reference and natural software reuse. We then describe
eText
, an interactive multimedia electronic textbook that facilitates the teaching of, navigating through, and referring to Archetypes. Initial experience with Archetypes and the electronic textbook suggests that this approach to teaching parallel programming can aid computer users in the immediate future.
Teaching C++ to high school students
Authors: Finkel David , Hooker Chet , Salvidio Scott , Sullivan Mark , Thomas Christopher
Published: July 2004

C++ was used to teach programming to beginning programming students in a summer program for high-ability high school students. We discuss the reasons for choosing C++, how we presented it to this group of students, and the results of this experiment. Some suggestions are presented for others interested in teaching C++ to novice programmers.
Understanding the bottom-up SLR parser
Authors: Khuri Sami , Williams Jason
Published: July 2004

This paper describes an application of one of the important abstract concepts taught in a compiler construction course. It demonstrates how the techniques behind the bottom-up SLR parser can be used to perform computer animation. The different phases of the implementation presented are identical to the ones used by the traditional compiler for parsing source codes written in high-level languages. This application can be used either to explain the different phases of the traditional compiler, or as an illustration of the bottom-up SLR parsing techniques applied in a non-traditional environment.
Speeding up slicing
Authors: Reps Thomas , Horwitz Susan , Sagiv Mooly , Rosay Genevieve
Published: July 2004

Program slicing is a fundamental operation for many software engineering tools. Currently, the most efficient algorithm for interprocedural slicing is one that uses a program representation called the system dependence graph. This paper defines a new algorithm for slicing with system dependence graphs that is asymptotically faster than the previous one. A preliminary experimental study indicates that the new algorithm is also significantly faster in practice, providing roughly a 6-fold speedup on examples of 348 to 757 lines.
CAIS
Authors: Mashayekhi Vahid , Feulner Chris , Riedl John
Published: July 2004

Many software engineering tasks have a synchronous component that requires the participants to assemble together at the same time and place. This approach is expensive in terms of traveling, scheduling and human resources. Existing computer tools mitigate these constraints by adding structure to the meeting, providing on-line document support, and distributing the participants over geographic boundaries. The constraint remains, however, that all participants participate at the same timeWe propose relaxing the time constraint in software engineering tasks to resolve issues non-concurrently, in effect reducing (and in some cases eliminating) the need for the synchronous meeting. We hypothesize that support for asynchrony will enable software engineering teams to work together as effectively in different times as in same time.We have chosen software inspection as our candidate software engineering task because it is well-understood, highly-structured, and widely-practiced. We have designed and developed a Collaborative Asynchronous Inspection of Software (CAIS) meeting prototype that supports the meeting part of inspection. CAIS allows participants to effectively "meet" even when separated by time zones and working schedules. We have conducted a pilot study comparing the manual and CAIS meetings and present our results and lessons learned.
A language-independent approach to specification construction
Authors: Lévy N. , Smith G.
Published: July 2004

An interactive specification development environment is presented in which a number of development methodologies and specification languages can be supported. Within the environment, design concepts and strategies are captured by the application of
development operators
, i.e. operators which enable the incremental construction and modification of specifications.The focus of this paper is to investigate the language independence feature of the environment, based on the work done in the Esprit project ICARUS. A set of operators enabling an object-oriented approach to specification development are instantiated for both the algebraic specification language Glider and the model-based specification language Z. These operators are illustrated by the development of a case study of a simple card game in both Glider and Z.
LCLint
Authors: Evans David , Guttag John , Horning James , Tan Yang Meng
Published: July 2004

This paper describes LCLint, an efficient and flexible tool that accepts as input programs (written in ANSI C) and various levels of formal specification. Using this information, LCLint reports inconsistencies between a program and its specification. We also describe our experience using LCLint to help understand, document, and re-engineer legacy code.
Using specialized procedures and specification-based analysis to reduce the runtime costs of modularity
Authors: Vandevoorde Mark T. , Guttag John V.
Published: July 2004

Managing tradeoffs between program structure and program efficiency is one of the most difficult problems facing software engineers. Decomposing programs into abstractions simplifies the construction and maintenance of software and results in fewer errors. However, the introduction of these abstractions often introduces significant inefficiencies.This paper describes a strategy for eliminating many of these inefficiencies. It is based upon providing alternative implementations of the same abstraction, and using information contained in formal specifications to allow a compiler to choose the appropriate one. The strategy has been implemented in a prototype compiler that incorporates theorem proving technology.
Foundations of software testing
Authors: Hamlet Dick
Published: July 2004

Testing is potentially the best grounded part of software engineering, since it deals with the well defined situation of a fixed program and a test (a finite collection of input values). However, the fundamental theory of program testing is in disarray. Part of the reason is a confusion of the goals of testing---what makes a test (or testing method) "good." I argue that testing's primary goal should be to measure the dependability of tested software. In support of this goal, a plausible theory of dependability is needed to suggest and prove results about what test methods should be used, and under what circumstances. Although the outlines of dependability theory are not yet clear, it is possible to identify some of the fundamental questions and problems that must be attacked, and to suggest promising approaches and research methods. Perhaps the hardest step in this research is admitting that we do not already have the answers.
Oracles for checking temporal properties of concurrent systems
Authors: Dillon Laura K. , Yu Qing
Published: July 2004

Verifying that test executions are correct is a crucial step in the testing process. Unfortunately, it can be a very arduous and error-prone step, especially when testing a concurrent system. System developers can therefore benefit from oracles automating the verification of test executions.This paper examines the use of Graphical Interval Logic (GIL) for specifying temporal properties of concurrent systems and describes a method for constructing oracles from GIL specifications. The visually intuitive representation of GIL specifications makes them easier to develop and to understand than specifications written in more traditional temporal logics.Additionally, when a test execution violates a GIL specification, the associated oracle provides information about a fault. This information can be displayed visually, together with the execution, to help the system developer see where in the execution a fault was detected and the nature of the fault.
Performing data flow testing on classes
Authors: Harrold Mary Jean , Rothermel Gregg
Published: July 2004

The basic unit of testing in an object-oriented program is a class. Although there has been much recent research on testing of classes, most of this work has focused on black-box approaches. However, since black-box testing techniques may not provide sufficient code coverage, they should be augmented with code-based or white-box techniques. Dataflow testing is a code-based testing technique that uses the dataflow relations in a program to guide the selection of tests. Existing dataflow testing techniques can be applied both to individual methods in a class and to methods in a class that interact through messages, but these techniques do not consider the dataflow interactions that arise when users of a class invoke sequences of methods in an arbitrary order. We present a new approach to class testing that supports dataflow testing for dataflow interactions in a class. For individual methods in a class, and methods that send messages to other methods in a the class, our technique is similar to existing dataflow testing techniques. For methods that are accessible outside the class, and can be called in any order by users of the class, we compute dataflow information, and use it to test possible interactions between these methods. The main benefit of our approach is that it facilitates dataflow testing for an entire class. By supporting dataflow testing of classes, we provide opportunities to find errors in classes that may not be uncovered by black-box testing. Our technique is also useful for determining which sequences of methods should be executed to test a class, even in the absence of a specification. Finally, as with other code-based testing techniques, a large portion of our technique can be automated.
Correctness and composition of software architectures
Authors: Moriconi Mark , Qian Xiaolei
Published: July 2004

The design of a large system typically involves the development of a hierarchy of different but related architectures. A criterion for the relative correctness of an architecture is presented, and conditions for architecture composition are defined which ensure that the correctness of a composite architecture follows from the correctness of its parts. Both the criterion and the composition requirements reflect special considerations from the domain of software architecture.The main points are illustrated by means of familiar architecture for a compiler. A proof of the relative correctness of two different compiler architectures shows how to decompose a proof into generic properties, which are proved once for every pair of architectural styles, and instance-level properties, which must be proved for every architecture.
Using undergraduates as teaching assistants in introductory programming courses
Authors: Roberts Eric , Lilly John , Rollins Bryan
Published: July 2004

The introductory computer science at Stanford University have a combined annual enrollment of over 1000 students. Teaching introductory programming to a population of this size requires significant instructional support to ensure that students receive the individual attention most beginning programmers need. This paper describes the approach that has evolved at Stanford for the introductory computer science courses, which is based on the extensive use of advanced undergraduates to teach sections of the introductory course. In our experience, using undergraduates as part of the teaching staff has created an effective learning environment for both the students in the classes and the undergraduate section leaders themselves.
Achieving a uniform interface for binary tree implementations
Authors: Gurwitz Chaya
Published: July 2004

One of the basic principles taught in a data structures course is that an application program should be independent of the implementation of any particular data structure it uses. This policy breaks down when binary trees are introduced, because the interfaces for the various representations of binary trees are not uniform. In particular, implementing a binary tree by using an implicit array generally requires the array itself to be passed as a parameter to any function that manipulates the tree. In this paper we present an approach for defining the implicit array representation of a binary tree. Our definition makes the underlying array transparent to the user. This allows us to describe a uniform interface for a binary tree module that can be used by an application program regardless of the particular implementation of the tree.
A visual simulator for a simple machine and assembly language
Authors: Barnett B. Lewis
Published: July 2004

We present a package which provides a visually oriented simulation of the execution of machine and assembly language programs on a simple computer. The programs are written for HyperCard running on Apple Macintosh computers. They are suitable for in-class demonstrations and various types of in-class or out of class assignments.
Software reuse and object-oriented software engineering in the undergraduate curriculum
Authors: Tewari Rajiv
Published: July 2004

Software engineering education and practice are currently undergoing extensive re-evaluation and analysis in the light of new object-oriented software development techniques as the complexity of software development is rapidly increasing. There is a growing recognition that software reuse can contribute to increased productivity, and the programming paradigm that best supports software reuse is the object-oriented paradigm. Component-based software engineering is currently best facilitated by the object-oriented approach through reuse of available class libraries and application frameworks. We present a comparative analysis of the procedural and object-oriented paradigm from a pedagogic perspective, and show that object-oriented techniques are a logical progression of the well tested structured methodologies. We show that the object-oriented methodology better addresses the fundamental concepts and processes defined in the ACM/IEEE Computing Curricula '91.
Loop exits and structured programming
Authors: Roberts Eric S.
Published: July 2004

Internal exits from loops represent a critically important control structure that should be taught in the introductory CS1 curriculum. Without access to those facilities, students are often incapable of solving simple programming problems that occur frequently in applications. This paper reviews the existing evidence in support of such facilities and argues that it is important to reconsider our traditional pedagogical approach as we adopt new languages of instruction.
Experiences with Mosaic for legacy projects
Authors: Morris J. Morgan
Published: July 2004

Mosaic, a hypermedia information browser for the World-Wide Web, has become popular within the past year, and the number of sites are expected to increase even further. One use of Mosaic by Computer Science educators is for legacy projects, i.e. student projects that will contribute to the educational efforts of future students in the course. For the resulting hypermedia documents to be useful, a design methodology is needed that promotes consistency in use and navigation. The instructor may also take on the role of editor of a hypermedia document and ensure that the document is correctly formatted and connected, and consistent. Students enrolled in a human-computer interaction course at Georgia State University have been required to develop legacy projects using Mosaic. Experiences in developing these projects are discussed, and recommendations based on these experiences are presented.
Active use of hypertext to aid learning and classroom instruction
Authors: Moore Thomas
Published: July 2004

Hypertext is a valuable means of representing and organizing information, for both instructors and students. Hypertext can be used to create a set of presentation materials that can be easily shared with both students and colleagues. More importantly, those materials can also be used to help students build on explicit representation of their knowledge that helps them to understand complex concepts and their relationships. In this paper, we discuss our experience in the active use of hypertext in the development and teaching of a breadth-first introductory course.
Teaching a modern numerical analysis course
Authors: Noyes James L.
Published: July 2004

The traditional introductory undergraduate numerical analysis course typically begins by addressing some mathematical preliminaries and computer arithmetic followed by one or more major topic areas. For each of these areas, specific problems are proposed, algorithms for their solution are derived and implemented, results are obtained, and an associated error analysis is made. The algorithms and associated software are usually sequential in nature and the error analysis is often simplified. Increasingly, students need to be made aware of the additional hardware and software advances that can make the solution of these problems more efficient and their error analysis easier. This paper discusses an approach that incorporates
Mathematica
to help provide problem insight and an improved error analysis, and a parallel processing simulation program called
Multi-Pascal
, to help teach effective algorithm implementation.
Where have the women gone and how do we keep them from going? (panel)
Authors: Honda Adams Sandra , Isles Rachel D. , Moses Louise E. , Pinto Domenick , Van Scoy Frances L.
Published: July 2004

When only one female student joined our Introduction to Structured Programming course in the Fall of 1993 and was gone by midterm, I became alarmed! During the last several years, our enrollment in Computer Science has attracted fewer and fewer females. I believe the lack of interest of female students to be a serious problem that needs to be addressed by educators. For this reason I have assembled a panel of educators who will share their ideas as to why this is happening and inform us of their efforts to counteract this gender imbalance.
Never mind
the
paradigm, what about multiparadigm languages?
Authors: Budd Timothy A. , Pandey Rajeev K.
Published: July 2004

A source of great debate among educators is the choice of a programming language in the various computer science courses. In recent years the focus has shifted from features of various programming languages to arguments about the various paradigms that the languages embody. The approach suggested here is to expose students to all of the major paradigms, via the use of a multiparadigm language, as opposed to attempting to identify "the" correct paradigm. In this paper, we first describe the multiparadigm language Leda and its constituent paradigms. We then identify points in the curriculum at which to introduce a multiparadigm language, and some consequences of these choices.
An investigation of the relationship between student algorithm quality and program quality
Authors: McGill Tanya , Volet Simone
Published: July 2004

This paper reports on an exploratory study designed to explore the relationship between the quality of students' algorithm development and the quality of their final programs. By videotaping pairs of students engaged in writing a program to solve a problem the process used by students could be examined and its relationship to program quality investigated. The results of the study show a clear positive relationship between the quality of algorithm development and the quality of programs written by students in an introductory programming course.
An object-oriented tutoring system for teaching sets
Authors: Güvenir H. Altay
Published: July 2004

Over the recent years several prototypes of intelligent tutoring systems for scientific subjects have been developed. Meanwhile, the object-oriented paradigm has become popular in the software engineering and artificial intelligence communities. The objective of the research presented in this paper is an application of the object-oriented paradigm to the design and implementation of an intelligent tutoring system. The domain of the system is the set theory at the secondary school level. It is shown that the inheritance hierarchy of the object-oriented paradigm is very useful in defining and organizing the components of the set theory, and in the generation of examples and questions. The issues raised in the object-oriented design of an intelligent tutoring system are discussed.
The application of second natural language acquisition pedagogy to the teaching of programming languages—a research agenda
Authors: Robertson Stephanie A. , Lee Martin P.
Published: July 2004

The writing of programs is one of the central activities in computer science education, yet frequently it is poorly taught. In this paper we argue that some of the most recent principles emerging from research into and the successful teaching of second natural languages might be applied to the teaching of programming languages.The paper begins by reviewing the historical development of the teaching of both second natural languages and programming languages. It continues with a manifesto for potential research areas, in order to test these ideas further.
An advanced microprocessor course with a design component
Authors: Mattis W. E.
Published: July 2004

The paper describes the structure of an advanced microprocessor course, given at the graduate level. Included in the discussion is the rationale for the specific processors taught, the depth of coverage, and a design component.
Software reliability apportionment using the analytic hierarchy process
Authors: Aggarwal K. K. , Singh Yogesh
Published: July 2004

In this paper, we present a software reliability apportionment scheme using analytic hierarchy process which attempts to answer the question " how reliable should each system module be ? ". Reliability requirements determined by integrating user's view, software manager's view and programmer's view would be more realistic, consistent and economically attainable than those obtained through subjective or haphazard method. This model determines reliability goals at the planning and design stages of the software project, hence making reliability a singular measure for performance evaluation. The concept of frequency ratio is used which considers the probability of a module execution when the software is executed for a predefined number of input cases. Modules which are to be executed rather infrequently may be allocated relatively lower reliability values.
Inheritance as sublation and its semantics
Authors: Xu Dianxiang , Zheng Guoliang
Published: July 2004

This paper presents an approach to non-monotonic inheritance in an object-oriented logic programming framework. Inheritance as sublation, achieved through predicate extension and exception, not only provides a very flexible mechanism for software reuse but also is very philosophical. Taking the (iterated least fixpoint) well-founded model semantics to traditional logic programs as a basis, the declarative semantics is also explored.
The development of JR-DSSG
Authors: Xu Manwu , Zeng Fancong , Lu Jianfeng , Yang Dong
Published: July 2004

To increase software productivity and enhance its quality, techniques for software reuse have attracted more and more attention in recent years. Among these techniques, application generator is a rather practical one but without deep explorations yet. In this paper, at first we examine the application generator in terms of characteristics of software reuse. And then, as a case study of application generator technique, the development of JR-DSSG and its features are presented. Finally, we end this paper with a discussion of intended further work.
Why should you use a personal software process?
Authors: Humphrey Watts S.
Published: July 2004

The Personal Software Process (PSP) is a structured set of forms, standards, and procedures that is designed to help you do better work. Data on the PSP's early use shows that engineers achieve average reductions of 75% in numbers of injected defects, make more accurate plans, and have higher productivity. To date, the PSP has been used to write more than 1000 small programs with a total of over 100,000 LOC. C is the language most commonly used but C++, Ada, Pascal, FORTRAN, and Visual Basic have also been used. This note describes the PSP, why it was developed, and how it can help you to be a better software engineer.
Reuse-oriented requirements engineering in NATURE
Authors: Maiden N. A. M.
Published: July 2004

This short paper outlines research undertaken as part of the ESPRIT III NATURE basic research action into domain-specific requirements engineering environments. It describes a set of problem abstractions which are the basis for intelligent guidance during requirements scoping, acquisition, modeling, critiquing and communication. It presents a toolkit designed to exploit the problem abstractions during different requirements engineering activities. Routes for industrial exploitation of these research results are also outlined.
Practical verification for requirements model of Hatley/Pirbhai
Authors: Tatsuta Tanehiro
Published: July 2004

Five years have passed since translated version of a popular book on Real Time Structured Analysis method was published in Japan. Japanese readers of it have been discussing its practical usage actively. Its research work is however hardly ever presented abroad. We will show here recent Japanese research work on it.
Reuse through inheritance
Authors: Bieman James M. , Zhao Josephine Xia
Published: July 2004

According to proponents of object-oriented programming, inheritance is an excellent way to organize abstraction and a superb tool for reuse. Yet, few quantitative studies of the actual use of inheritance have been conducted. Quantitative studies are necessary to evaluate the actual usefulness of structures such as inheritance. We characterize the use of inheritance in 19 existing C++ software systems containing 2,744 classes. We measure the class depth in the inheritance hierarchies, and the number of child and parent classes in the software. We find that inheritance is used far less frequently than expected.
Automated support for software development with frameworks
Authors: Schappert Albert , Sommerlad Peter , Pree Wolfgang
Published: July 2004

This document presents some of the results of an industrial research project on automation of software development. The project's objective is to improve productivity and quality of software development. We see software development based on frameworks and libraries of prefabricated components as a step in this direction. An adequate development style consists of two complementary activities: the creation of frameworks and new components for functionality not available and the composition and configuration of existing components.

Just providing adequate frameworks and components does not necessarily yield automation and efficiency of software development. We developed the concept of relations between software components as a foundation for abstraction, reuse and automatic code generation for component interrelationship. Furthermore we suggest to supplement frameworks with an active cookbook consisting of active recipes which guide the software developer in the use of framework elements.

In this paper our concept of using relations among software components is presented and the active cookbook is illustrated as a means for developer guidance. We created a prototype to demonstrate these concepts.
An approach to the classification of domain models in support of analogical reuse
Authors: Lung Chung-Horng , Urban Joseph E.
Published: July 2004

This paper presents an approach to classify domain models in order to facilitate reuse through analogy. Domain analysis plays a critical role for systematic reuse, but domain analysis is difficult to perform, especially for new application areas. Analogical approach to reuse can support the domain analysis process by providing software products in a different but analogous domain. In order to achieve this goal, domain models need to be classified. This paper proposes a classification method for domain models. The method is an integration of the enumerative hierarchy and faceted scheme. The classification approach can help the domain analyst to locate an analogous domain to perform the modeling and analysis process. Moreover, the approach is more flexible and more descriptive than conventional classification methods.
Location-independent naming for virtual distributed software repositories
Authors: Browne Shirley , Dongarra Jack , Green Stan , Moore Keith , Pepin Theresa , Rowan Tom , Wade Reed
Published: July 2004

A location-independent naming system for network resources has been designed to facilitate organization and description of software components accessible through a virtual distributed repository. This naming system enables easy and efficient searching and retrieval, and it addresses many of the consistency, authenticity, and integrity issues involved with distributed software repositories by providing mechanisms for grouping resources and for authenticity and integrity checking. This paper details the design of the naming system, describes how the system fits into the development of the National HPCC Software Exchange, an virtual software repository that has the goal of providing access to reusable software components for high-performance computing.
The spin-off illusion
Authors: Wasmund Michael
Published: July 2004

Based on the desire of enterprise management to find a smooth, low-risk way of introducing reuse methodology, this paper discusses several approaches taken. The illusion of using the by-product of software development to obtain reusable assets is the subject of the second approach. The third successful approach follows the software factory paradigm and has been successfully implemented at several IBM sites.
Supporting the process of satisfying information needs with reusable software libraries
Authors: Henninger Scott
Published: July 2004

Retrieval tools for component-based software reuse libraries face two interrelated problems. The first is the ill-defined nature of information needs. The second is that large repositories will often use unfamiliar and esoteric vocabulary to describe software components. CodeFinder, a retrieval system designed to help developers locate software components for reuse, addresses these issues through an innovative combination of retrieval by reformulation and spreading activation. An empirical study comparing CodeFinder with two other systems showed evidence that subjects using CodeFinder with ill-defined tasks or mismatching vocabulary performed better than subjects using the other systems. The study confirmed the utility of spreading activation and retrieval by reformulation techniques for satisfying information needs of the kind encountered in software design.
SMART requirements
Authors: Mannion Mike , Keepence Barry
Published: July 2004

Systems Analysis, or as it is increasingly known as today, Requirements Engineering, is a time consuming, expensive but critical phase in software (and system) development. The "perfect" Requirements Specification should exhibit a number of qualities including correctness, completeness and consistency. Within a Requirements Specification individual requirements at the microscopic level should be justified, clear, unambiguous and verifiable. However, in many cases Systems Analysts or Requirements Engineers describe requirements which fall short of these demands. In addition, outside reviewers faced with presenting an independent qualitative assessment of a Requirements Specification have few guidelines to assist them. In this paper we present a simple technique, borrowed from objective setting in Management Psychology, to assist the construction and evaluation of individual requirements.
Beyond objects
Authors: Shaw Mary
Published: July 2004

A standard demonstration problem in object-oriented programming is the design of an automobile cruise control. This design exercise demonstrates object-oriented techniques well, but it does not ask whether the object-oriented paradigm is the best one for the task. Here we examine the alternative view that cruise control is essentially a control problem. We present a new software organization paradigm motivated by process control loops. The control view leads us to an architecture that is dominated by analysis of a classical feedback loop rather than by the identification of discrete stateful components to treat as objects. The change in architectural model calls attention to important questions about the cruise control task that aren't addressed in an object-oriented design.