bluuebunny/crossref_metadata_2025 huggingface dataset:
Pragmatic problems with step-wise refinement program development
Authors: Diaz-Herrera Jorge L.
Published: July 2004

This paper presents a generalization of two fundamental programming concepts, LOCAL ABSTRACTIONS and GLOBAL ABSTRACTIONS, and a survey of several mechanisms for implementing them. Global abstractions are semantic definitions (of objects) used throughout a program, whereas Local abstractions are refinement steps generated by the subdivision of a problem into subproblems. Global abstractions are very well supported in today's programming languages, but there is no mechanism entirely satisfactory for the "natural" development of programs using top-down step-wise decomposition techniques. Current languages lack means of expressing the hierarchical tree structure of programs. The structure of the program must be retained explicitly, and with varying degrees of detail at different levels corresponding to the way the program was developed. There is an important deficiency in the process of refining the solution to a problem: local abstractions, which describe intermediate stages of the solution, are replaced by their corresponding refinements.In particular, we discuss some inadequacies of "the facto" structuring constructs in modern languages, showing that, for instance, procedures should not be used for represeting refinements, since these are intended to control the "static" program structure (refinements may well represent non-executable pieces of code!). Finally, we propose the introduction of two new DESIGN constructs for developing structured programs which can show and maintain the solutions's structure as produced during the development process.
Software engineering under deadline pressure
Authors: Costello Scott H.
Published: July 2004

Good software engineering methodology can be rendered ineffective by the presence of deadline pressure. A simple model is developed to explain the possible responses to deadline pressure and to show that there is a tendency to divert resources away from software engineering activities under such conditions. Management is identified as being responsible for ensuring that software engineering activities are given adequate resources. A managerial strategy for achieving these ends is suggested.
Programming with small blocks
Authors: Joseph Mark K.
Published: July 2004

Programming style is a highly personalized characteristic of programs. Modular and block structured programming techniques provide many standards for good programming. These techniques are used to develop well designed but only marginally readable code. Similar organizational techniques are not typically applied to code inside subroutines, which is either too small or too specific to be further broken down into subroutines. The result is often obscure subroutine code that makes the maintenance programmer's job extremely difficult. Presented here is a styling technique for intra-subroutine code that groups program statements into "small BLOCKS" of function or conditional constraints. It is shown that this style of formating subroutine code can greatly improve the readability of the average program. The technique is demonstrated in Pascal, C, and Lisp.
Developing reusable software for military systems, why it is needed, why it isn't working
Authors: Coomer T. N. , Comer J. R. , Rodjak D. J.
Published: July 2004

This paper discusses the importance of developing reusable software component libraries for Department of Defense (DoD) military software systems, as well as a few of the main reasons why current approaches are not working. A working definition of software resuability is estabilished and the major goals of reuse are examined. The emphasis of the paper is on the necessary characteristics of a reusable software component as well as the compilation and utilization of reusable component libraries. The roles of UNIX™, Ada®, and C in the development of reusable components are examined. Many of the problems facing the development of adaptable, reusable software components are outlined as well as some possible solutions to these problems. Conclusions are drawn concerning the critical need for these software characteristics in DoD military systems of the future.
Introducing CASE tools into the software development group
Authors: Györkös J. , Rozman I. , Welzer T.
Published: July 2004

Conventional groups for software development try to increase its efficiency with a more advanced approach to all phases of software life cycle. The need for more formal specifications demands the introduction of computer aided tools which base on the empirically confirmed methodologies. The most important task of CASE tools is to unite the methodologies for covering various life cycle phases under one shell. In the paper the problems, appearing in the contact of the tool with the subjects of the developers team are described.
AI based simulation in reusability
Authors: Aiken M. W.
Published: July 2004

This paper presents a knowledge-based approach for selecting and testing modular reusable code. This approach entails three stages: system definition through a system entity structure (SES), SES pruning and model synthesis using an expert system (ES), and the evaluation of candidate design models using discrete event simulation (DEVS). An example of this approach is shown through the development of a Group Decision Support System (GDSS) idea generation tool.
Teaching a graduate expert systems course
Authors: Yue Kwok-bun
Published: July 2004

Because expert systems technology is relatively new, there are only a few papers describing a graduate course on the subject. Most of the described courses were either seminar oriented or centered around a student project, but did not have a complete coverage of the major topics. This paper describes the teaching of a graduate expert system course that has a relatively complete coverage of the subject area. Other additional features of the course include incremental development of the student projects, emphasis on evaluations of tools and projects, as well as using more conventional problems for strengthening expert system shell programming techniques.
Coming to terms with software reuse terminology
Authors: Peterson A. Spencer
Published: July 2004

This article attempts to standardize the use of many terms used in the software reuse literature. Three terms of particular interest -- taxonomy, software reuse, and domain analysis -- and some problems with their usage are discussed. The specific problems with these terms are generalized and several solutions are given, the most important being the introduction of the concept of using reuse process models to provide both context and an overall view of the potential areas of discourse in reuse. Several new terms are proposed for future use; definitions of existing terms that are meaningful in the context of software reuse are also included.
OPIUM
Authors: Ducassé Mireille , Emde Anna-Maria
Published: July 2004

Opium is an extensible debugging environment for PROLOG providing high-level debugging facilities for programmers and debugging experts.
A survey of software functional testing methods
Authors: Omar A. A. , Mohammed F. A.
Published: July 2004

Functional testing is used to find disagreement between the specifications and the actual implementation of the software systems. The method of representing the specification can help to detect inconsistency and incompleteness in it. The various specification representation schemes are outlined in the paper. The basic technique of functional testing of software systems is the black box technique. This technique generates the test data using the information contained in the program's specification, independent of the implemented program's code. Black box testing cannot discover errors contained in the functions which are not mentioned explicitly in the specification. Therefore, a program dependent testing is necessary to discover this type of errors. The paper surveys the different methods of generating test data for both techniques; the black box and the program dependent techniques.
Summary of post-symposium evaluations from 1991 SIGCSE technical symposium on computer science education
Authors: Almstrum Vicki L. , Platt David C.
Published: July 2004

The 1991 SIGCSE Technical Symposium was held March 7-8, 1991, in San Antonio, Texas. A post-symposium evaluation form was made available to all attendees, with the request that it be filled out to assist the '91 committee in evaluating the current symposium and to help future committees in planning their symposia. This article highlights the responses to the evaluation forms and includes excerpts from the chair report, the registration report, and the treasurer's report.
Can computer programming improve problem-solving ability?
Authors: Tu Jho-Ju , Johnson John R.
Published: July 2004

This paper reports the results of a study of the relationship between computer programming skills and problem-solving abilities. Students in two introductory programming courses (FORTRAN and PASCAL) of a large university served as the subjects for this study. Students' problem-solving abilities were assessed during the first month that each computer programming course commenced and again during the final month of the course. Analysis of pretest and posttest results indicated that students who had successfully completed all computer programming course requirements experienced significant improvement in their overall problem skills. Results also suggested that students who had successfully completed computer programming course requirements experienced significant improvement on the logical reasoning section of the problem-solving assessment.
Upsilon Pi Epsilon (UPE)
Authors: Roggio Robert F.
Published: July 2004

It is the role of the university and programs in computer science to provide a quality education in the computing sciences. These activities clearly imply the need to expose the students to the professional societies, such as ACM, IEEE-CS, and DPMA, as appropriate. But in addition, recognition for outstanding scholarship is a must. While other major areas, such as engineering, mathematics, and business have societies through which outstanding students may be recognized for a number of years, the computer science honor society is relatively new.The purpose of this paper is to present not only the general features and organization of the honor society, but, most importantly, to demonstrate the impact of the society on the daily activities of computing science students.
PDP-11 simulator for Apple Macintosh is designed for instructional use
Authors: Fuller Roy
Published: July 2004

We describe a interactive PDP-11 simulator that runs on the Apple Macintosh. The simulator has been extremely easy for students at the University of Arkansas to learn and operate after a fraction of one lecture period of explanation. It has been utilized for three years in two undergraduate courses: computer organization and assemblers, translators & compilers. Compared to using an actual PDP-11 or a simulator (not the author's) running on our University's mainframe, we have found that the students using the Macintosh simulator achieve higher productivity, measured not by the number of lines assembled or executed in a second but by the number of
human hours
spent writing and debugging a program. Students gain a clearer understanding of concepts that are intrinsically dynamic (such as the birth and death of activation records) due to the ease with which (simulated) memory and registers can be monitored during execution.
Computer graphics and parallelism, an interdisciplinary fable
Authors: Schaller Nan C.
Published: July 2004

A tale of collaboration on graphics projects between undergraduate students leads to speculation concerning the ingredients for success in such projects. This article attempts to identify those elements of the academic environment that foster open and collaborative learning.
Developing Ada software without target hardware
Authors: Scarlato Philip P.
Published: July 2004

An analysis of several of the Ada software projects recently completed at the E-Systems ECI Division reveals that although the software is very target specific, a large portion of this software could be developed independent of the target hardware. Only a very small portion of this software could not be developed in some way without the physical target hardware. However, it seems that the projects that experienced the most difficulty in completing the software task had a large portion of the software that was target test dependent. To visualize this software development difficulty, the target test dependent portion of software can be thought of as the small portion of an iceberg's mass that is visible above the water line as illustrated in figure 1 - the greater the mass above the water line, the greater the overall mass of the iceberg, the longer the melt down, and the greater the threat to navigation. Therefore, to reduce the overall navigation threat to project completion, this target test dependent software should be limited in a manner that allows the bulk of the iceberg to be verified and fine tuned independent of the target hardware.This paper discusses software development tactics used to reduce the overall risk in developing software for a project in which hardware and software were developed in parallel and access to the target hardware was limited or unavailable until after the majority of the software was developed. These tactics are useful in partitioning the software into a manageable form, can help prevent the creation of duplicate software development, and can allow Computer Software Component (CSC) integration and test of the majority of the software in the host environment before the target hardware becomes available.
A practical approach to software quality assurance
Authors: Bukovsky Nikolay S.
Published: July 2004

Software quality assurance (SQA) has been recognized as an effective approach to quality problems. This paper reflects INTERPROGRAMA Institute's experience in developing and implementing a SQA program. Topics to be discussed will include: Phased approach to SQA implementation; Management and organization of SQA; Quality measurement; Quality control procedures; Quality measurement tools; Developers' participation in SQA; Anomaly reporting; Quality planning; Defects analysis; INTERPROGRAMA's practical experience and results.
Structured development of graph-grammars for icon manipulation
Authors: Dolado José Javier
Published: July 2004

In this work we are showing a structured process to build a grammar for icon manipulation. We presuppose that the object to be manipulated in the computer screen can be stated as a set of relations among its parts. We describe a procedure to generate a program that manipulates the object, guaranteeing that only objects with those properties will be constructed, and that every instance of that object is allowable. The formation rules for the object are stored in terms of attributed graph-grammars productions.
Perestroika, anyone? A standard for democracy in professional organizations
Authors: Buckley Fletcher J.
Published: July 2004

The IEEE Computer Society has been recently taken to task for being an "old boys" club. Response to these kind of attacks can sometimes be to raise the drawbridge, drop the portcullis and man the battlements. Sometimes, however, it is more productive to sift through the muck and the mire, take a look at the facts and see if a real problem exists. In this particular case, as Al Smith used to say, let's take a look at the record.
Towards an alternative model for software developments
Authors: Jähnichen S , Goos G
Published: July 2004

This paper addresses three distinct but strongly related topics in the life cycle and environments area:•Failure of the traditional life-cycle-model due to missing support for feedback loops.•An alternative model which represents development states and rules of well-structured project progress on the basis of abstract properties of the underlying documents.•Software engineering environment support for the proposed model.
Can software engineering afford to improve the process?
Authors: Scott Gregory J.
Published: July 2004

The purpose of this paper is to raise questions and generate discussion within the software engineering community about the potential impact of software engineering process improvements. This paper begins by providing a few facts about software engineering economics and process improvement benefits followed by three views of those facts: the traditional cost savings perspective; a software engineer's perspective; and a government contractor's perspective. In the last two perspectives, the questions of what is in this for me and is it in my best interests to support process improvement are asked. The conclusion of this paper is that apparently significant changes must be made in the business culture before process improvements can hope to occur.
ToolCASE
Authors: Linos Panagiotis
Published: July 2004

The design and construction of an up-to-date repository of CASE (Computer-Aided Software Engineering) tools, called ToolCASE, is introduced in this paper. ToolCASE is populated with information regarding purchasing, citations and software engineering capabilities of existing CASE tools. Purchasing information, included in ToolCASE, embodies vendors, costs, discounts, hardware and software requirements; the citations encompass various publications on CASE, whereas software engineering capabilities comprise phases of the paradigm automated, software application area targeted and methodologies supported by CASE tools. ToolCASE is designed for people with diverse backgrounds who wish to choose the proper CASE tool for their specific needs. For instance, a project manager can retrieve the name and phone number of the company that develops a particular CASE tool, its price and the first year it was available. A software engineer may request all CASE tools that automate a particular phase of a software engineering paradigm, aim at the development of software for a specific application area or follow a certain methodology. In addition, a researcher could acquire citations on existing CASE tools that meet specific requirements.
Design of an algorithm simulation and animation environment (ASA)
Authors: Mayerhofer Mário André , Pereira de Lucena Carlos José
Published: July 2004

This paper proposes a computer based environment to aid in teaching algorithms. The environment is called ASA (Algorithm Simulator and Animator) and it is being developed for SENAC, a Brazilian company, associated to Brazilian National Commerce Confederation, responsible for technical education.The text discusses difficulties in teaching algorithms and suggests the computer as a tool capable of decreasing existing learning barriers. In this context we present the goal of the ASA project. We review other on going projects also oriented towards teaching about algorithms through computers which bear some influence on our work.In sequence, we present the ASA system's arquitecture. The system's three modules are described as: Algorithm Presentor, Animator (Data Animator and Code Animator) and Constructor.The experience gained in implementing the prototype is reported. Dificulties encountered and even implementation details are also reported. The experience provides insights for the project's future directions.We end by discussing the main research areas in operation, that are results from the experience gained.
A method of acquiring formal specifications from examples
Authors: Jian Lu
Published: July 2004

The acquisition of the formal specification is very important in software development automation. This paper presents a method which combines the concept formation and the antecedent derivation mechanism to accomplish the automatic acquisition of the formal specification from the example specification and the plausibility of the generated formal specification is guaranteed in some sense.
An integrating pedagogical tool based on writing articles
Authors: Côté Vianney , Custeau Guy
Published: July 2004

This article describes a teaching method based on the writing of review or vulgarization articles by the students in their fields of study. The best articles are published in a magazine distributed to data processing managers and practitioners. The advantages of this method and a list of evaluation criteria are presented.
A course in software portability
Authors: Mooney James D.
Published: July 2004

This paper describes an experimental course on the topic of software portability, and initial experience in teaching this course. With the continuing proliferation of both applications and computing environments, the need for portability is being increasingly recognized. A large proportion of the software now being developed will eventually need to be ported to new environments. Yet this topic is missing from most computer science and software engineering curricula.

The course described here was designed to explore practical issues in the development of portable software. Lectures and discussions on portability topics are combined with the ongoing development of a simple software project designed to expose a variety of portability problems. During the course the project is ported to several environments and redesigned to improve its portability.

This course has been taught experimentally with encouraging results. Student assignments have used novel and effective methods to overcome portability barriers. Feedback from student indicates that they have become more aware of portability issues to be considered in software development, and have gained experience with system interface issues in several programming environments.
Undergraduate software engineering laboratories
Authors: Kiper James , Lutz Michael J. , Etlinger Henry A.
Published: July 2004

Recently, both Miami University of Ohio and the Rochester Institute of Technology received NSF grants to develop undergraduate software engineering laboratories. While the general goals of the labs are similar, specific hardware and software selections were driven by differing curricular emphases and educational environments at the two institutions. This paper presents the distinctive characteristics of each school's program, discusses the influence of these features on the selection process, and describes our experiences to date with the resulting labs. The goal is to provide useful information guidance to others considering such facilities.
Raising the self confidence and self esteem of final year female students prior to job interviews
Authors: Teague Joy
Published: July 2004

Published research and anecdotal evidence suggest that women may be disadvantaged when seeking employment. This paper describes a one day seminar on handling job interviews, conducted for female computer science students at the beginning of the final year of their undergraduate degree. Initial evaluations completed by the participants at the time that they participated in the seminar and a survey some six months later have been extremely positive. It appears that, if women are prepared for the interview process, they approach their first interviews with greater confidence and consequently are better equipped to deal with one of the most vital series of interactions that will occur in their lifetimes.
Designing laboratory modules for novices in an undergraduate AI course track
Authors: Aiken Robert M. , Allemang Dean , Wehrle Thomas
Published: July 2004

A current joint project between three institutions in Switzerland has as its goal to create Artificial Intelligence (AI) software in teaching principles of AI at the University level. The modules of this project, the Portable AI Lab (PAIL), illustrate basic concepts of Artificial Intelligence in a uniform and self-contained manner. This paper discusses the design considerations that were adopted in order to make the presentation of this material easier for novice students.
A CPU scheduling simulation from structured programming to object-oriented design
Authors: Tang L. S.
Published: July 2004

Object-oriented programming has become increasingly popular in the past few years. This paper presents a cpu scheduling simulation project that we feel can convince students of the benefits of object-oriented design and spur their interest. We will first describe the project and discuss its solutions in three levels of abstraction:
structure programming
using Pascal,
object-based programming
using Ada, and
object-oriented programming
using C++. We will present our experiences in this assignment and explain why the object-oriented design is the best approach. This paper is intended to serve as a case study in an object-oriented language course or a programming languages course.
Teaching operating systems using Turbo C
Authors: Hughes Larry
Published: July 2004

Operating systems are an example of a subject that, given the right tools, can be taught in a practical manner, allowing students to understand, and hence appreciate, the internal workings of commercial operating systems such as VMS, Unix, or VM. Not surprisingly, the tools needed in an operating systems course are, at a minimum, a hardware testbed and a programming language into which algorithms can be translated. This paper describes how many of the salient points concerning operating systems can be covered in a practical manner using the PC and Turbo C.
Introducing the fuzzy paradigm using Prolog
Authors: Kaminski D. M.
Published: July 2004

This artificial intelligence project introduces students to an alternative to the traditional “crisp” paradigm of computer science through the use of fuzzy sets and linguistic variables for modeling natural language expressions. A fuzzy/linguistic meta-language is built on Prolog. This helps them to explore some of the problems encountered in the human/computer interface of bridging the fuzzy, imprecise symbolic world of natural language and the computer's crisp, numeric world.
The impact of new accreditation and certification standards for secondary computer science teachers on university computer science departments
Authors: Taylor Harriet G. , Martin C. Dianne
Published: July 2004

The establishment of accreditation and certification standards for secondary computer science teachers has been taking place over the past 5 years. The ACM has taken the lead in developing certification standards for adoption by states and the International Society for Technology in Education (ISTE) has taken the lead in developing national accreditation standards for teacher preparation programs through affiliation with NCATE, the accrediting body for professional education units in the USA. The impact of institutionalizing these new standards is discussed, and the role that university computer science departments should now take in the teacher preparation process is described.
Get high school students hooked on science with a challenge
Authors: Cohen M. , Foster M. , Kratzer D. , Malone P. , Solem A.
Published: July 2004

Skilled scientists and engineers along with a public that understands science and technology are vital in today's technically competitive world. The United States must encourage its students to study and excel in scientific academic subjects and consider science and engineering as a possible career.

An academic program that progresses from a statewide to a national competition is a way of developing science and computing knowledge among high school students and teachers, as well as instilling enthusiasm for science. This paper describes the new Mexico High School Supercomputing Challenge, a nonselective academic-year long program that was initiated in 1990. Teams of high school students from throughout New Mexico do a team computational science project using high performance computers.
A course in computer law
Authors: Kay D. G.
Published: July 2004

We describe a course for computer science students that covers the legal issues that apply to computing, from intellectual property protection to liability for system failures to computer crime.
Reviving systems programming
Authors: Wolfe J. L.
Published: July 2004

This paper describes how a systems programming course, which was losing popularity with students and which no longer fit into the curriculum, was revised so that it made a contribution to the overall program. The principal changes were to replace a large, well-worn project with a collection of small challenges and to alter radically the content, presentation, support, and grading of these challenges (in comparison to typical assignments). The resulting course amalgamates traditional systems programming and systems programming as it is done on the job.
Detection of similarities in student programs
Authors: Wise M. J.
Published: July 2004

It has argued that systems for detecting similarities in submitted programs must be based on the analysis of program structure. One such system is “Plague”. In this paper, some difficulties with the Plague system are outlined and a new system is described that achieves the same goals as Plague, but in a way that is both more portable and more easily customized to new target languages.
Software engineering from a practical perspective
Authors: Saradhi Motamarri
Published: July 2004

The development of software is a marathon feat. Software Quality Assurance is a much more difficult and challenging task. Further, putting the software for live use, is a still more complex affair. These matters are not trivial for successful and appropriate exploitation of computers and Information Technology, rather they are the central issues one must answer first. Motivated by the ongoing discussions on a plenty of issues related to software, (software technology!) including standards and quality assurance, I am translating my experiences as the mentioned issues are duly represented in my systems development projects. Perhaps, this is an attempt to bring to light the prominent but less addressed points, especially that are lying at the interface of the several disciplines related to software creation. I present a generic structure of
Systems Development Process (SDP)
from a practical view point. The presentation will outline the framework of SDP, and the environment in which it takes place to illustrate the line of thinking that has influenced the creation of successful application systems developed in several domains.
Simulating procurement in the classroom
Authors: Berry Michael W.
Published: July 2004

The process known as procurement is commonly used by academia, industry, and government to acquire the most suitable computer system for their particular working environments. The challenge is to purchase machines yielding the desired performance given certain constraints in funding. The guidelines used in the acquisition of equipment can vary from customer to customer. Similarly, the demonstration of machine performance by computer vendors may differ according to the market type and share they control. In this paper, we describe a project from a recent graduate course on Performance Evaluation within the Department of Computer Science at the University of Tennessee, Knoxville, concerning a simulation of the procurement process by studying the interactions between computer vendors and the scientific community (academia, industry, and government). The goals of this project were: (
i
) to define and interpret the scientific methods used by customers to acquire their equipment, (
ii
) to equate computational work with machine performance and make cost-effective purchases, (
iii
) to select appropriate hardware/software for customer's needs, (
iv
) to determine effective methods of performance presentation, and (
v
) to investigate the psychology of vendor-customer relations within a scientific computing environment.
Using Harel statecharts to model object-oriented behavior
Authors: Walters Neal
Published: July 2004

Object-oriented analysis and design methods are increasingly being considered for complex system development. However, object-oriented implementations can introduce run-time inefficiencies. Therefore, predicting system behavior is an important simulation objective for validating completeness and analyzing performance. There are two contributors to system behavior - the individual behavior of each object and the collaborative behavior of object when executing scenarios required by the system. Modeling the collaborative interaction of objects is the primary subject of this paper. Templates for three types of objects are presented: Director, Agent and Server object classes. The mechanisms presented in this paper utilize Harel state diagram notation as supported by the Statemate CASE tool.
Manpower profiling for information technology
Authors: Hosny H. M. , Akabawy M. S. , Gough T. G.
Published: July 2004

Information Technology (IT) is finding its way rather too quickly into the job markets in the developing countries. There is a growing demand for IT trained staff but no specific dimensions have been provided for the types of graduates needed in the local marketplace.A survey has been carried out of a wide cross section of IT employers in Egypt, as a typical example of a developing country with great potential for technological advancement. The objective of the survey was to identify the employers' present employment patterns as well as their needs for trained personnel in the IT field, at present and in the near future.
Concurrency with semaphores
Authors: Hilzer Ralph C.
Published: July 2004

Concurrency is introduced in most operating systems textbooks, but usually, only the basics of synchronization and mutual exclusion are presented. The more complicated examples are invariably
canned
code such as the producer/consumer or readers/writers problems. This paper explores semaphores at an intermediate level by using them to coordinate the activities of a barbershop. The obstacles encountered when attempting to provide tailored access to barbershop resources are similar to those encountered in a real operating system.
Developing and integrating ProDAG in the Arcadia environment
Authors: Richardson Debra J. , O'Malley T. Owen , Moore Cynthia Tittle , Aha Stephanie Leif
Published: July 2004

ProDAG is an analysis toolset that provides an application programmatic interface for program dependence analysis. Program dependences are syntactic relationships between program statements. The ProDAG interface provides a uniform set of operations for creating and accessing several pre-defined dependence relations, which are represented as graphs, as well as a standard mechanism for developing new dependence graphs. ProDAG is one analysis toolset in Arcadia, ProDAG was developed in the Arcadia environment and has been integrated with the language processing, oject management, and process definition components of the Arcadia architecture, and further integration with the user interface development system and the measurement and evaluation components are underway. This paper describes the design, implementation and integration of proDAG within Arcadia.
The Proteus presentation system
Authors: Graham Susan L. , Harrison Michael A. , Munson Ethan V.
Published: July 2004

Software development environments can increase user productivity by presenting information in more useful ways. This paper describes Proteus, the presentation system of Ensemble, a software development environment that supports a wide variety of language and document capabilities. Proteus provides a set of services which allow the appearance of software development documents, such as programs or design specifications, to be determined by formal specifications of style. Proteus is based on a generic model of presentation services and is intended for use with a wide variety of media.
Teaching computer science through writing
Authors: Taffe William J
Published: July 2004

Student difficulty in expressing computing concepts in clear, concise English has stimulated me to introduce a writing assignment into various Computer Science courses. This article describes the problem, the goals of the assignment, and student improvement and reaction.
A note on slowing Quicksort
Authors: Chaudhuri R. , Dempster A. C.
Published: July 2004

We present a simple linear time algorithm for generating a worst case sequence for Quicksort when the pivot element is chosen as the middle elements of the (sub)array in each pass.
Necessity is the mother of language features
Authors: Carrasquel Jacobo
Published: July 2004

A common problem when teaching CS1 courses to non-CS majors is students' lack of motivation. This paper describes a new approach and methodology intended to solve this problem: The new approach involves a different sequencing of topics covered in most CS1 courses, and the division of the course into four units; thus exposing students to four different problems of moderate length and degree of difficulty. The new methodology consists of presenting students with problems for which the programming features learned up to that point are inadequate to solve the task. Thus, instead of presenting topics (language features) followed by a series of problems which require the student to apply specific tools, I introduce problems which create a need for new language features. This way students feel more motivated to explore new venues and participate more effectively in the decision-making process.
Schlaer-Mellor object-oriented analysis rules
Authors: Lang Neil
Published: July 2004

Shlaer-Mellor Object Oriented Analysis provides a complete and executable description of a problem domain using a set of formal analysis models: an information model, a set of state models, and a set of process models. In this paper we present the conditions that must be satisfied by a valid Shlaer-Mellor Object Oriented Analysis.
The object-oriented brewery
Authors: Sharble Robert C. , Cohen Samuel S.
Published: July 2004

Interest in object-oriented methods has been rapidly increasing, as software developers and project managers try to reduce escalating development and maintenance costs. There is an increasing need to determine if there are differences in effectiveness between various methods of object-oriented software development, and whether techniques from more successful methods can be extracted and applied to improve other methods.This paper reports on research to compare the effectiveness of two methods for the development of object-oriented software. These methods are representative of two dominant approaches in the industry. The methods are the responsibility-driven method and a data-driven method that was developed at The Boeing Company and taught in a course available to the public.Each of the methods was used to develop a model of the same example system. A suite of metrics suitable for object-oriented software was used to collect data for each model, and the data was analyzed to identify differences.The model developed with the responsibility-driven method was found to be much less complex, and specifically to have much less coupling between objects and much more cohesion within an object.
Discrete mathematics II
Authors: Brown David T.
Published: July 2004

This is a report on the second of a two course sequence in discrete mathematics taught at Ithaca College. The course covers three topics, combinatorics, finite state automata and regular languages and verification theory, and is a prerequisite for a theoretical course in computer science. The emphasis in this paper is the half semester spent teaching verification theory.
The object-oriented paradigm in the undergraduate curriculum
Authors: Mazaitis Dorothy
Published: July 2004

Many undergraduate computer science programs have not yet incorporated the object-oriented paradigm into their curriculum or have done so only minimally. Furthermore, programs which do teach object-oriented design and programming do so in a variety of ways. This paper presents a survey of different approaches to incorporating the object-oriented paradigm into the undergraduate curriculum. Data were complied from experiences related in the current literature and from a survey of undergraduate programs in Connecticut. To round out the discussion, feedback from local industry with regard to its use of this methodology is included: specifically, is there a need for proficiency in object-oriented design and programming?
Mechanisms for generic process support
Authors: Balzer Robert , Narayanaswamy K.
Published: July 2004

As more and more programming environments incorporate explicit process descriptions, generic process capabilities will become crucial to the convenient instantiation and maintenance of process description. However, partly because process modeling languages have followed the example of programming languages in general, they are surprisingly weak in supporting generic process descriptions.We propose mechanisms whereby generic process capability can be added to any process formalism. The generic portions of the process description can then be
refined
through instantiation. We define a system architecture in which a generic process description can be refined gradually
during its enactment
. Such capabilities will be crucial to incorporating explicit process descriptions into the program environments of the future.
Does every inspection need a meeting?
Authors: Votta Lawrence G.
Published: July 2004

At each step in large software development, reviewers carry out inspections to detect faults. These inspections are usually followed by a meeting to collect the faults that have been discovered. However, we have found that these inspection meetings are not as beneficial as managers and developers think they are. Even worse, they cost much more in terms of products development interval and developer's time than anyone realizes.Analysis of the inspection and collection process leads us to make the following suggestions. First, at the least, the number of participants required at each inspection meeting should be minimized. Second, we propose two alternative fault collection methods, either of which would eliminate the inspection meetings altogether: (a) collect faults by deposition (small face-to-face meetings of two or three persons), or (b) collect faults using verbal or written media (telephone, electronic mail, or notes).We believe that such a change in procedure would increase efficiency by reducing production times without sacrificing product quality.
Enhancing compositional reachability analysis with context constraints
Authors: Cheung S. C. , Kramer J.
Published: July 2004

Compositional techniques have been proposed for traditional reachability analysis in order to introduce modularity and to control the state explosion problem. While modularity has been achived, state explosion is still a problem. Indeed, this problem may even be exacerbated as a locally minimised subsystem may contain many states and transitions forbidden by its context or environments. This paper presents a method to alleviate this problem effectively by including context constraints in local subsystem minimisation. The global behaviour generated using the method is observationally equivalent to that generated by compositional reachability analysis without the inclusion of context constraints.Context constraints, specified as interface processes, are restrictions imposed by the environment on subsystem behaviour. The minimisation produces a simplified machine that describes the behaviour of the subsystem constrained by its context. This machine can also be used as a substitute for the original subsystem in the subsequent steps of the compositional reachability analysis. Interface processes capturing context constraints can be specified by users or automatically constructd using a simple algorithm. The concepts in the paper are illustrated with a clients/server system.
Designing programs to check their work (abstract)
Authors: Blum Manuel
Published: July 2004

Designing Programs to Check Their Work Professor Manuel Blurn
Department of EECS UC Berkeley and International Computer Science
Institute Berkeley, California Abstract Students, engineers,
programmers... are all expected to check their work. Computer
programs are not. There are several reasons for this: 1. Computer
hardware almost never makes errors -- but that fails to recognize
that programmers do! 2. Programs are hard enough to write without
having to also write program checkers for them -- but that is the
price of increased confidence! 3. There is no clear notion what
constitutes a good checker. Indeed, the same students and
engi-neers who are cautioned to check their work are rarely
informed what it is that makes a proce-dure good for doing so --
but that is just the sort of problem that computer science should
be able to solve! In my view, the lack of correctness checks in
programs is an oversight. Programs have bugs that could perfectly
well be caught by such checks. This talk urges that programs be
written to check their work, and outlines a promising and rigorous
approach to the study of this fascinating new area.
Faults on its sleeve
Authors: Hamlet Dick , Voas Jeff
Published: July 2004

Most of the effort that goes into improving the quality of software paradoxically does not lead to quantitative, measurable quality. Software developers and quality-assurance organizations spend a great deal of effort preventing, detecting, and removing “defects”—parts of software responsible for operational failure. But software quality can be measured only by statistical parameters like hazard rate and mean time to failure, measures whose connection with defects and with the development process is little understood.

At the same time, direct reliability assessment by random testing of software is impractical. The levels we would like to achieve, on the order of 10
6
- 10
8
executions without failure, cannot be established in reasonable time. Some limitations of reliability testing can be overcome but the “ultrareliable” region above 10
8
failure-free executions is likely to remain forever untestable.

We propose a new way of looking at the software reliability program. Defect-based efforts should
amplify
the significance of reliability testing. That is, developers should demonstrate that the actual reliability is better than the measurement. We give an example of a simple reliability-amplification technique, and suggest applications to systematic testing and formal development methods.
STATEMATE applied to statistical software testing
Authors: Thévenod-Fosse P. , Waeselynck H.
Published: July 2004

This paper is concerned with the use of statistical testing as a verification technique for complex software.
Statistical testing
involves exercising a program with random inputs, the test profile and the number of generated inputs being determined according to criteria based on program structure or software functionality. In case of complex programs, the probabilistic generation must be based on a black box analysis, the adopted criteria being defined from
behavior models
deduced from the specification. The proposed approach refers to a hierarchical specification produced in the
STATEMATE
environment. Its feasiblity is exemplified on a
safety-critical module
from the nuclear field, and the efficiency in revealing
actual faults
is investigated through experiments involving two versions of the module.
Mutation analysis using mutant schemata
Authors: Untch Roland H. , Offutt A. Jefferson , Harrold Mary Jean
Published: July 2004

Mutation analysis is a powerful technique for assessing and improving the quality of test data used to unit test software. Unfortunately, current automated mutation analysis systems suffer from severe performance problems. This paper presents a new method for performing mutation analysis that uses
program schemata
to encode all mutants for a program into one
metaprogram
, which is subsequently compiled and run at speeds substantially higher than achieved by previous interpretive systems. Preliminary performance improvements of over 300% are reported. This method has the additional advantages of being easier to implement than interpretive systems, being simpler to port across a wide range of hardware and software platforms, and using the same compiler and run-time support system that is used during development and/or deployment.