By Topic

Software Engineering, IEEE Transactions on

Issue 5 • Date Sept. 1984

Filter Results

Displaying Results 1 - 20 of 20
  • [Front cover]

    Page(s): c1
    Save to Project icon | Request Permissions | PDF file iconPDF (26 KB)  
    Freely Available from IEEE
  • Table of contents

    Page(s): nil1
    Save to Project icon | Request Permissions | PDF file iconPDF (26 KB)  
    Freely Available from IEEE
  • Editorial Announcement

    Page(s): 473
    Save to Project icon | Request Permissions | PDF file iconPDF (98 KB)  
    Freely Available from IEEE
  • Foreword

    Page(s): 474 - 477
    Save to Project icon | Request Permissions | PDF file iconPDF (2338 KB)  
    Freely Available from IEEE
  • An Expansive View of Reusable Software

    Page(s): 477 - 487
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3957 KB)  

    The present crisis in software development forces us to reconsider the fundamental ways in which programming is done. One often quoted solution is to exploit more fully the idea of reusable software. It is the purpose of this paper to examine this concept in all of its forms and to assess the current state of the art. In addition to its usual meaning of reusable code, reusability includes reusable design, various forms of specification systems. so-called application generators, and systems for prototyping. We examine each approach from the perspective of the practicing engineer, and we evaluate the work in terms of how it may ultimately improve the development process for large-scale software systems. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Reusability in Programming: A Survey of the State of the Art

    Page(s): 488 - 494
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2181 KB)  

    As programming passes the 30 year mark as a professional occupation, an increasingly large number of programs are in application areas that have been automated for many years. This fact is changing the technology base of commercial programming, and is opening up new markets for standard functions, reusable common systems, modules, and the tools and support needed to facilitate searching out and incorporating existing code segments. This report addresses the 1984 state of the art in the domains of reusable data, reusable architectures, reusable design, common systems, reusable programs, and reusable modules or subroutines. If current trends toward reusability continue, the amount of reused logic and reused code in commercial programming systems may approach 50 percent by 1990. However, major efforts will be needed in the areas of reusable data, reusable architectures, and reusable design before reusable code becomes a sound basic technology. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An Essay on Software Reuse

    Page(s): 494 - 497
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2097 KB)  

    This paper explores software reuse. It discusses briefly some economic incentives for developing effective software reuse technology and notes that different kinds of software reuse, such as direct use without modification and reuse of abstract software modules after refinement, have different technological implications. It sketches some problem areas to be addressed if we are to achieve the goal of devising practical software reuse systems. These include information retrieval problems and finding effective methods to aid us in understanding how programs work. There is a philosophical epilogue which stresses the importance of having realistic expectations about the benefits of software reuse. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Software Engineering with Reusable Designs and Code

    Page(s): 498 - 501
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1389 KB)  

    For over six years Raytheon's Missile Systems Division, Information Processing Systems Organization has used a successful approach in developing and maintaining business software. The approach centers on the fact that 60 percent of all business application designs and code are redundant and can be standardized and reused. This approach has resulted in significant gains in productivity and reliability and improved end-user relations, while providing better utilization of data processing personnel, primarily in the maintenance phase of the software life cycle. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Some Experiences in Promoting Reusable Software: Presentation in Higher Abstract Levels

    Page(s): 502 - 513
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2465 KB)  

    In the Toshiba software factory, quality control and productivity improvements are primary concerns. Emphasis is placed on reusing existing software modules that have been proven correct through actual operation. To achieve a substantial degree of reuse, the software design process is viewed at several levels of abstraction. In this paper, these levels of abstraction are defined, and examples of the specification for these defined levels are given. This paper proposes a ``presentation'' of each existing module at the highest level of abstraction. Traceability between the presentation and the reusable program modules which implement it is established to simplify reusability. The paper concludes with an example showing reuse of a presentation for a different application. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The Unix System and Software Reusability

    Page(s): 513 - 518
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2355 KB)  

    The Unix system contains a variety of facilities that enhance the reuse of software. These vary from the utterly conventional, such as function libraries, to basic architectural mechanisms, such as the Unix pipe. The Unix pipe, which makes whole programs building blocks of larger computational structures, has been the primary reason for the development of a literature of useful, but specialized programs-programs that would be too costly to write in a conventional programming language such as C. It has led to high levels of program reuse both by the nature of its operation and through its effect on programming conventions (e.g., programs structured as simple filters). Another facility enhancing reuse on Unix is the on-line C source code for Unix system programs. This has led to a shared style of programming in which existing programs are used as models for new programs, allowing the reuse of ideas, algorithms and source code. Finally, the Unix system contains many other reuse enhancing facilities, such as generic facilities for screen management (curses and termcap) and program generators (lex and yacc). View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Experience with Traits in the Xerox Star Workstation

    Page(s): 519 - 527
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3089 KB)  

    The Xerox Star (8010) is an integrated office workstation. Its software is written in an object-oriented style. Often, different applications will impose slightly different requirements on nominally similar objects which they use. Customization of object definitions for different applications is achieved by attaching modifiers called traits to pre-existing object defintions. This paper describes the approach and recounts our experience with traits. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Parameterized Programming

    Page(s): 528 - 543
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3998 KB)  

    Parameterized programming is a powerful technique for the reliable reuse of software. In this technique, modules are parameterized over very general interfaces that describe what properties of an environment are required for the module to work correctly. Reusability is enhanced by the flexibility of the parameterization mechanism proposed here. Reliability is further enhanced by permitting interface requirements to include more than purely syntactic information. This paper introduces three new ideas that seem especially useful in supporting parameterized programming: 1) theories, which declare global properties of program modules and interfaces; 2) views, which connect theories with program modules in an elegant way; and 3) module expressions, a kind of general structured program transformation which produces new modules by modifying and combining existing modules. Although these ideas are illustrated with some simple examples in the OBJ programming language, they should also be taken as proposals for an Ada1 library system, for adding modules to Prolog, and as considerations for future language design efforts. OBJ is an ultra-high level programming language, based upon rewrite rules, that incorporates these ideas, and many others from modern programming methodology. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Design of Ada Systems Yielding Reusable Components: An Approach Using Structured Algebraic Specification

    Page(s): 544 - 551
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2567 KB)  

    Our experience with design of Ada1 software has indicated that a methodology, based on formal algebra, can be developed which integrates the design and management of reusable components with Ada systems design. The methodology requires the use of a specification language, also based on formal algebra, to extend Ada's expressive power for this purpose. We show that certain requirements for the use of Ada packages which cannot be expressed in Ada can be expressed in algebraic specification languages, and that such specifications can then be implemented in Ada. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Use of Very High Level Languages and Program Generation by Management Professionals

    Page(s): 552 - 563
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3024 KB)  

    The introduction of very high level languages (VHLL) and automatic program generation are expected to reduce significantly the needed programming skills and considerably increase software development productivity. The paper explores the hypothesis that the preferred mode of developing management systems will be for the management professional to directly specify, generate, and debug the needed software without involvement of professional programmers. The investigation is experimental, by having an accountant develop an accounting system, using the equational type MODEL VHLL and program generator, and by monitoring carefully the times that it takes to perform certain steps or debug certain types of errors. The investigation consisted of progressive development of an accounting system in three stages: first a general ledger, extended for inventory management, and concluding with a major modification to incorporate reporting for the effects of changing prices in accordance with Financial Accounting Standard 33 (FAS 33). In this way the work pattern in modifying and maintaining a system was investigated as well. The developer was an M.B.A. candidate majoring in accounting with a limited computer background who determined the requirements of the accounting system and used MODEL to generate the programs, along with their extensions and modifications. A description of the accounting system design is presented first. Next, a sample MODEL specification is discussed in order to communicate generally the style of specifying computations in MODEL. This sample is used also to demonstrate the incorporation of FAS 33. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The Draco Approach to Constructing Software from Reusable Components

    Page(s): 564 - 574
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2647 KB)  

    This paper discusses an approach called Draco to the construction of software systems from reusable software parts. In particular we are concerned with the reuse of analysis and design information in addition to programming language code. The goal of the work on Draco has been to increase the productivity of software specialists in the construction of similar systems. The particular approach we have taken is to organize reusable software components by problem area or domain. Statements of programs in these specialized domains are then optimized by source-to-source program transformations and refined into other domains. The problems of maintaining the representational consistency of the developing program and producing efficient practical programs are discussed. Some examples from a prototype system are also given. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Program Reusability through Program Transformation

    Page(s): 574 - 588
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (5155 KB)  

    How can a program written in pure applicative LISP be reused in a Fortran environment? One answer is by automatically transforming it from LISP into Fortran. In this paper we discuss a practical application of this technique-one that yields an efficient Fortran program. We view this process as an example of abstract programming, in which the LISP program constitutes an abstract specification for the Fortran version. The idea of strategy-a strategy for getting from LISP to Fortran-is basic to designing and applying the transformations. One strategic insight is that the task is easier if the LISP program is converted to ``recursive'' Fortran, and then the recursive Fortran program is converted to nonrecursive standard Fortran. Another strategic insight is that much of the task can be accomplished by converting the program from one canonical form to another. Developing a strategy also involves making various implementation decisions. One advantage of program transformation methodology is that it exposes such decisions for examination and review. Another is that it enables optimizations to be detected and implemented easily. Once a strategy has been discovered, it can be implemented by means of rewrite-rule transformations using the TAMPR program transformation system. The transformational approach to program reuse based on this strategy has a measure of elegance. It is also practical-the resulting Fortran program is 25 percent faster than its compiled LISP counterpart, even without extensive optimization. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Reusability Through Program Transformations

    Page(s): 589 - 594
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2371 KB)  

    We describe a methodology and supporting programming environment that provide for reuse of abstract programs. Abstract programs are written using notations and constructs natural to the problem domain in a language realized by syntactic extension of a base language. Program transformations are employed to refine an abstract program into its concrete counterpart. We discuss the use of the methodology in the setting of rapid prototyping and custom tailoring. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Empirical Studies of Programming Knowledge

    Page(s): 595 - 609
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2594 KB)  

    We suggest that expert programmers have and use two types of programming knowledge: 1) programming plans, which are generic program fragments that represent stereotypic action sequences in programming, and 2) rules of programming discourse, which capture the conventions in programming and govern the composition of the plans into programs. We report here on two empirical studies that attempt to evaluate the above hypothesis. Results from these studies do in fact support our claim. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Call For Papers

    Page(s): 610 - 612
    Save to Project icon | Request Permissions | PDF file iconPDF (682 KB)  
    Freely Available from IEEE
  • [Front cover]

    Page(s): c2
    Save to Project icon | Request Permissions | PDF file iconPDF (26 KB)  
    Freely Available from IEEE

Aims & Scope

The IEEE Transactions on Software Engineering is interested in well-defined theoretical results and empirical studies that have potential impact on the construction, analysis, or management of software. The scope of this Transactions ranges from the mechanisms through the development of principles to the application of those principles to specific environments. Specific topic areas include: a) development and maintenance methods and models, e.g., techniques and principles for the specification, design, and implementation of software systems, including notations and process models; b) assessment methods, e.g., software tests and validation, reliability models, test and diagnosis procedures, software redundancy and design for error control, and the measurements and evaluation of various aspects of the process and product; c) software project management, e.g., productivity factors, cost models, schedule and organizational issues, standards; d) tools and environments, e.g., specific tools, integrated tool environments including the associated architectures, databases, and parallel and distributed processing issues; e) system issues, e.g., hardware-software trade-off; and f) state-of-the-art surveys that provide a synthesis and comprehensive review of the historical development of one particular area of interest.

Full Aims & Scope

Meet Our Editors

Editor-in-Chief
Matthew B. Dwyer
Dept. Computer Science and Engineering
256 Avery Hall
University of Nebraska-Lincoln
Lincoln, NE 68588-0115 USA
tseeicdwyer@computer.org