bluuebunny/crossref_metadata_2025 huggingface dataset:
Scenario-based prototyping for requirements identification
Authors: Hooper James W. , Hsia Pei
Published: July 2004

The three major facets of software requirements engineering are: (1) requirements identification, (2) requirements analysis, and (3) requirements communication. Much research addresses the latter two aspects, but few practical approaches exist for addressing the first one. Hence, system requirements remains the most critical and problemprone area of system development. There is thus an urgent need for a methodology which helps a user identify requirements and realize potential impacts, in a timely manner.The objectives of this research are: (1) develop a methodology (and accompanying tools) to aid users in identifying requirements before building a system, and (2) evaluate the effectiveness of the methodology (and tools) in actual use.The novel approach of this research is an attempt to capture the conceptual system as visualized by the user, by use of operational examples ("scenarios"). By means of simulation and man-machine interface techniques, the scenarios may serve as a "quick and dirty" prototype of the intended system, providing the means for requirements analysis and validation, and for communicating the real intent of the requirements. It is anticipated that the methodology can be extended to fully support the concept of step-wise refinement and continuing system validation.
Rapid prototyping and requirements specification using PDS
Authors: Klausner A. , Konchan T. E.
Published: July 2004

Rapid Prototyping is a software development methodology which can reduce development cost by aiding the requirements definition, design, and coding of a software system. PDS is an integrated programming environment which can support rapid prototyping. and it was used by the authors to build a prototype of a relational database system. Observations on both rapid prototyping and PDS are given, and a requirements specification language is proposed as a natural extension to PDS.
Scale models and rapid prototyping
Authors: Weiser Mark
Published: July 2004

A prototype of a system is a model of that system which sacrifices accuracy in some areas (such as ease of change) for a quick check of the system's function. A prototype is therefore one kind of scale model-- a model accurate in some ways but inaccurate in others. Three different ways to build scale models of software correspond to the accurate modeling of the following three aspects of a software system: user interface, functionality, and performance. A prototype accurate in one of these areas will usually deliberately ignore accuracy in the other two. Specific scaling of results in a software scale model will be necessary depending upon what aspect has been ignored.
Languages for representing software specifications and designs
Authors: Riddle William E. , Wileden Jack C.
Published: July 2004

We consider the nature of software system specifications and designs, then survey the languages used in representing them. We emphasize the utility of language-based representations as a foundation for computerized tools which provide aid during software system development. The survey is based upon a classification of the languages according to their underlying representational constructs.
Evaluating the effect of inter-programmer communication
Authors: Bailey John W. , Christensen Ken , Krcmar Helmut , Lassez Jean-Louis , Shen Vincent Y. , Woodfield Scott N.
Published: July 2004

Various methods exist for estimating the complexity of single modules and the complexity of interacting modules. We propose to demonstrate how the degree of programmer inter-communication in a multi-programmer project also has a significant effect on productivity. Specifically, projects which use programming team structures which require more inter-programmer communication will experience lower productivities than projects which use team structures which minimize the need for inter-programmer communications.The design proposed here involves the simultaneous re-implementation of an existing, well-documented design by teams of seven graduate-level students. It offers the advantage of alternate levels of work depending upon the amount of data collection and analysis to be underwritten. The results of even the least demanding study will be of significance to any medium to large scale development environment as a guide to selecting programming team structure. The more involved study will give more general results as to the effects of unconstrained communication paths in a team environment.
The application of fractional factorial techniques
Authors: Curtis Bill , Gannon John , Gloss-Soler Shirley , Goel Amrit , Miyamoto Isao , Panzl David , Warburton Roger
Published: July 2004

We are interested in evaluating the effects of software tools and methods on cost and errors over the life-cycle of a software project. The adopted approach is to perform controlled experiments. The experiments are designed to be conducted for selected variables using standard experimental design strategies. We discuss the use of the fractional factorial approach to a specific design for a selected experiment. The Appendix contains the list of variables which were considered in the design of this experiment.
Evaluation of design methodologies
Authors: Arisawa Makoto , Bergland G. David , Bowers Earle C. , Buxton John N. , Kelley Robert A. , Kerth Norman L. , Saib Sabina H. , Ting Peter D. , Troy Douglas A. , Zweben Stuart H.
Published: July 2004

This proposal seeks to evaluate the effects of various design methodologies on the development and maintenance of computer systems. More specifically, an experiment is proposed to test the hypothesis that the cost of making changes to computer systems is influenced by the application area of the system and by the design methodology employed in its development. Proponents of various design methodologies will develop, from user requirements, solutions to selected problems in each of four application areas. After acceptance of the solutions by an independent contractor, requests for changes will be given to each design methodology group. Careful records of the costs of initial development and subsequent modifications will be kept. These costs, other measures taken on the resulting products, and a post activity conference will form the basis for evaluation the experiment and the participating methodologies.
VERking in constructive set theory
Authors: Constable Robert L.
Published: July 2004

The constructive set theory of PL/CV3 is used to illustrate conditions that a formal system must satisfy if it is to feasibly represent the reasoning needed to solve sequential programming problems.
Real-life software projects as Software Engineering Laboratory exercises
Authors: Lee Kyu Y. , Frankel Eric C.
Published: July 2004

The Software Engineering Laboratory is a one-academic-year course required for the Master of Software Engineering degree at Seattle University. It is designed to simulate a real-life software development project environment, providing equal focus on technical and managerial considerations. The output of the laboratory must be a software product of marketable quality.This paper describes the experience gained from the laboratory projects and discusses directions for future projects.
Another look at software design methodology
Authors: Lehman M. M. , Stenning V. , Turski W. M.
Published: July 2004

Software design - from 'topmost' specification down to final implementation - is viewed as a chain of uniform steps, each step being a transformation between two linguistic levels. A canonical form of the step is discussed and it is argued that all rational design activities are expressible as a combination of canonical steps. The role of backtracking in software design is explained and a mechanism for introducing changes, both indigeneous and exogeneous, is proposed, again entirely by a combination of canonical steps. The main tenet of the 'canonical step approach' is that a design step contains a degree of unconstrained, creative invention and a calculable part which is the actual transformation effected.
A program testing assistant for BASIC-PLUS
Authors: Chan Mee-Yee , Yam Siu-Yuen
Published: July 2004

A programmer often writes and tests programs in a bottom-up manner, producing code fragment by fragment and testing each fragment on a few examples to convince himself that the program works so far. These intermediate tests are typically lost without full utilization. The objective of this project is to create a kind of information retrieval system for test cases to remedy this situation. The "program testing assistant" described herein is intended to aid BASIC-PLUS programmers during incremental program development. As in the production of any piece of software tool, issues of ease of use and user-friendliness are of main concern in our testing assistant, along with software engineering considerations such as maintainability and reliability.
Quality assurance and quality control in the software development process
Authors: Yiannakos Andrew E.
Published: July 2004

Quality has become an important concept in the marketplace recently. Have American workers traditionally produced "garbage"? Have standards for quality ever been defined? The intense competition created by the automobile industry in the last decade has sent an important message home. The importance of producing a quality product has come of age.The quality "spirit" has overflowed from the auto industry into almost all other industries in the United States, with good cause: the weak economy of the previous few years and increased penetration of our marketplace by foreign competitors have proven that nothing can replace a quality product. Quality has its place also in the information systems industry. Quality assurance and quality control exist to check and verify a developer's software product. A good structured system design, plus an aggressive assurance effort, allow information system products to meet customer expectations and approval.This research paper,
Quality Assurance and Quality Control in the Software Development Process
, reviews QA's place in system design, development and test. Different quality control techniques are discussed for the DP environment, and the payoffs and costs of QA are reviewed.The following is the bibliography used in this paper. The author is interested on discussion and suggestions on this topic, and he can be reached at: Andrew E. Yiannakos, IBM Corporation, New York Advanced Education Center, 909 Third Avenue, New York, New York, 10022.
Two observations on large software projects
Authors: Dunn Dick
Published: July 2004

The observations which follow have come from observing and participating in several large software projects over the past few years. I present them as observations---hypotheses, if you will---without any attempt to prove them. The intent is to stimulate discussion.
Multi-level specifications based on traces
Authors: Veloso P. A. S. , Furtado A. L.
Published: July 2004

A methodology for the formal specification of data base applications is presented. Central to the methodology is the idea of proceeding through successive levels of "traces", which enables an initial algebra specification to be obtained from one based on preconditions and effects. Besides being executable these trace levels provide a way to go from a natural language specification to an algebraic one.
DoD-Std-2167A and methodologies
Authors: Overmyer S. P.
Published: July 2004

Many experts in software engineering agree that the emerging iterative requirements engineering, software engineering and software design methodologies present excellent ways to identify and validate user requirements. These methodologies often include innovative techniques for elicitation and validation of user requirements including various forms of human engineering analysis, rapid prototyping, and knowledge acquisition tasks. This paper addresses the compatibility of these techniques with DoD-Std-2167A. Assessment is made regarding the compatibility of the standard with innovative requirements techniques, and how and where these techniques may be inserted into the life cycle.
Applying Zen principles in an introductory programming course
Authors: Dalbey John
Published: July 2004

The word "zen" often conjures up images of robed and shaven headed monks sitting in lotus position in a meditation hall in a japanese monastery. For most people it is hard to reconcile this image with that of modern computer technology. But in my experience as a teacher of computer programming I have found that certain zen principles can be very valuable for people learning about computers.Despite its "philosophical" or "abstract" reputation, zen is actually a practice aimed at helping people cope with everyday life. In a sense it is anti-philosophical because it emphasizes actions not words. Historically, zen was practiced in the context of very pragmatic and technical skills such as archery and swordsmanship. The discipline had specific exercises aimed at improving one's technical skills while simultaneously providing opportunity for a kind of spiritual growth. While programming a computer is a cognitive skill instead of a physical skill, zen principles still have important application to the psychology of learning.
A hands-on dataflow architecture/programming course
Authors: Canning James T.
Published: July 2004

The University of Lowell's Department of Computer Science offers a course in data flow programming which provides students with the opportunity to run their programs on an actual, rather inexpensive dataflow machine. Students gain a much deeper understanding of the issues related to line grain parallel processing. The course not only surveys various dataflow architectures and languages, but also involves laboratory assignments where students must design, debug and execule dataflow programs.
An introduction to object-oriented programming through Turbo Pascal
Authors: Dixon Chip
Published: July 2004

This paper presents three introductory concepts of object-oriented programming: encapsulation, inheritance and polymorphism. The specific implementation for these concepts and other terms presented, is the language Turbo Pascal (5.5 or later). The examples illustrated have been successfully used as the first part of an introductory object-oriented programming class.
An Artificial Intelligence theory of computer competency
Authors: Wagner Christian , Vinsonhaler John
Published: July 2004

This article reports the development of an Intelligent Tutorial System (ITS) that represents procedural knowledge using a "mental context" that permits generalization. The system behaves much like an advisor, competent in the use of personal computers, who is helping another person perform a word processing task. The nature of the system is discussed and illustrated. Implications are drawn for the definition and measurement of what the authors term "computer competence."
Dining philosophers revisited, again
Authors: Yue Kwok-bun
Published: July 2004

This paper describes a problem in the solution of the dining philosophers problem by Gingras [2] that makes it inefficient, instead of the claimed maximal efficiency. A correct implementation is presented. Even then, the solution has other undesirable characteristics and is still not maximally efficiency. Depending on the definition of efficiency, it may not be possible to attain maximal efficiency and be starvation-free at the same time. A better and simpler solution for general mutual exclusion problems, in which the dining philosophers problem is a special case, is presented. This solution can become symmetric if appropriate data structures are used.
The role of software configuration management in a measurement-based software engineering program
Authors: Sprague Kristopher G.
Published: July 2004

The role of Software Configuration Management has rapidly expanded and grown in importance over the last few years for a number of reasons. This paper presents an overview of the significant changes that are occurring in the Software Configuration Management discipline with respect to its role in a measurement-based software engineering program. It identifies the changes, provides an overview of the SCM functions, proposes a process, and discusses directions for future research and development.
The V project manager tools
Authors: Marsh Shaun
Published: July 2004

This paper proposes a simple set of tools for managing the concurrent development of a given project by many developers. These tools may be added to most programming environments while not hiding the files from other tools which the developer may wish to use.
Automatic resumption mechanism for program debugging
Authors: Shimomura Takao
Published: July 2004

In program debugging, tracing control instructions that examine internal program states can be saved in a file and this file can be used to initialize the debugging environment when a program is loaded by a debugger. When a source program is modified because of bugs, however, source line numbers are also changed. It is therefore necessary to update the source line numbers in a tracing control instruction file according to the modifications in the source program. This paper proposes a solution by means of an automatic resumption mechanism that simplifies the debugging procedure from source modification to the beginning of the next debugging. While a programmer is creating an executable program using make after he has modified the program, the tracing control instruction file is updated automatically, so the programmer does not even have to think of updating them. This mechanism makes it very easy to resume debugging with the same debugging environment after program modification.
Some notes on program design
Authors: McLaughlin Robert
Published: July 2004

Program design is an important part of the design process. The propose of this paper is to give some guidelines to the design process. It is not possible to write down a set of rules that will deal with all design problems. However it is possible to make program design a respected science within the computer sciences.
Soft system methodology and is research
Authors: Kokol Peter , Stiglic Bruno , Zumer Viljem
Published: July 2004

A sound and complete evaluation is a necessity in efficient and effective information system design. In the present paper we show how the Checklands Soft System Methodology can be used in the development of a new evaluation process, in the manner to overcome some of the greatest weaknesses of conventional ones.
Using a software engineering approach to CS1
Authors: Leonard James R.
Published: July 2004

This investigation used two groups of CS1 students. The control group was taught with a more traditional synthesis approach emphasizing language use using bottom-up explanations. The treatment group was taught with a software engineering-oriented analysis approach and emphasized topdown functional decomposition. The results indicate that a software engineering approach can produce significantly better student performance than a more traditional approach.
Managing hard-disk PCs in the introductory laboratory
Authors: Walker David K. , Tucker David S.
Published: July 2004

A method is described for managing stand-alone hard-disk PCs, in an environment in which students are allowed to explore the hard disk. The system, application, and student-created files are safeguarded by management software which helps eliminate "accidental" loss or modification.
OZ
Authors: Osborne Martin
Published: July 2004

In response to the needs of students taking introductory programming classes, we have a created a syntax generating editor. This simple to use and reasonably powerful editor helps students avoid syntax errors and also greatly eases and speeds the typing of programs. This is especially true in Modula-2 where the frequent need to change between upper and lower case places exhausting demands on even good typists. Changes in a configuration file allow the editor to work with a number of different programming languages. The editor is written in Pascal and runs under VAX/VMS. Source code, executable code, and documentation are available over the Internet.
An environment of a graduate curriculum in computer graphics
Authors: Carlson Wayne E.
Published: July 2004

Attention has been focused recently on programs in Computer Graphics within the general Computer Science Curriculum. A successful graduate program in the Department of Computer and Information Science at The Ohio State University is outlined. Facilities and laboratories, courses, and staffing are discussed. Particular attention is given to a software environment, called EDGE (Educational and Development Graphics Environment) which is central to the success of the courses in the curriculum.
Creating pedagogical programming environments
Authors: Ezell C. L.
Published: July 2004

A popular way to introduce program design concepts to beginning programming students is to discuss the solution of familiar, easily decomposed problems involving ordinary situations, such as washing a car or cleaning a room. Extensible languages, such as Smalltalk, make it easy to create pedagogical programming systems on which the solutions of such problems can be implemented.
Average case analysis when merging two ordered lists of different length
Authors: Trono John A.
Published: July 2004

A derivation for the expected number of comparisons when merging two ordered lists is given, where the sizes of the individual lists are unknown but the size of the merged list is known. Other applications where this result can be applied are also mentioned, most notably the LUPSort algorithm of Merritt and Nauck[4].
Building monitors with UNIX and C
Authors: Dunstan Neil
Published: July 2004

An outline is given for structuring concurrent programs written in C under UNIX System V using the concept of monitors. It is shown how a monitor can be implemented in UNIX System V using the semaphore and shared memory facilities. Monitors are a common topic in the studies of concurrent programming and operating systems.
Tool for making programs more readable
Authors: Arab Mouloud
Published: July 2004

Until recently, the researchers in the C.R.I.S.S Research Center dealing particularly with teaching beginners the writing of Pascal programs meet some problems concerning the presentation of the programs. The Pascal language is a structured one, the teachers wants to provide a model of the presentation of the Pascal program which facilites the correction and make the program readable by other programers. We propose an automatic formatting programs for responding to this aim. Results have been positive. The students produce organized programs and the presentation provided helps the students in the detection of bad constructs and the teachers in having a readable programs which are presented in the same way by the students.
Comfort and experience with computing: are they the same for women and men?
Authors: Bernstein Danielle R.
Published: July 2004

What produces comfort with computers and how is comfort related to computer achievement for men and women? This study looks at the effects of comfort and prior spreadsheet knowledge on the ability to design spreadsheets by management science students. Results showed that comfort with computing is significantly correlated with test performance for women; for men, mathematics ability and relevance to their future career are more important. The study suggests that the quality of women's initial computing instruction is very important in affecting what they will accomplish in the future.
AD/Cycle repository manager from object-oriented perspective
Authors: Maciaszek Leszek A.
Published: July 2004

The advantage of an object-oriented approach to development is that it offers the analyst, designer and programmer a higher level of abstraction in which to work. AD/Cycle uses object orientation in two contexts: (1) it encourages an object-oriented approach to software production based on AD/Cycle, and (2) it presents itself as an object-oriented database development platform. The former is a methodological issue, the latter - an environmental issue.The methodological issue is only sketched in AD/Cycle documents, and as such is addressed only briefly
in this paper
. The main thread of the paper is on the evaluation of the environmental aspect of AD/Cycle. This implies that the paper concentrates on the Repository Manager of AD/Cycle. In particular, the paper examines the conceptual specification view and also the logical specification view combined with run-time services.The conclusions of this paper are only as sound as the object orientation paradigm itself. The paper places special emphasis on this issue. It is believed that object
orientation solves the application a
nd data management problems faced by CASE developers and users, but hard proof has yet to be provided. The same applies to the claims of productivity improvements in most but particularly susceptible application development activities (such as window management).
Perspectives on CASE tool integration
Authors: Wybolt Nicholas
Published: July 2004

CASE tool integration means making the whole tool environment greater than the sum of its constituent parts (tools). An integrated CASE environment, in turn, is built on an integrationframework. This paper presents a series of perspectives on CASE tool integration and frameworks.
Optimization of validation test suite coverage
Authors: Lindquist Timothy E. , Gutzmann Kurt M. , Remkes David L. , McKee Gary
Published: July 2004

Test coverage is an important aspect of a validation suite for implementations of a standard such as the CAIS. This paper presents the development and application of a constrained optimization process for CAIS test coverage. Subjective criteria and goals combined with objective measures of test coverage derived from information models yield a quasi-quantitative figure of merit for test objectives. The approach next identifies resource (time and effort) and process constraints. A greedy algorithm provides a partial solution to the coverage design problem. The decreasing first fit bin packing heuristic then refines the coverage measure of the validation test suite within the process constraints. Finally, the paper presents the results of the application test selection and optimization process to the design of the CIVC-A test suite.
Making all types typedefed
Authors: Ben-Natan Ron
Published: July 2004

Encapsulation has been recognized as one of the most important methods for assuring that software systems maintenance is made possible. Many modern programming languages
now provide specific constructs for encapsulation
and abstraction. This note emphasizes the fact that the return types of an encapsulation's interface is a part of the interface functions themselves, and as such must also be encapsulated. The examples are given in C++ and encapsulating of the types is done using typedefs.
The culture of quality and software engineering education
Authors: Rout T. P.
Published: July 2004

It is clear that both internal and external pressures within the software development industry will require a much greater focus on effective quality management. The reasons for the slow acceptance of proven quality techniques are canvassed, and it is suggested that cultural obstacles to their use are developed and reinforced through the educational process. Some principles for overcoming the problem are proposed.
Computer-aided vs. manual program restructuring
Authors: Griswold William G. , Notkin David
Published: July 2004

Restructuring a software system as it evolves promises to reduce associated maintenance costs. To simplify restructuring, we have developed a tool that preserves the meaning of a program as the engineer applies structural transformations. To help evaluate the prototype tool and its underlying approach, we ran an experiment to compare how people using standard editing tools restructure a program against the computer-aided style that our tool supports.We drew three conclusions from the experiment. First, the subjects generally used a mix of copy/paste and cut/paste editing paradigms; our tool gives the engineer the safety of copy/paste and the speed of cut/paste. Second, most of the subjects made mistakes, including simple syntactic errors and semantic errors (such as not updating the call site after modifying a function definition); our tool avoids errors by the engineer using compensation (for instance, it automatically updates call sites when a procedure definition is changed) or by signalling an error. Third, manual restructuring tends to be haphazard, with engineers handling the order of changes, testing, etc. in inconsistent and potentially error-prone ways; by separating restructuring from functional maintenance and by ensuring preservation of meaning during restructuring, our approach can make the maintenance process more orderly.
Building an infrastructure to support writing across the computer science curriculum
Authors: Falconer David R. , Katz Martin
Published: July 2004

This paper describes an infrastructure to support efforts to improve communications skills. This infrastructure is designed to support writing throughout the computer science curriculum and the typical deficiencies and attitudes of computer science faculty and majors in the area of interpersonal communications.
The effects of an introductory computer course on the attitudes of older adults towards computers
Authors: Morris J. M.
Published: July 2004

An introductory computer course was offered to adults 60 years and older. A computer attitude survey was administered before and after the course in order to uncover preexisting concerns and reveal those attitudes most affected by the course. Attitudes following the course were marked by highly positive changes. Survey results revealed that after the course the participants felt better acquainted with computer terminology, less left out because they are unfamiliar with computers, less apprehensive about using a computer, and more certain of their ability to interpret a computer printout. An interaction diary maintained by each of the participants revealed enthusiastic learners who were eager to take more courses in the future. Contrary to widely held stereotypes, many older adults view computer technology favorably and can benefit from acquisition of basic computer skills.
Biologically based machine learning paradigms
Authors: Abunawass Adel M.
Published: July 2004

This paper describes an introductory course on biologically based sub-symbolic machine learning paradigms. Specifically, this paper covers Artificial Neural Networks, Genetic Algorithms and Genetics-Based Machine Learning. It provides the structure, motivation, content, texts and tools for the course. This course is suitable for an upper division undergraduate level course or as an introductory graduate course. The paper includes a section on bibliographical references to aid the instructor in preparing for this course.
Teaching loop invariants to beginners by examples
Authors: Tam Wing C.
Published: July 2004

Since the concept of a loop invariant has long been recognized as the correct way to design and analyse loops, it is important that its application to programming be introduced to students and programmers as early as possible. This paper describes how to teach the use of loop invariants to reason about loops and to program them correctly in introductory programming courses by following a systematic set of steps coupled with examples.
Using scientific experiments in early computer science laboratories
Authors: Baldwin Doug , Koomen Johannes A. G. M.
Published: July 2004

Computer science is an experimental science, in the same sense that biology or physics are experimental sciences. Nonetheless, lab exercises for CS1 and CS2 courses are almost never formal “experiments” as the term would be understood in any other science. This paper describes our experiences using formal experiments in CS1 and 2 laboratories. Such exercises are extremely valuable, in part because they help students relate abstract concepts to concrete programs, but more importantly because they lead students into new areas of computing, and even new forms of learning.
On finding a stable roommate, job, or spouse
Authors: Astrachan Owen
Published: July 2004

The use of real world problems as the basis for assignments in Computer Science courses is attractive for many reasons. At the same time it is difficult to find such a problem that offers the same richness that is found, for example, in sorting or searching. In this paper a problem is presented that has many real-world instances and which is pedagogically attractive at all levels of Computer Science from the level of a non-major's course to that of an advanced algorithms course.
Management information systems curricula in the United States and the Republic of China
Authors: Hwang Betty W. , Whinston Andrew B. , Savenye Wilhelmina
Published: July 2004

The purpose of this study was to investigate and compare the Management Information Systems (MIS) curricula in higher education in the United States (U.S.) and the Republic of China (R.O.C.). Several factors that affect the MIS curricula and its development in these two countries were closely examined. Similarities and differences were identified and compared; strengths and weaknesses were analyzed and described.

In particular, this study focused on the undergraduate MIS programs in both countries. Comparisons of the MIS programs were made concerning: MIS program history, MIS program setting, admission requirements and standards, graduation requirements and standards, computer hardware and software facilities, curriculum model adopted, required courses, instructional methods, faculty profiles, student profiles, and relationships with the industry. Based on the findings, some recommendations for improving the Chinese MIS curricula were offered.
A compiler construction project for an object-oriented language
Authors: Temte Mark C.
Published: July 2004

A non-traditional compiler construction project is described for an object-oriented language modeled after Smalltalk. Central issues include implementation of message sending and inheritance and the relationship with the run-time environment. The project offers diversity and challenge and has been successfully completed by small teams.
An interdisciplinary course in digital image processing
Authors: Magee Michael , Englert Sue
Published: July 2004

This paper documents the development and first offering of an interdisciplinary undergraduate course in Digital Image Processing at the University of Wyoming. The course itself was designed to serve majors from a wide range of academic disciplines, although in its initial offering, it was attented mainly by students majoring in Computre Science and Electrical Engineering. National Foundation funding for equipment for the course was used to purchase a high speed image processing system and six state-of-the-art graphics workstations with software that supported basic and intermediate level image processing operations. Students in the course were required to perform a standard set of image processing sequences such as histogramming and histogram equalization, edge detection and evaluation, image smoothing, region growing, Fourier filtering, and image warping. Each student, in consultation with the instructor, then pursued a specific topic in image processing which involved either combining several image processing operations to produce a desired result or developing special code to implement image processing algorithms that were discussed in the text but not included in the provided software. The nature of the course and its impact on education at the University of Wyoming is discussed in the paper that follows.
APPGEN
Authors: Osborne M.
Published: July 2004

APPGEN is a program which generates information systems. It is easy to use and powerful and runs on a VAX under VMS. It has been used with success in senior level courses on systems analysis and design. Using APPGEN, students are able to analyze and design systems of realistic size and still have time to implement them. Implementations give students important feedback about their designs and give additional focus to a class on systems analysis and design. Students get satisfaction from actually creating a working system.
Lectureroom demonstration of serial data communications
Authors: Walker D. K. , Chahryar H. , Chaudri J. , Lodgher A. , Majdalani E. , Tucker David S.
Published: July 2004

Some important concepts in serial data communications may be demonstrated “live” in the lectureroom using a PC equipped with videoprojector, analog input board, and pickup circuitry. The apparatus displays the wave-shape of the serial signal, along with characters sent or received. It has proven useful for “seeing” the signal and for exploring hardware/software setttings, cable type, cable length and other characteristics of a serial interface./
A quantitative approach for teaching parallel computing
Authors: Luque E. , Suppi R. , Sorribes J.
Published: July 2004

Parallel computing teaching has an important difficulty, there are few tools to directly learn the behavior of the parallel algorithms and the parallel architectures. Normally the student is formed to think in sequential algorithms running in sequential machines. We present PSEE, a tool to reduce the gap between the basic concepts and its utilization. PSEE is an integrated and interactive graphic environment which allows to simulate and evaluate the performance of parallel algorithms in parallel architectures. PSEE permits to manage the main characteristic parameters involved in the system in order to show the tuning grade of the algorithm/architecture couple. PSEE includes a graphic editor for algorithms and architectures in modelled form, an interactive simulator to run (simulate) the algorithm on the architecture and a performance evaluation instrument.
Teaching empirical performance analysis of parallel programs
Authors: Fisher A. L. , Gross T.
Published: July 2004

Performance is a central issue in parallel computing. In this paper, we describe our approach to teaching advanced undergraduates and graduate students about the fundamentals of measuring and analyzing the performance of programs running on a variety of parallel machines. This approach can be applied to virtually any type of parallel machine, as well as to parallel program simulators. Although performance analysis can serve many purposes, we focus on the needs of the parallel programmer: understanding the behavior of algorithms and programs, and making informed choices among them.
Understandability of the software engineering method as an important factor for selecting a case tool
Authors: Rozman I. , Györkös J. , Rizmañ K.
Published: July 2004

The article highlights the understandability of a software engineering methodology as an important criterion for selecting a CASE tool. This aspect is treated through the comparison of learning properties for two very well known methodology on which the CASE tools are usually based on. The first one is SA-SD and the second one is JSD. In the purpose to compare both methodology a group of young engineers has been tested. Each of them wrote a seminar theme, answered a questionnaire and explained his observations. At the end of the paper, a general conclusion is presented.
Document classification for software quality systems
Authors: Laitinen Kari
Published: July 2004

Software development origanizations need to have appropriate document control policies. A software document classification can serve as a framework for establishing such policies. This paper presents a software document classification and discusses the quality system functions needed for each class of documents. Software development is viewed as a documentation process, and documents are considered the most essential products of the development process. Referring to the document classification, new definitions for the concept of software are given, and the general difficulties of software documentation are analyzed.
A diagnostic view on information technology
Authors: Saradhi Motamarri
Published: July 2004

Computers, computerization, Systems Analysis, Systems Design etc., have become the catchwords of the day. In majority of the cases
analysis
is interpreted in the narrow sense as
the study of the existing system
in view of computerizing its operations. The thrust for computerization is emphasized without any relevance to the context of application.The real power of the computer, its limitations, and level of applicability are not properly thought of. Computerization at most, is one facet of Information Technology; is surprisingly overlooked. The aim of this article is to drive home the point that a much rational thought and approach are mandatory to get fruitful benefits out of Information Technology.
An undergraduate project to compute minimal perfect hashing functions
Authors: Trono John A.
Published: July 2004

Some heuristics for computing the character weights in a Cichelli-style, minimal perfect hashing function are given. These ideas should perform best when applied to relatively small, static sets of character strings and they can be used as the foundation for a large programming assignment. An example using the names of the fifty United States is given to illustrate how the weights are determined.
An examination of operating systems laboratory techniques
Authors: Withers James M. , Bilodeau Mark B.
Published: July 2004

Students majoring in computer science at the United States Military Academy (USMA) must take a course in operating systems. In this course the students complete a series of laboratory projects to learn the basic concepts of modern computer operating systems. During the last three semesters, our operating system laboratory scheme evolved (1) from having the students master a series of separate, unconnected projects (2) to modifying an existing operating system simulation (3) to finally having them completely build an operating system. This article will discuss each approach, its strengths and weaknesses and the rationale for changing to our current program.
HyperWeb
Authors: Ferrans James C. , Hurst David W. , Sennett Michael A. , Covnot Burton M. , Ji Wenguang , Kajka Peter , Ouyang Wei
Published: July 2004

Software productivity and quality will increase as we improve our model of software and develop tools to support that model. Development environments must take into account that software is more than source; that it is more than text; and that it forms a highly interconnected web of information. Because more time is spent understanding and maintaining software than creating it, environments should strongly support browsing and reading. Finally, environments must be easy to customize.

In this paper we present HyperWeb, a framework that supports the construction of hypermedia-based software development environments having this richer view of software. It coordinates the activities of an integrated set of tools through a message server, uses an object-oriented database to store software artifacts, and supports hypermedia linking of these software artifacts. It is built around an interpreter for a general purpose scripting language, allowing for very flexible customization and environment building. We also describe our experience in using it to build an environment that supports software design, development and maintenance on Unix. Its primary features include support for document linking, source code annotation and restructuring, and modification request tracking. It is being used and evaluated internally and at several external sites.
Supporting collaborative software development with ConversationBuilder
Authors: Kaplan Simon M. , Tolone William J. , Carroll Alan M. , Bogia Douglas P. , Bignoli Celsina
Published: July 2004

In this paper we discuss the architecture of the Conversation Builder, an environment for collaborative work, and show how our framework provides a powerful basis for support of collaborative software development activities.
Supporting cooperation in the Marvel process-centered SDE
Authors: Barghouti Naser S.
Published: July 2004

Large scale software development processes often require cooperation among multiple teams of developers. To support such processes, SDEs must allow developers to interleave their access to the various components of the projects. This interleaving can lead to
interference
, which may corrupt the project components. In traditional database systems, the problem is avoided by enforcing serializability among concurrent transactions. In traditional software development, the problem has been addressed by introducing version and configuration management techniques combined with checkout/checkin mechanisms. Unfortunately, both of these solutions are too restrictive for SDEs because they enforce serialization of access to data, making cooperation unacceptably difficult. In this paper, I illustrate the problem and show how the encoding of the software development process in process-centered SDEs can be used to provide more appropriate concurrency control. I present the concurrency control mechanism I developed for the MARVEL SDE. This mechanism uses the process model in MARVEL to support the degree of cooperation specified in the development process.
obTIOS
Authors: Quester Remco
Published: July 2004

An open integrated CAx-framework supplies services to build derived CAx-environments (e.g. for concurrent Engineering (CE), VLSI-design, Software Engineering, etc.) with specialized, integrated in-house or foreign tools. Such integrated tool uses services of the CAx-framework and cooperates with other integrated tools to achieve a common engineering objective like the simulation of a VLSI-circuit. In most CAx-frameworks the integrated tools cooperate indirectly using CAx-framework services like Data Handling or Inter-Tool Communication (ITC).

With obTIOS a high-level approach to control cooperation of integrated tools within a Computer Aided Concurrent Engineering (CACE) environment is introduced. The tools of a CACE-environment are grouped to domains which represent the most coarse, mutually independent, structural unit within the CACE-environment. The way in which the tools of a domain cooperate is described by Encapsulated Composed Activities (ECA). An ECA represents a template of control regarding cooperation-in-the-large and cooperation-in-the-small of tools.
An empirical investigation of menu design in language-based editors
Authors: Toleman Mark A. , Welsh Jim , Chapman Alan J.
Published: July 2004

In program visualization some form of graphics is used to represent some aspect of a program. However, graphics are necessarily expensive with respect to “screen real estate”. Alternatives, therefore, may be required for presentation of certain concepts fundamental to the programmer's model of a program. For example, one graphical representation of a program, written in a block-structured language like Pascal or Modula-2, is the structure chart model of the hierarchical structure of the blocks or modules making up the program. This graphic may be the most appropriate but it may not be conveniently implemented as a menu and a means of “directly” selecting blocks of program code to view or edit. Such graphics are used extensively, for example, in the Garden environment developed at Brown University. An alternative is a text-based list of block names indented to summarize the program's structure. UQ1, a language-based editor developed at the University of Queensland, implements the concept in this manner. Both types of menu structure were examined and compared for efficiency in a direct manipulation style of interaction. In general, there was no significant difference (
P
> 0.05) in time taken by subjects to select items from either style of menu.