Search

In this paper we introduce two classes of program testing strategies that consist of specifying a set of required elements for the program and then covering those elements with appropriate test inputs. In general, a required element has a structural and a functional component and is covered by a test case if the test case causes the features specified in the structural component to be executed under the conditions specified in the functional component. Data flow analysis is used to specify the structural component and data flow interactions are used as a basis for developing the functional component. The strategies are illustrated with examples and some experimental evaluations of their effectiveness are presented. [ABSTRACT FROM AUTHOR]

An abstract requirements specification states system requirements precisely without describing a real or a paradigm implementation. Although such specifications have important advantages, they are difficult to produce for complex systems and hence are seldom seen in the "real" programming world. This paper introduces an approach to producing abstract requirements specifications that applies to a significant class of real-world systems, including any system that must reconstruct data that have undergone a sequence of transformations. It also describes how the approach was used to produce a requirements document for SCP, a small, but nontrivial Navy communications system. The specification techniques used in the SCP requirements document are introduced and illustrated with examples. [ABSTRACT FROM AUTHOR]

-c_The theory of software science was developed by the late M. H. Halstead of Purdue University during the early 1970's. It was first presented in unified form in the monograph Elements of Software Science published by Elsevier North-Holland in 1977. Since it claimed to apply scientific methods to the very complex and important problem of software production, and since experimental evidence supplied by Halstead and others seemed to support the theory, it drew widespread attention from the computer science community. Some researchers have raised serious questions about the underlying theory of software science. At the same time, experimental evidence supporting some of the metrics continue to be presented. This paper is a critique of the theory as presented by Halstead and a review of experimental results concerning software science metrics published since 1977. [ABSTRACT FROM AUTHOR]

-c_Halstead proposed a methodology for studying the process of programming known as software science. This methodology merges theories from cognitive psychology with theories from computer science. There is evidence that some of the assumptions of software science incorrectly apply the results of cognitive psychology studies. Halstead proposed theories relative to human memory models that appear to be without support from psychologists. Other software scientists, however, report empirical evidence that may support some of those theories. This anomaly places aspects of software science in a precarious position. The three conflicting issues discussed in this paper are 1) limitations of short-term memory and number of subroutine parameters, 2) searches in human memory and programming effort, and 3) psychological time and programming time. [ABSTRACT FROM AUTHOR]

The purpose of this paper is to develop a method for designing and verifying data abstractions using the functional approach. Before doing so, the existing techniques for designing and verifying procedure and data abstractions will be surveyed briefly. These techniques will then be modified and extended to verify data abstractions. By using the concept of a mathematical function, one can model the behavior of a procedure abstraction and give a more uniform and clearer meaning to the stepwise refinement and verification of procedure abstractions. The concept of a state machine is then used as a basis to specify data abstractions. Using state machine specification, a technique for expressing the design of a data abstraction is then given. A method is then developed to verify the design of a data abstraction with respect to its specifications. [ABSTRACT FROM AUTHOR]

In this paper we compare the performance of virtual memory allocation algorithms. The primary measure of performance is the space-time product of primary memory occupancy, or space-time cost, used by a program during its execution. Using DMIN, an optimal dynamic allocation algorithm, we compute the minimum space-time cost achievable for some benchmark program runs. We compare the DMIN space-time cost with the space-time cost from: MIN, an optimal static allocation algorithm, VMIN, an optimal variable space algorithm, and two heuristic dynamic allocation algorithms: the page fault frequency algorithm and the damped working set algorithm. [ABSTRACT FROM AUTHOR]

It is known that not all paths are possible in the run time control flow of many programs. It is also known that data flow analysis cannot restrict attention to exactly those paths that are possible. It is, therefore, usual for analytic methods to consider all paths. Sharper information can be obtained by considering a recursive set of paths that is large enough to include all possible paths, but small enough to exclude many of the impossible ones. This paper presents a simple uniform methodology for sharpening data flow information by considering certain recursive path sets of practical importance. Associated with each control flow arc there is a relation on a finite set C). The paths that qualify to be considered are (essentially) those for which the com- position of the relations encountered is nonempty. For example, Q might be the set of all assignments of values to each of several bit variables used by a program to remember some facts about the past and branch accordingly in the future. Given any data flow problem together with qualifying relations on Q associated with the control flow arcs, we construct a new problem. Considering all paths in the new problem is equivalent to considering only qualifying paths in the old one. Preliminary experiments (with a small set of real programs) Indicate that qualified analysis is feasible and substantially more informative than ordinary analysis. The methodology also ban beneficial feedback effect on the delicate task of passing from programs to meaningful data flow analysis problems. Even when all paths qualify, unusually sharp information can be obtained by passing from programs to problems in ways suggested by theorems proved here. [ABSTRACT FROM AUTHOR]

The need for programming environments which support different phases of the software life cycle using responsive tools is well established. This paper presents a method for developing automatic analyzers which analyze programs and provide programmers with a variety of messages for the purpose of validating these programs in the early stages of program development. We show using an example, that such analyzers can be systematically constructed using an extension of the Attribute Grammar model which reflects the fact that a prop-am analyzer should perform a static analysis of the program as well as monitor its dynamic behavior efficiently. One of the advantages of the model is that a systematic interaction is allowed between the static and dynamic attributes of the program. We illustrate that an advantage of this interaction is selective program instrumentation. That is, the analyzer is responsive to the programmer's needs by providing a selective analysis of the program's behavior rather than an exhaustive analysis which is difficult to comprehend. [ABSTRACT FROM AUTHOR]

Modula is a new programming language for implementing dedicated, parallel systems. Following a systematic design technique, this paper illustrates the use of Modula for the design of a message switching communication system. A message switching system poses a number of interesting problems: a high degree of concurrent activity exists, a variety of I/O devices need to be controlled, messages can have multiple destinations, and messages can be preempted. The strengths and weaknesses of Modula with respect to these specific problems and its utility as a general purpose language are evaluated. [ABSTRACT FROM AUTHOR]

The use of capabilities to control the access of component programs to resources in an operating system is an attractive means by which to provide a uniform protection mechanism. In this paper, a capability is defined as an abstract encapsulation of the data needed to define access to a protected object. We do not assume that capability checking is necessarily concentrated in a protection kernel, nor that capabilities to different types of objects are all of the same degree of complexity. We explore a language-based capability mechanism in which protection environments are established by declaration, enforcement protocols are automatically produced by a compiler, and access control policy is clearly placed in the hands of the system designer. The basic mechanism introduced is a program component called a capability manager that is an extension of the monitor concept. It can be used to realize most of the facilities associated with kernel-based capabilities, including preemptive revocation. [ABSTRACT FROM AUTHOR]

This paper discusses the problem of allocating storage for the activation records of procedure calls within a system of parallel processes. A compile time storage allocation scheme is given, which determines the relative address within the memory segment of a process for the activation records of all procedures called by the process. This facilitates the generation of an efficient run-time code. The allocation scheme applies to systems in which data and procedures can be shared among several processes. However, recursive procedure calls are not supported. [ABSTRACT FROM AUTHOR]

A method for formal description of programming principles is presented in this paper. Programming principles, such as sequential search can be defined and proven even in the absence of an application. We represent a principle as a program scheme which has partially interpreted functions in it. The functions must obey certain input constraints. Use of these ideas in program proving is illustrated with examples. [ABSTRACT FROM AUTHOR]

In this paper we describe and review the course plan and syllabus we use in a course on formal methods in software engineering currently included in the degree in Informatics of the Faculty of Sciences at the University of Bologna. The course matches the theory of formal methods with their practice based on actual tool usage. In fact, the course is centered upon a project whose main goal is to let students learn some formal specification techniques, all supported by specific tools. The students use well-known notations for both requirements specification and formal design. The formal methods we use are based on the Z notation for requirements specification and on the Larch family of languages for design specifications. [ABSTRACT FROM AUTHOR]

A project course in software engineering is often part of the curriculum in computer engineering or computer science. This paper studies the relationship between academic and industrial projects in software engineering. The purpose is to compare the practices followed in a project-course approach with the practices of professional software engineers. The approach is to compare the measurements obtained from academic and industrial projects. The critical factors regarding the process, the people and the project are discussed. The structure of the software processes and the measurement tools are presented. The data analyses show that the academic projects are found to be strongly dominated by programming activities. Based on the data from the industrial projects, we formulate seven recommendations to improve the software engineering practices in academic projects. They are related to management, predevelopment, development, testing, reviews documentation and team activities. The concluding remarks discuss some of the actions that could be taken to improve academic projects. [ABSTRACT FROM AUTHOR]

Postgraduate degree programs in “software engineering” have been in existence for some time and now undergraduate degree programs with this title are beginning to appear. A number of questions and issues of only moderate importance with respect to the postgraduate programs now become critical and of overriding importance. While one could (and did) by and large gloss over these issues earlier, this will be much more difficult, and probably impossible, in the future. These issues must be resolved in a wider context than that in which they have been dealt with before, involving engineering in the universities and professional engineering societies in the larger social context. Much of the disagreement regarding these issues can, ultimately, be traced back to differing fundamental views and definitions of the term “engineering” and whether “software engineering” should be treated as “just” another engineering discipline or in a significantly and fundamentally different way. After examining two different definitions and views of “engineering,” this paper states and discusses a number of the questions and issues which planners of new undergraduate software engineering degree programs must deal with. Some pros and cons of various alternative answers are presented and a few answers suggested. The issues discussed here begin with questions of general policy and concept (e.g., which culture – that of the traditional engineering disciplines or that of computer science – should be instilled in the students in these new degree programs), include organizational matters (e.g., the position of the new degree program in the university hierarchy) and end with selected, more detailed questions regarding the curriculum (e.g., how to deal with programming, design and management topics). It is conjectured that, although the scientific foundation for the undergraduate software engineering degree programs must and will come from computer science, their culture and orientation must come from engineering if they and their graduates are to be successful in satisfying society's needs in the long term. [ABSTRACT FROM AUTHOR]

This paper describes how we have modified a software engineering stream within a computer science course to include broader concepts of systems engineering. We justify this inclusion by showing how many reported problems with large systems are not just software problems but relate to system issues such as hardware and operational processes. We describe what we mean by ‘systems engineering’ and go on to discuss the particular course structure which we have developed. We explain, in some detail, the contents of two specific systems engineering courses (Software Intensive Systems Engineering and Critical Systems Engineering) and discuss the problems and challenges we have faced in making these changes. In the appendix, we provide details of the case studies which are used as linking themes in our courses. [ABSTRACT FROM AUTHOR]

Software engineering education has a 30-year history. It is a story of academics struggling to fulfill industry needs with almost no support from computer science curriculum designers. It is a story of industry finally winning over some of academia to teach software engineering rather than vanilla computer science. It is a story of a discipline still incomplete, but having made great strides in the last decade. This paper discusses the succeeding eras of software engineering education, from lone teachers to master's curricula to undergraduate degree programs. Even though the maturity of the discipline is as yet unattained, it will achieve adult status through practice, not by waiting for academia to glacially catch up. [ABSTRACT FROM AUTHOR]

Programmes in “Software Engineering” have become a source of contention in many universities. Some Computer Science departments, many of which have used that phrase to describe individual courses for decades, claim software engineering as part of their discipline. However, Engineering faculties claim “Software Engineering” as a new speciality in the family of engineering disciplines. This paper discusses the differences between traditional computer science programmes and most engineering programmes and argues that we need programmes that follow the traditional engineering approach to professional education and educate engineers whose speciality within engineering is software construction. One such programme is described. [ABSTRACT FROM AUTHOR]

The article discusses how software architecture has evolved since 2006. In the first paper written by the authors, they claimed that software architecture is a healthy engineering discipline since it follows a classic technology maturation path, which begins with research and ends with the termination of software building without the help of technology. They considered 2006 as a golden age for software architecture and predicted that the discipline is starting to mature. The authors are still convinced that software architecture is shifting from concept exploration to the application of the concepts.

Background: Cell tracking experiments, based on time-lapse microscopy, have become an important tool in biomedical research. The goal is the reconstruction of cell migration patterns, shape and state changes, and, comprehensive genealogical information from these data. This information can be used to develop process models of cellular dynamics. However, so far there has been no structured, standardized way of annotating and storing the tracking results, which is critical for comparative analysis and data integration. The key requirement to be satisfied by an ontology is the representation of a cell's change over time. Unfortunately, popular ontology languages, such as Web Ontology Language (OWL), have limitations for the representation of temporal information. The current paper addresses the fundamental problem of modeling changes of qualities over time in biomedical ontologies specified in OWL. Results: The presented analysis is a result of the lessons learned during the development of an ontology, intended for the annotation of cell tracking experiments. We present, discuss and evaluate various representation patterns for specifying cell changes in time. In particular, we discuss two patterns of temporally changing information: n-ary relation reification and 4d fluents. These representation schemes are formalized within the ontology language OWL and are aimed at the support for annotation of cell tracking experiments. We analyze the performance of each pattern with respect to standard criteria used in software engineering and data modeling, i.e. simplicity, scalability, extensibility and adequacy. We further discuss benefits, drawbacks, and the underlying design choices of each approach. Conclusions: We demonstrate that patterns perform differently depending on the temporal distribution of modeled information. The optimal model can be constructed by combining two competitive approaches. Thus, we demonstrate that both reification and 4d fluents patterns can work hand in hand in a single ontology. Additionally, we have found that 4d fluents can be reconstructed by two patterns well known in the computer science community, i.e. state modeling and actor-role pattern. [ABSTRACT FROM AUTHOR]

In this correspondence, we point out some of the major shortcomings that we have discovered in the article titled "Factors that Impact Implementing a System Development Methodology" by Roberts et al. [9]. The article was published in the August 1998 issue of IEEE Transactions of Software Engineering. The article contains multiple problems that, if not pointed out, have the potential to lead to a state of confusion among researchers and practitioners alike. In particular, the article has the following problems: 1) The authors claim that the lack of theoretical basis for their factors is due to the fact that SDM implementation has never been studied in the literature. In fact, there is a multitude of studies very similar to that of Roberts et al. 2) The study does not meet commonly accepted standards for factor analysis procedures such as a minimum sample size ratio of 5:1, a ratio mandated even by the authors' own citations. This and other factor analysis problems lead to results that are questionable. In order to make the published article more useful to researchers and practitioners this paper corrects some of the inaccuracies in the Roberts et al.'s article by: 1) Providing a brief literature review of some articles that are similar to the Roberts et aI. study and 2) noting some of the technical inaccuracies in the data analysis procedures used by the authors so that the results can be interpreted in the proper context. [ABSTRACT FROM AUTHOR]

The conversation scheme is a promising way of developing fault-tolerant software and several mechanisms for its implementation have been proposed. In an earlier paper Tyrrell and Holding used Petri nets to design conversations. Their procedure, although correct, appears to be more complex than necessary. In this correspondence, a simplified transition identification method is proposed. Using a robot arm control program we show that the corresponding Petri net graph is simpler than the one proposed by Tyrrell and Holding, but the communication state change table is the same. It is also shown that these two methods are equivalent. [ABSTRACT FROM AUTHOR]

In the eWaterCycle II project we took up the challenge to "do Open Hydrology right". Ichallenge that we ourselves suggested in our commentary paper "Let hydrologistslearn the latest computer science by working with Research Software Engineers(RSEs) and not reinvent the waterwheel ourselves" [Hut 2017]. For computationalhydrology to be reproducible and re-usable, merely making data and software openlyavailable will not be enough. Models and model-components will have to communicatethrough well defined open interfaces to allow reusability by other scientist withoutforcing those scientists to become an expert in the code that they are trying to buildon.The goals we have for the eWaterCycle II project is to provide the hydrological communitywith tools that: Allow the use of a wide variety of models, written in different programming languages, without having to learn those languages. Run models needing large amounts of memory and CPUs. Have access to all the relevant datasets from the community (forcing, observations) Allow advanced use cases such as data assimilation and model coupling studies. Allow the sharing of models with the entire community, both for citing (DOIs) and re-use.Ultimately providing hydrologists with a toolset that allows them to run each other models, butalso adept, couple, and in general tinker with models without the headache of having to delveinto each others detailed code. Currently one year into this three year project, at the General Assembly we willdemonstrate, and make accessible to fellow hydrologist the first version of our system wherescientists can: Get started with modelling without installing a single piece of software. Run any of the available models within minutes. Add their own model with minimal effort. Compare output of their model, as well as that of colleagues to standard observations like discharge from the Global River Data Centre. Develop code quickly in a notebook environment. At the PICO screen we will have a life demonstration of this system. [ABSTRACT FROM AUTHOR]

An editorial is presented by Jeff Kramer, the new Editor-in-Chief of the "IEEE Transactions on Software Engineering" (TSE) journal, regarding the publications future. A vision statement is presented for the new issues and applications that face the computer engineering industry, and plans are offered to strengthen the Editorial Board. Three proposals are offered to improve the quality of TSE papers, including inviting submissions, being flexible with innovative papers that require further improvements, and the use of case studies.

This article introduces the August 1994 issue of "IEEE Transactions on Software Engineering", which contains papers chosen from the 1993 European Conference in Software Engineering held in Germany. The conference was oriented towards presenting the strengths of European software engineering and in exploring the interaction between software engineering and other related areas of computer science and engineering. Of the six papers chosen, three are concerned with system specification where European work has traditionally been strong. The other three papers cross boundaries in that they address issues of distributed software engineering and software engineering and cooperative work.

In the paper, "Temporal Logic-Based Deadlock Analysis for Ada," reference [9] was duplicated as reference [10], causing the remaining references to be misnumbered by one. The correctly numbered reference list is given below in its entirety. All reference citations in the paper's text are correct as published.

The note introduces a special section containing research papers on statistical and scientific database (SSDB) management, which appeared in the October 1985 issue of the periodical "IEEE Transactions on Software Engineering." The collection of papers reflect the diversity of approaches to the solutions of SSDB management including physical storage organization and the application of artificial intelligence expert system techniques. The first paper is an introduction to the key research issues of SSDB management. The second paper is on data compression. The third paper is on data management support of computational statistical data. The fourth paper is on query facilities for SSDB. The last paper is on applying the production systems techniques in artificial intelligence for performing estimation.

The field of transformations is developing a methodology for manipulating programs, mapping them from one form into another. Transforming a program will preserve some of its properties, and alter others. While many choices could be made about which properties to preserve, the transformation field has focused on altering the performance characteristics of programs while preserving their 'semantics.' The papers published in the January 1981 issue of the periodical "IEEE Transactions on Software Engineering" are necessarily limited. Many of the important topics are not trated. The papers were selected to present a flavor for some aspects of the transformation field and to illustrate some research.

This article introduces a series of articles on software testing and development. Hailpern and Santhanam provide formal definitions for debugging, testing and verification and show how each activity relates to the software development process. Bassin, Biyani and Santhanam describe metrics that can be applied as part of the acceptance test for vendor-developed software. The authors explain how metrics can be used to estimate the degree of risk involved in accepting a software component, based on test case execution. The paper by Butcher, Munro and Kratschmer describes case studies in which Orthogonal Defect Classification, a quantitative method used to improve processes as products evolve, was applied to a mature product, a large middleware product, and small team project. Weyuker and Avritzer introduce the performance nonscalability likelihood metric, designed to predict the likelihood that the system will fail to meet its performance goals when the workload is scaled. Loveland and colleagues report on the process, tools and techniques used to test z/OS, the operating system for the IBM zSeries processors. Edelstein and colleagues describe ConTest, a tool that both generates and executes tests for detecting synchronization problems in multithreaded Java programs.

The article focuses on the journal "Transactions on Software Engineering," vol. 27, published as of October 1, 2001 which presents information about software engineering. Thomas Reps received the PhD degree in computer science from Cornell University in 1982. His PhD dissertation won the 1983 Association of Computing Machinery Doctoral Dissertation Award. He has also been the recipient of the US National Science Foundation Presidential Young Investigator Award, a Packard Fellowship, a Humboldt Research Award and a Guggenheim Fellowship. He is a professor of computer science in the Computer Sciences Department at the University of Wisconsin, which he joined in 1985. He is the author or co-author of three books and more than 75 papers. Ali Mili received the PhD degree from the University of Illinois in 1980. His research interest lie in software engineering and range from managerial aspects to technical aspects. Gregg Rothermel received the BA degree in philosophy Reed College, Portland, Oregon.

The article presents an introduction to the May 1, 1998 issue of the journal "ACM Computing Survey." The issue includes articles on software engineering frameworks, business computing algorithms and concurrency control performance. Researcher Scott Lewandowski's article "Frameworks for Component-Based Client/Server Computing" is the first winner of the journal's student paper award. It presents an in-depth review into frameworks for client-server computing and principles. It explores frame work for distributed objects and compound documents. High standard of the paper provide a baseline for future submissions to the journal's student paper competition. Researcher Alexander Thomasian's "Concurrency Control: Methods, Performance, and Analysis" a traditional area of computer science from a new perspective. It provides a performance analysis of both standard and non-standard locking system techniques, exploring methods of improving locking performance. Techniques examined include restart-oriented locking methods, the running priority method and optimistic concurrency control techniques.

This editorial introduces the January 1993 issue of the periodical "IEEE Transactions on Software Engineering" which focuses on software for critical systems. The issue contains a selection of significant papers from the SIGSOFT '91 conference. Papers by Ricky Butler and George Finelly, John Rushby and Friedrich von Henke, and others address different aspects of the topic. [ABSTRACT FROM AUTHOR]

This editorial addresses various issues relating to the periodical "IEEE Transactions on Software Engineering." It outlines the process by which papers are received and reviewed for publication. It encourages authors to submit electronic copies of their papers to facilitate editing. Lastly, it puts forth the requirements for papers submitted for general and special issues.

Some papers from the 1978 computer science conference, COMPSAC 78 Conference, are presented in this issue of the "IEEE Transaction on Software Engineering". Computer science of which software engineering is a very important component, is a multifaceted discipline and the computer applications are providing the major avenues of its growth, just as physical and biological sciences have been the beacon lights of the growth of mathematical sciences. The papers in this issue and those presented at COMPSAC 78 portray this emerging thrust of software application experience.

The Third International Conference on Data Engineering was held in Los Angeles, California on February 2 to 6, 1987. The conference was designed as an international forum for bringing together researchers, developers, managers, strategic planners and other users with an interest in the research, design and development of data engineering methodologies, strategies and systems. Its scope includes computer science, artificial intelligence, electrical engineering, and computer engineering. It featured papers from all major areas of data engineering, including database design and modeling, performance evaluation, algorithms, integrity, security, fault tolerance, query language, artificial intelligence approaches, knowledge bases, database machines, distributed databases and data engineering applications.

Software module clustering is the problem of automatically organizing software units into modules to improve program structure. There has been a great deal of recent interest in search-based formulations of this problem in which module boundaries are identified by automated search, guided by a fitness function that captures the twin objectives of high cohesion and low coupling in a single-objective fitness function. This paper introduces two novel multi-objective formulations of the software module clustering problem, in which several different objectives (including cohesion and coupling) are represented separately. In order to evaluate the effectiveness of the multi-objective approach, a set of experiments was performed on 17 real-world module clustering problems. The results of this empirical study provide strong evidence to support the claim that the multi-objective approach produces significantly better solutions than the existing single-objective approach. [ABSTRACT FROM AUTHOR]

The editorial introduces the new Editor-in-Chief of the "IEEE Transactions on Software Engineering" journal, Jeff Kramer, professor in the Department of Computing at the Imperial College of Science, Technology, and Medicine in London, England. The status of the journal is discussed, including gratitude for the creativity displayed in the 341 papers received in 2005. The future of the software industry is discussed, along with difficulties in improving reliability and lowering production cost.

Editorial. Presents an overview of the contents of the publication 'Computer Science Education.' Focus on academic software engineering education and industrial needs; Importance of the papers for software engineering; Factors promoting success in computer science.

Responds to a comment on the authors' paper "A Metrics Suite for Object Oriented Design" by Neville I. Churcher and Martin J. Shepperd.

In a recent paper, an approximate formula for the number of faults per line of code was developed. We show that there is an approximation which is easier to develop, more accurate, and simpler to use. [ABSTRACT FROM AUTHOR]