bluuebunny/crossref_metadata_2025 huggingface dataset:
The patterns business
Authors: Viljamaa Panu
Published: July 2004

Monticello - Illinois was the place that hosted PLoP-94 (The first Conference on Pattern Languages of Programs) 4th - 6th August 1994. Here I'll summarize the insights into the nature of 'Patterns' and 'Pattern Languages' I gained. The intended reader works with software development but is more generally anybody trying to improve the quality of intellectual tasks.
A distributed virtual machine to support software process
Authors: Ambriola Vincenzo , Cignoni Giovanni A.
Published: July 2004

The availability of new technologies increases, at least potentially, the chance to support
cooperative work
exploiting the many resources offered by computer networks. This opportunity is impaired by the lack of tools able to manage the large variety of network resources at an adequate level of abstraction. This lack is particularly felt in the implementation of
software process
support environments.In this paper we describe how, in Oikos, we realized the distributed run-time support to process enactment. On the basis of this experience, we claim the need of a homogenous framework that overcomes this limitation. We propose oiXos, a
virtual machine
that abstracts a network of Unix workstations, disk servers, and X Window terminals. We introduce the notions of
component, item,
and
gibject.
Upon these notions we build the abstraction level given by the oiXos virtual machine. We discuss the oiXos architecture that relies on a collection of system components that manage the objects of the oiXos machine.
Experiences and lessons from the analysis of TCAS II
Authors: Heimdahl Mats P. E.
Published: July 2004

This report highlights some of the experiences gathered while analyzing the requirements specification for a commercial avionics system called TCAS II (Traffic alert and Collision Avoidance System II) for consistency and completeness. Completeness in this context is defined as a complete set of requirements, that is, there is a behavior specified for every possible input and input sequence.Under the leadership of Dr. Nancy G. Leveson, the Irvine Safety Research Group has developed a state-based requirements specification language RSML (Requirements State Machine Language) using TCAS II as a testbed [6]. The TCAS requirements specification project was very successful; RSML was well liked by all participants in the project, and the formal specification has been adopted as the official TCAS II requirements. The requirements document has been delivered to the FAA and has undergone an extensive independent validation and verification effort (IV&V).In a previous investigation, we defined procedures for analyzing state-based requirements specifications for completeness and consistency [5]. To demonstrate that our approach is feasible and is applicable to realistic systems, we have implemented a draft analysis tool and we have applied the analysis to the TCAS II requirements. The initial results from the analysis effort were encouraging [4, 5] and scaled well to a large requirements specification. The most complex parts of the TCAS requirements specification have recently been analyzed. Even though the effort was largely successful, some limitations with the approach have surfaced. Most importantly, the accuracy of the analysis algorithms needs improvement. When analyzing the most complex parts of the TCAS requirements, the number of spurious error reports can occasionally be overwhelming. Furthermore, we discovered that once the analysis has identified problems, it has been unexpectedly difficult to correct some of them.
Critical slicing for software fault localization
Authors: DeMillo Richard A. , Pan Hsin , Spafford Eugene H.
Published: July 2004

Developing effective debugging strategies to guarantee the reliability of software is important. By analyzing the debugging process used by experienced programmers, we have found that four distinct tasks are consistently performed: (1) determining statements involved in program failures, (2) selecting suspicious statements that might contain faults, (3) making hypotheses about suspicious faults (variables and locations), and (4) restoring program state to a specific statement for verification. This research focuses support for the second task, reducing the search domain for faults, which we refer to as
fault localization.
We explored a new approach to enhancing the process of fault localization based on dynamic program slicing and mutation-based testing. In this new approach, we have developed the technique of Critical Slicing to enable debuggers to highlight suspicious statements and thus to confine the search domain to a small region. The Critical Slicing technique is partly based on "statement deletion" mutant operator of the mutation-based testing methodology. We have explored properties of Critical Slicing, such as the relationship among Critical Slicing, Dynamic Program Slicing, and Executable Static Program Slicing; the cost to construct critical slices; and the effectiveness of Critical Slicing. Results of experiments support our conjecture as to the effectiveness and feasibility of using Critical Slicing for fault localization.This paper explains our technique and summarizes some of our findings. From these, we conclude that a debugger equipped with our proposed fault localization method can reduce human interaction time significantly and aid in the debugging of complex software.
Beyond traditional program slicing
Authors: Sloane Anthony M. , Holdsworth Jason
Published: July 2004

Traditional program slices are based on variables and statements. Slices consist of statements that potentially affect (or are affected by) the value of a particular variable at a given statement. Two assumptions are implicit in this definition: 1) that variables and statements are concepts of the programming language in which the program is written, and 2) that slices consist solely of statements.Generalised slicing is an extension of traditional slicing where variables are replaced by arbitrary named program entities and statements by arbitrary program constructs. A model of generalised slicing is presented that allows the essence of any slicing tool to be reduced to a node marking process operating on a program syntax tree. Slicing tools can thus be implemented in a straight-forward way using tree-based techniques such as attribute grammars.A variety of useful program decompositions are shown to be instances of generalised slicing including: call graph generation, interface extraction, slicing of object-oriented inheritance hierarchies and slices based on type dependences. Examples are also given of how slicing can enhance understanding of formal compiler specifications and aid the creation of subset language specifications.
Using partial-order methods in the formal validation of industrial concurrent programs
Authors: Godefroid Patrice , Peled Doron , Staskauskas Mark
Published: July 2004

We have developed a formal validation tool that has been used on several projects that are developing software for AT&T's 5ESS
™
telephone switching system. The tool uses Holzmann's supertrace algorithm to check for errors such as deadlock and livelock in networks of communicating processes. The validator invariably finds subtle errors that were missed during thorough simulation and testing; however, the brute-force search it performs can result in extremely long running times, which can be frustrating to users. Recently, a number of researchers have been investigating techniques known as
partial-order methods
that can significantly reduce the running time of formal validation by avoiding redundant exploration of execution scenarios. In this paper, we describe the design of a partial-order algorithm for our validation tool and discuss its effectiveness. We show that a careful compile-time static analysis of process communication behavior yields information that can be used during validation to dramatically improve its performance. We demonstrate the effectiveness of our partial-order algorithm by presenting the results of experiments with actual industrial examples drawn from a variety of 5ESS
™
application domains, including call processing, signalling, and switch maintenance.
A proposed methodology for knowledge based systems development
Authors: McManus Joe , Vergruggen Renaat
Published: July 2004

This paper proposes a new methodology for the development of Knowledge Based Systems (KBS). The key characteristics of knowledge based systems are examined, with particular emphasis on those aspects of developing such systems which differentiate them from more conventional development approaches. Existing KBS development methodologies are considered, and some of the important aspects of these methodologies are adopted/adapted within the new methodology, which seeks to define a methodological approach which satisfies the key requirements of knowledge-based systems development, while ensuring that the key managerial aspects of a methodological approach are also catered for. The proposed methodology is then assessed in the light of the particular difficulties of the paradigm which it seeks to address.
The wild-west revisited
Authors: Pitts David R. , Miller Barbara H.
Published: July 2004

In 1985 Mark Spinrad and Curt Abraham published; "
The Wild West Lifecycle (WILI)
" [1] which, although written with a slightly irreverent tongue-in-cheek style, introduced a significant metaphor for the software engineering lifecycle. In this paper we will discuss briefly the importance of software metaphors in general, and then revisit and expand the Wild West analogy.
Essential C++
Authors: Grout Jarrell C. , Strader Robert G. , Hanks John B.
Published: July 2004

C++ is rapidly becoming one of the most important programming languages in the world. Yet it is an extremely complex language and, therefore, one that is very difficult to learn. To provide a significant degree of simplification and, thereby, to help alleviate the difficulties of learning the language, a relatively small C++ subset, Essential C++, has been defined. It is proposed for use by the computer science academic community as a suitable first programming language for students as well as for use by other individuals who desire eventually to become software developers using the full C++ language.After supporting the case for the need of a C++ subset and discussing the reasons for developing one, this article presents Essential C++, provides the rationale for selecting its particular constituents from the full C++ language, and then examines the advantages and disadvantages of using Essential C++.
History in the computer science curriculum
Authors: Lee John A. N.
Published: July 2004

IFIP Working Group 9.7 (History of Computing) is charged with not only encouraging the preservation of computer artifacts, the recording of the memoirs of pioneers, and the analysis of the downstream impact of computer innovations, but also on the development of educational modules on the history of computing. This paper presents an initial report on the study of the history of computing and informatics and preliminary proposals for the inclusion of aspects of the history of computing and informatics in the curriculum of university and college students.
Learning to teach C++
Authors: Ross John Minor
Published: July 2004

Object-oriented programming, which came on the scene with Simula-67, is continuing to grow in popularity. C++, the object-oriented expansion of C, is one of the most used languages associated with object-oriented programming. Much of what is written about C++, however, is directed towards those already immersed in the object-oriented paradigm. Such writings often are not useful to C language instructors just beginning to work with C++ since there is a considerable learning curve for novices and experts alike. Readers who are C-literate are (1) presented with reasons to move to C++, (2) warned of potential hazards on the object-oriented path, and (3) provided with heuristics to make the transition from C to C++ easier.
Use of computer conferencing in teaching systems analysis and design
Authors: Baram Giora , Mandviwalla Munir
Published: July 2004

This article describes how the Department of Computer and Information Sciences (CIS) at Temple University uses a computer based "bulletin board" system to improve our Systems Analysis and Design Courses. We found that the use of the bulletin board improves the communication skills of students and increases the productivity of both instructor and student. While the article is descriptive rather than empirical, we believe it offers useful insights for other instructors who share our concerns and are interested in the use of computer based communication technology to improve teaching.
Evaluating software engineering methods and tool—part 3
Authors: Kitchenham Barbara Ann
Published: July 2004

In the first article about the DESMET evaluation methodology, I identified nine different types of evaluation:1. Quantitative Experiments2. Quantitative Case Studies3. Quantitative Surveys4. Feature Analysis --- Screening mode5. Feature Analysis --- Case Study6. Feature Analysis --- Experiment7. Feature Analysis --- Survey8. Qualitative Effects Analysis9. Benchmarking.In the last article I discussed various technical criteria that would influence your choice of an evaluation method. In principle, you should select the simplest evaluation method appropriate for your specific evaluation requirements and organisational capability. However there are a number of constraints that can influence your final choice of evaluation method:• the
elapsed time
that is needed for the different evaluation options;• the
confidence
that a user can have in the results of an evaluation;• the
cost
of an evaluation;This information may be useful in two circumstances:1. When you want to decide between a quantitative case study and a quantitative formal experiment and there are no clear technical reasons for preferring one to the other.2. When you want to ensure that the evaluation you have decided to undertake is feasible.These issues are discussed in this article.
Requirements-driven software test
Authors: Ramachandran Muthu
Published: July 2004

Testing is essential for proving the quality of all products. It is expensive and hard to test interactive multimedia systems. This paper proposes a model for the test process, and investigates the possibility of deriving test cases from system models and requirement analysis techniques such as requirements definition and specification. We believe this will allow early detection of errors thereby reducing the cost for testing. These test cases can also be used as guidelines on design for testability. Effectiveness of the test tools depends on the careful selection of test cases.
An algebra approach to the deduction of data flow diagrams and object oriented diagrams from algebraic specifications
Authors: Vazquez Federico
Published: July 2004

The Software Engineering procedures usually lack formal mathematical foundations. This paper presents a formal approach for the development of Specifications, Data Flow Diagrams and Object Oriented Diagrams using algebraic theory. The use of algebraic theory allows the check for completeness and consistency and the generation of automatic procedures for translating specifications into Data Flow Diagrams or Object Oriented Diagrams.
Organization of final year projects
Authors: Dawson-Howe Kenneth M.
Published: July 2004

This paper details a method for the organization of final year computer science projects which has been found to be extremely beneficial both from the point of view of the students and the supervisor. These projects count for 20% of the final degree result in this Department, and are a crucial part of the development of the student.The model proposed for the organization of the projects is one in which the students initially work in a group, co-operatively developing a basic platform on which they can then individually develop their projects. This organization allows the supervision to be achieved through regular group meetings, and provides the students with good experience (and all the benefits) of working in a group, while at the same time fulfilling the objective of getting the student to work on a complex task independently. An example of this project organization in practice, in the field of computer vision, is also detailed.
C++ dynamic arrays vs. linked lists
Authors: Zaidman Marsha
Published: July 2004

Dynamically allocated linked lists are generally portrayed as a more flexible structure than arrays. However, dynamically allocated arrays, as available in C++, can be just as flexible and easier to use. This paper compares the use of dynamically allocated linked lists to dynamically allocated arrays as available in C++.
Structure exits, not loops
Authors: Ben-Ari Mordechai
Published: July 2004

Until recently, Pascal was the first programming language taught to students. As more schools choose Ada or C++ as a first language, the debate on structured programming has been reopened ([Rob95]). We are no longer restricted to the while-statement: exit/break-statements can be used to exit a loop from the middle, and return from a procedure or function is allowed within a loop statement. Do these constructs violate the principle of structure programming? This article claims that more general loop constructs can be objectively justified, because they simplify the verification of programs. A program that is simple to verify is also easy to explain and understand.
Command-line usage in a programming exam
Authors: Greening Tony
Published: July 2004

Introductory computer science education has a strong emphasis on the teaching and learning of programming skills. In establishing that a desired level of proficiency in the use of these skills has been attained, many courses implement a practical exam where students must complete a program and get it to run correctly under supervision and unaided. This exam may, as in our case, be presented as a "barrier" exam which must be passed in order to proceed to intermediate computer science enrolment. The importance of such an event is not always matched by our understanding (as educators) of student behaviour under such conditions. The binary (pass/fail) nature of the exam tends to be reflected in student perceptions of the exam, often polarised as being "quite easy" by those who pass or "too difficult" by those who fail. This paper describes an exploration into command-line behaviour during the exam, in an attempt to gain some insight into student behavioural reaction to it. In so doing, the issue is raised as to whether or not certain actions are more likely to serve as indicators of a successful candidate, and what meaning this has for teachers and students.
User responses to constraints in computerized design tools (extended abstract)
Authors: Day Donald L.
Published: July 2004

This study sought to improve our understanding of user attitudes, perceptions, satisfaction and behavior in reference to constraints within computerized design tools. It also attempted to examine the differences in perspective between tool builders and tool users regarding appropriate design practices, as communicated via design tools.The study created a typology of constraints and described a set of strategies users employ in the negotiation of constraints encountered in of computer-aided systems engineering (CASE) tools. Also addressed were (a) the cognitive fit between tool users and tool builders in terms of appropriate and necessary constraints, and (b) issues of creativity in the design of computer software.An eight-page questionnaire containing 61 questions was developed by conducting structured interviews with tool users and managers, in industry. Following a pre-test, the questionnaire was administered to an international sample of tool users, tool builders and non-CASE software application developers (a control group). More than 200 questionnaires were returned (half via electronic mail) from respondents largely in North America, but also from Europe, Australia and New Zealand.Analysis followed a factorial design that evaluated the impact of normative attitudes toward and perceptions of control upon satisfaction and behavior. Most respondents reported not feeling especially encumbered with constraints in their tools, although most also reserved the right to override or work around constraints, depending upon circumstances.The study found that normative attitudes toward control have a significant impact upon behavior in response to constraints in computerized design tools. (Favorable attitudes toward control are associated significantly with conforming behavior.) It also found that perceptions of control have a significant impact upon satisfaction and behavior. (Perceptions of high control are associated significantly with low satisfaction and with resistant behavior.) No significant differences were observed between tool users and tool builders in terms of key constructs.Suggestions for future research include investigation of concerns raised by the current study, examination of similar effects in other domains (such as architectural design), and development of the potential for intelligent machine guidance in creative design activities.
Building testable software
Authors: Zucconi Lin , Reed Karl
Published: July 2004

This paper examines a connection between well known specification, design, implementation methodologies and test-design which appears not to have been previously well-formulated. We refer to the fact that the use of finite state machines (FSMs) in each development phase (specification, design, implementation and testing) is well known and documented. However, despite the fact that much of this work is more than twenty years old, there appears to be no detailed proposal for a consistent FSM-based approach be used across all development phases for other than very specific application types. We suggest that the adoption of a systematic FSM-based approach across all phases, including implementation, may allow a number of major problems in software development to be either eliminated or simplified. In this way, testable, highly dependable systems can be produced. In such systems, behaviour is explicitly defined, built, and tested using both functional and structural methods. Undesired behaviours can be found and eliminated, and abnormal or unexpected input explicitly handled. We discuss the issues we consider to be involved, and the benefits which we expect may be gained. We also identify those areas where further work appears to be required.
Egret
Authors: Johnson Philip
Published: July 2004

Egret is a publically available, advanced framework for construction of computer-supported cooperative work applications. Egret provides an approach to multi-user, interactive application development that differs markedly from other frameworks or infrastructures, such as Groupkit, WWW, or Lotus Notes. This short paper introduces Egret, its architecture, design philosophy, selected applications, and interest groups within the software engineering community. It concludes with information on how Egret's sources, binaries, and documentation may be obtained free of charge using the Internet.
Using test case metrics to predict code quality and effort
Authors: Harrison R. , Samaraweera L. G.
Published: July 2004

This paper reports on an investigation into the use of a design metric (the number of test cases) to predict code quality, development and testing time during the production of functional and object-oriented programs. We report on whether a significant difference exists in the number of test cases for equivalent functional and object-oriented programs as well as determining whether these test cases metrics are correlated with various development and design metrics for the different paradigms. The results of this investigation suggest that test case metrics could be used both as indicators of code quality and to predict the development and testing effort required for functional and object-oriented programs.
Object-centered design
Authors: Adams Joel C.
Published: July 2004

With Pascal waning in popularity as the CS1 language of choice, many colleges and universities are considering the adoption of C++ (an imperative and object-oriented hybrid language) as its replacement. An important issue that must be addressed in making such a change is the question of what software design methodology should be taught to CS1 students. Two common answers are (i) continue teaching structured design in CS1 and switch to object-oriented design in CS2; or (ii) teach object-oriented design from the outset in CS1. We believe that both of these approaches have significant drawbacks. To avoid these drawbacks, this paper describes a graduated approach to object-oriented design that we call
object-centered design
. The approach introduces students to object-oriented design by the end of CS2 without an abrupt paradigm shift, and without requiring an early introduction of inheritance.
The joy of software—starting with objects
Authors: Woodman Mark , Davies Gordon , Holland Simon
Published: July 2004

This paper briefly describes the evolution and content of the Open University's new introductory course in Computing which has been designed for delivery internationally to over 3500 students per year. It replaces a conventional procedural programming course and introduces computing through object technology---specifically, through Smalltalk. Unlike its predecessor it is being designed to be accessible by non-computing majors and with an intention to address the gender imbalance in our student population. Multimedia technologies are used in the delivery of this distance learning course which is being developed by the course team for presentation in 1997.
Using inheritance to implement concurrency
Authors: Ben-Ari Mordechai
Published: July 2004

The Ada programming language is an excellent vehicle for teaching concurrent programming because support for concurrency has been designed into the language. The paper shows how primitives from other concurrent programming languages (occam, Linda, Joyce) can be simulated within Ada. This enables students to study other constructs without the overhead of learning a new language and programming environment. The simulations use inheritance which was introduced into the new Ada 95 standard. They can also be used as examples of inheritance when teaching object-oriented programming.
Thetis
Authors: Freund Stephen N. , Roberts Eric S.
Published: July 2004

Commercially available compilers, particularly those used for languages like ANSI C that have extensive commercial applicability, are not well-suited to students in introductory computer science courses because they assume a level of sophistication that beginning students do not possess. To alleviate this problem at Stanford, we have developed the Thetis programming environment designed specifically for student use. The system consists of a C interpreter and associated user interface that provides students with simple and easily understood editing, debugging, and visualization capabilities. Reactions of students and instructors indicate that Thetis fulfills the goals we set out to accomplish and provides a significantly better learning environment for students in CS1/CS2.
Multiple paradigms in CS I
Authors: Leska Chuck , Barr John , King L. A. Smith
Published: July 2004

This paper presents an approach to introducing multiple programming language paradigms in the CS I course through the use of a single multiparadigm language. The approach uses multiple paradigms in the design and implementation of solutions to computer projects. The paper illustrates the approach by outlining a solution to a sample project which utilizes the imperative, object-oriented, and the functional paradigms.
Lessons learned
Authors: Aiken R. , Ingargiola G. , Wilson J. , Kumar D. , Thomas R.
Published: July 2004

The authors have conducted for each of the past three Summers a workshop for faculty who have taught or are scheduled to teach an upper level undergraduate course in Artificial Intelligence. This paper describes problems the organizers have encountered and ways in which they have attempted to address them. The hope is that others designing and implementing similar workshops can benefit from these "lessons learned".
What courseware dedicated to computer science?
Authors: Boufaida Mahmoud
Published: July 2004

Computer science is a field where the concept acquisition depends both on knowledge and know-how. Some aspects such as the situated learning, the use of viewpoints and the negotiated tutoring play an important part in the programming learning. All these notions require specific tools intented for a teacher who designs a computer science courseware. So, this paper presents an authoring system which is particularly specialized in the student interface generation and the tutoring strategy execution.
Graduate assistant usage in Oklahoma graduate computer science programs
Authors: Fife Leslie D. , Racherla Gopal , Killian Steven E.
Published: July 2004

This paper is the result of a survey sent to the graduate teaching and research assistants at three computer science departments in the State of Oklahoma. The survey was designed to determine how the students were utilized by their departments, what the students felt about their experiences as a teaching or research assistant, and how their positions have impacted their educational experience. This paper presents and discusses the results of the survey.
Productivity through automated tools
Authors: Bobbie P O
Published: July 2004

Of late, there have been several discussions of various methodologies and techniques for improving software development productivity. Current methodologies include executable specification languages, integrated software environments, and Artificial Intelligence (AI) based shells. The following discussion addresses various contexts in which advanced software tools can promote software productivity.
A hierarchical spiral model for the software process
Authors: Iivari J
Published: July 2004

Barry B. Boehm suggested an interesting spiral model for the software development process in the International Workshop on the Software Process and Software Environments last Year (Boe86). The model is particularly interesting to me, since it seems to be highly consistent with some of the basic ideas of the PIOCO model for the information systems (IS) design process (Iiv82, Iiv83a, IiKo86) and also with its application to the development of embedded software (IiKT86). For instance, he characterizes the spiral model as a risk-driven approach. In the PIOCO model we have chosen to use the term uncertainty instead of risk emphasiznig that the IS/SW process, particularly in its earlier phases, is information production for the steering committee deciding about the IS/SW product and process (Iiv83a, Iiv86). In Iiv83a and b we have also formalized this idea in terms of Information Economics (Mar74) leading to the conclusion that IS/SW elaboration should be directed to those aspects of the IS/SW process in which the uncertainty, and therefore the potential value of the new information, is greatest (cf. Boe86).
A software development environment database
Authors: Soupos R , Goutas S , Christodoulakis D , Zaroliagis C
Published: July 2004

In your report on Software Development/Programming Environments in the April 86 issue you made some well-aimed remarks about the "fundamental underlying concepts" of software engineering environments, concerning their maturity and stability. Since we have been working on the development of a software engineering database for about three years in the frame of the ESPRIT project GRASPIN +), we were urged to send you the following abstract of our work in the field, hoping to contribute to the solution of the problems you mentioned.
Characteristics and functions of software environments: an overview
Authors: Houghton R , Wallace D
Published: July 2004

Software engineering environments surround their users with the software tools necessary for systematic development and maintenance of software. This report characterizes software engineering environments by their types, by their relationship to the software life cycle, and by their capabilities, limitations, primary users, and levels of support. This report provides examples of existing software engineering environments that are available commercially or in research laboratories with the features and characteristics they provide.
Software architecture styles as graph grammars
Authors: Le Métayer Daniel
Published: July 2004

We present a formalism for the definition of software architectures in terms of graphs. Nodes represent the individual agents and edges define their interconnection. Individual agents can communicate only along the links specified by the architecture. The dynamic evolution of the overall architecture is defined independently by a 'coordinator'. An architecture style is a class of architectures characterised by a graph grammar. The rules of the coordinator are statically checked to ensure that they preserve the constraints imposed by the architecture style.
Checking relational specifications with binary decision diagrams
Authors: Damon Craig A. , Jackson Daniel , Jha Somesh
Published: July 2004

Checking a specification in a language based on sets and relations (such as Z) can be reduced to the problem of finding satisfying assignments, or models, of a relational formula. A new method for finding models using ordered binary decision diagrams (BDDs) is presented that appears to scale better than existing methods.Relational terms are replaced by matrices of boolean formulae. These formulae are then composed to give a boolean translation of the entire relational formula. Throughout, boolean formulae are represented with BDDs; from the resulting BDD, models are easily extracted.The performance of the BDD method is compared to our previous method based instead on explicit enumeration. The new method performs as well or better on most of our examples, but can also handle specifications that, until now, we have been unable to analyze.
Program generalization for software reuse
Authors: Siff Michael , Reps Thomas
Published: July 2004

We consider the problem of software generalization: Given a program component
C,
create a parameterized program component
C
′ such that
C
′ is usable in a wider variety of syntactic contexts than
C.
Furthermore,
C
′ should be a semantically meaningful generalization of
C;
namely, there must exist an instantiation of
C
′ that is equivalent in functionality to
C.
In this paper, we present an algorithm that generalizes C functions via type inference. The original functions operate on specific data types; the result of generalization is a collection of C++ function templates that operate on parameterized types. This version of the generalization problem is useful in the context of converting existing C programs to C++.
Evaluating software engineering methods and tool part 5
Authors: Kitchenham Barbara Ann , Jones Lindsay
Published: July 2004

In previous articles, we have considered a number of general issues concerned with evaluating methods and tools. In the next few articles we describe how to perform a specific type of evaluation exercise called Feature Analysis.This article discusses the principles of feature analysis and describes how to identify features and establish a means of scoring products against those features. Later articles consider how to plan a feature-based evaluation and how to analyze the results of an evaluation.
A case-tool for supporting navigation in the class hierarchy
Authors: Putkonen A. , Kiekara M.
Published: July 2004

The central role that class hierarchy plays in object-oriented systems is discussed. The study focuses on design and maintenance stages where the requirements of navigation facilities are greater than at other stages of the systems lifecycle. It will be shown that different kinds of navigation are needed and it is necessary to browse up and down the class hierarchy before it is possible to decide which classes have to be changed. A flexible navigation tool which can support these design and maintenance stages is also presented. The tool helps the designer to navigate the class hierarchy and to investigate the effect of the intended changes on the entire class hierarchy.
From theory to practice or how not to fail in developing information systems
Authors: Drori Offer
Published: July 2004

The development of information systems consists of a wide variety of activities and processes, which come together to create a product designed for a specific purpose. We often encounter products that do not serve the purpose they were intended for, and the question asked is: How does it happen that a process that has been defined and structured in principle, has such a high failure ratio? The purpose of this article is to attempt to clarify the problematic points or subjects that exist in the process of developing information systems and to supply the tools to help reduce the problem.
Evaluating software engineering methods and tools part 6
Authors: Kitchenham Barbara Ann , Jones Lindsay
Published: July 2004

This article discusses the issues involved in selecting the list of features that will be used in a particular feature analysis evaluation exercise. We also consider candidate methods/tools can be evaluated by scoring them in terms of their provision of and support for features that are important to the users of technology.
Issues in designing an information model for application development
Authors: Sockut Gary H. , Arzu Helen P. , Matthews Robert W. , Shough David E.
Published: July 2004

IBM's object-oriented information model lets a customer share data among various tools for application development. This paper discusses several issues in designing the information model, namely (1) techniques for diagrams (an essential part of communication between an information model designer and other designers or tool writers), (2) organization of the design of the information model (an essential step when many designers design anything large), and (3) technical content. These discussions of the experience of designing the information model should be valuable for further design of the information model and for other design efforts, e.g., involving other models or other integration of tools.
A document-centered approach for an open CASE environment framework connected with the world-wide web
Authors: Blanqui Frédéric
Published: July 2004

Software development suffers from a number of well known difficulties, both technical and managerial [2]. A technical approach that could help to reduce them is the use of Computer-Aided Software Engineering (CASE) technologies. However, current Integrate Project Support Environment (IPSE) frameworks impose many constraints on CASE tool vendors, and this has impeded their adoption [10]. A more incremental strategy should be considered for the transfer and the diffusion of those technologies.This paper describes a document-centered approach and a simple but extendable system called Open Software Development System (OSDS) based on this approach. First, we describe difficulties inherent in the management of documents involved in software development. Second, we define some requirements to address those difficulties. Finally, we describe the important features of OSDS; these include an extension of Mosaic [3] that enables anyone with network access to connect to an OSDS, browse through it, and automatically integrate some documents into his/her own system.
Software development environment based on HyperNet
Authors: Marovac Nenad
Published: July 2004

In supporting groups working on development of large software programs we identify three classes of tools:1. CASE tools: tools which are used directly in the program development (specification, design, implementation, and testing).2. environment tools: tools which together are and effect the development environment, i.e. tools used in organizing and maintaining development information (program specifications, designs, code, test cases, etc.) which may be distributed world-wide.3. groupware tools: tools which are used to effect group communication and interaction, i.e. tools used for submission, organization and distribution of ideas and any issues related to the development and management process.In this paper we will address the second class of tools, the environment tools, and present an environment largely based on HyperNet - A tool to choreograph world wide distributed hypermedia documents. The environment incorporates three main functionalities:1. A project knowledge base and associated processor. The knowledge base stores all material relevant to a project, i.e. specification, design, implementation, testing and maintenance related documents and source code for the project including operating system scripts required to compile, link, execute and test the software.2. mechanism supporting libraries of reusable material. The material includes program specifications, design documents, code and test data and procedures.3. documentation processor which produces on-demand documentation for the project on any desirable level of detail.
Issues arising from medical system's failure
Authors: Blyth Andrew
Published: July 2004

As more health-care providers adopt and utilise information technology in the treatment of there patients, so the number of system failures increases. Analysis of these failures shows us that these systems are failing for a variety of technical and social reason. The question that we are forced to ask is Why? In this paper I seek to highlight some of the problems that are currently facing developers and users of medical computing systems.
So many algorithms. So little time
Authors: Greenwood Garrison W.
Published: July 2004

This paper discusses the futility in answering questions about convergence and performance in algorithms used to solve optimization problems. Not only are these answers difficult to obtain, they are often times meaningless.
Robust estimation in software experiments
Authors: Chen Yeh-Ling , Stromberg Arnold J.
Published: July 2004

"Software development, like other scientific developments, requires formal experiments with a great deal of plan and analysis if they are to provide meaningful results"[11]. This paper uses examples to extend the discussion to certain statistical analyses,i.e.,robust estimation and variance modeling, which are relatively new and may have never been practiced in the software engineering field.
A pattern oriented technique for software design
Authors: Ram D. Janaki , Raman K. N. Anantha , Guruprasad K. N.
Published: July 2004

Design patterns can be considered as elements of complex software systems. Crafting these software systems using design patterns calls for a suitable design methodology or technique. Existing design methodologies do not serve this purpose well. This paper proposes a technique which helps in developing software systems usign design patterns.
Report: 4th ACM Conference On Computer and Communications Security
Authors: Reifer Donald J.
Published: July 2004

The 4th ACM Conference on Computer and Communications Security [1] was held on 1-4 April 1997 in Zurich, Switzerland. About 100 participants from around the world gathered to discuss advances being made primarily in the area of defensive information warfare. This was primarily a research-oriented event which attracted principal investigators working in the security field from about 14 nations. I attended the conference for the following four reasons:• I wanted to update my knowledge of the area.• I wanted to ascertain what progress has been made in the field.• I wanted to determine whether there were any breakthrough technologies on the horizon.• I wanted to understand the threats being guarded against and the defensive strategies that leaders in the field were recommending.As I will relate later, significant progress has been in many defensive information warfare areas. I particularly was impressed by the advances that have been made in the area of cryptography, digital signatures and communications protocols. I was disappointed by the perceived lack of progress over the years in the important area of trusted systems and information security infrastructure development.This was the first conference that I have attended on the subject in about a decade. I selected the event because I thought that it would allow me to view both present work in the field and look into the future.
Getting started with computer ethics
Authors: Werth Laurie H.
Published: July 2004

Computer professionals face dilemmas which demand both technical knowledge and an understanding of ethical principles and skills, but how to best teach these principles and necessary skills to students? ACM's Curriculum '91 and the problems inherent in the growth of information technology call for educators to integrate computer ethics material into the computer science curriculum. Unfortunately, most faculty have neither background information nor experience teaching ethics and professionalism topics.This paper discusses basic instructional issues and provides elementary approaches for inexperienced faculty. Several simple techniques to identify and analyze ethical issues are presented. Next we look at two intermediate techniques suitable for computer science students which have been particularly successful in my classes. Finally, Project ImpactCS' model for teaching computer ethics, a valuable framework for the study of ethics and social principles and skills is summarized. This model leverages ethics experts experience to jump-start computer science faculty.
Teaching OOP in C++ using an artificial life framework
Authors: Pattis Richard E.
Published: July 2004

This paper explores the framework method for teaching object-oriented programming. Specifically, it describes a hierarchy of C++ classes that implement the framework for an Artificial Life simulator. Students learn how to read these classes and extend them via inheritance: they design and implement subclasses that encapsulate the behavior and state of environments and the entities that inhabit them. The simulator constructs an artificial world from objects of these subclasses; then, it animates these objects as they interact during the simulation. This paper includes one sample project and both subclasses that implement its solution.
The evolution of standards for accrediting computer science teacher preparation programs
Authors: Taylor Harriet
Published: July 2004

In 1992, the National Council for the Accreditation of Teacher Education (NCATE) adopted guidelines for computer science education teacher preparation programs. The endorsement signaled the emergence of computer science education as a distinct discipline and computer science as a formal secondary subject area. The guidelines were developed through an intense program of research and review by the International Society for Technology and Education (ISTE). Since the passage of the standards, numerous computer science and education professionals have been involved in the process of preparing program folios for review and developing the actual review process. This real experience with the standards helped to identify issues and problems that are common to most programs and that need examination in the current five year review. In this paper, an overview of the guidelines is presented, the review process is described, issues and problems are discussed, and future initiatives are identified.