By Topic

Software Engineering, IEEE Transactions on

Issue 2 • Date Feb. 1986

Filter Results

Displaying Results 1 - 19 of 19
  • Guest editors' prologue special issue on software design methods

    Page(s): 185 - 191
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1959 KB)  

    We describe why these papers were chosen, and categorize them in terms of major contribution, underlying model of the software life-cycle, and applicability to various types of system. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Data structured programming: Program design without arrays and pointers

    Page(s): 192 - 197
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1387 KB)  

    Structured programming introduced a new discipline for accessing the instructions of a program. In suitable programming languages, this discipline can be described in terms of program design without gotos. It can be shown, for example, that any functional result achievable in a programming language with gotos can be achieved in that same language without gotos if sequence, selection, and iteration control constructs are present. The gotos permit random access to the instructions while sequence, selection, and iteration provide much more limited and disciplined access. The authors introduce a new discipline for accessing the data of a program. Any functional result achievable in a programming language with arrays and pointers can be achieved in that same language without arrays and pointers if set, stack, and queue data types are present. The arrays and pointers permit random access to the data while sets, stacks, and queues provide much more limited and disciplined access. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • The transformation schema: An extension of the data flow diagram to represent control and timing

    Page(s): 198 - 210
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2484 KB)  

    The data flow diagram has been extensively used to model the data transformation aspects of proposed systems. However, previous definitions of the data flow diagram have not provided a comprehensive way to represent the interaction between the timing and control aspects of a system and its data transformation behavior. An extension of the data flow diagram called the transformation schema is described. This schema provides a notation and formation rules for building a comprehensive system model, and a set of execution rules to allow prediction of the behavior over time of a system modeled in this way. The notation and formation rules allow depiction of a system as a network of potentially concurrent `centers of activity' (transformations), and of data repositories (stores), linked by communication paths (flows). The execution rules provide a qualitative prediction rather than a quantitative one, describing the acceptance of inputs and the production of outputs by the transformations but not input and output values. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Object-oriented development

    Page(s): 211 - 221
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2975 KB)  

    Object-oriented development is a partial-lifecycle software development method in which the decomposition of a system is based upon the concept of an object. This method is fundamentally different from traditional functional approaches to design and serves to help manage the complexity of massive software-intensive systems. The author examines the process of object-oriented development as well as the influences upon this approach from advances in abstraction mechanisms, programming languages, and hardware. The concept of an object is central to object-oriented development and so the properties of an object are discussed. The mapping of object-oriented techniques to Ada using a design case study is considered. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An overview of JSD

    Page(s): 222 - 240
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3626 KB)  

    The Jackson System Development (JSD) method addresses most of the software lifecycle. JSD specifications consist mainly of a distributed network of processes that communicate by message-passing and read-only inspection of each other's data. A JSD specification is therefore directly executable, at least in principle. Specifications are developed middle-out from an initial set of `model' processes. The model processes define a set of events, which limit the scope of the system, define its semantics, and form the basis for defining data and outputs. Implementation often involves reconfiguring or transforming the network to run on a smaller number of real or virtual processors. The main phase of JSD are introduced and illustrated by a small example system. The rationale for the approach is discussed. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Functional programming, formal specification, and rapid prototyping

    Page(s): 241 - 250
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2209 KB)  

    Functional programming has enormous potential for reducing the high cost of software development. Because of the simple mathematical basis of functional programming, it is easier to design correct programs in a purely functional style than in a traditional imperative style. It is argued that functional programs combine the clarity required for the formal specification of software designs with the ability to validate the design by execution. As such they are ideal for rapidly prototyping a design as it is developed. An example is presented which is larger than those traditionally used to explain functional programming. This example is used to illustrate a method of software design which efficiently and reliably turns an informal description of requirements into an executable formal specification. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A rational design process: How and why to fake it

    Page(s): 251 - 257
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1705 KB)  

    Many have sought a software design process that allows a program to be derived systematically from a precise statement of requirements. It is proposed that, although designing a real product in that way will not be successful, it is possible to produce documentation that makes it appear that the software was designed by such a process. The ideal process and the documentation that it requires are described. The authors explain why one should attempt to design according to the ideal process and why one should produce the documentation that would have been produced by that process. The contents of each of the required documents are outlined. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A recommended practice for describing software designs: IEEE standards project 1016

    Page(s): 258 - 263
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1558 KB)  

    The method outlined presumes that a design is completely described when the information needs of each design user are satisfied. The minimum set of design users and their specific information requirements are discussed. An information model is used to describe the needed design information through a set of 15 standard design entity attributes. To simplify the access and assimilation of design information, an organization of the entity attributes into four distinct design views is proposed. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • An empirical study of software design practices

    Page(s): 264 - 271
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1692 KB)  

    Results of an empirical study of software design practices in one specific environment are reported. The practices examined affect module size, module strength, data coupling, descendant span, unreferenced variables, and software reuse. Measures characteristic of these practices were extracted from 887 Fortran modules developed for five flight dynamics software projects monitored by the Software Engineering Laboratory. The relationship of these measures to cost and fault rate was analyzed using a contingency table procedure. The results show that some recommended design practices, despite their intuitive appeal, are ineffective in this environment, whereas others are very effective. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • A metaprogramming method and its economic justification

    Page(s): 272 - 277
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (1474 KB)  

    Metaprogramming, defined as creating application programs by writing programs that produce programs, is presented as the basis of a method for reducing software costs and improving software quality. The method starts with a rapid prototyping phase in which selected representative parts of the application are prototyped; this is followed by a tooling up phase, during which the metaprogramming occurs. The final phase is the production of the application programs using the software tools and techniques of the metaprogramming phase. The author summarizes the experience of two projects that support the assertion that metaprogramming is an efficient way to produce programs, since these projects used metaprogramming in their development. An economic theory which justifies this approach is outlined. It is shown how to do a cost/benefit analysis of the method. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Constrained expressions: Adding analysis capabilities to design methods for concurrent software systems

    Page(s): 278 - 292
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3716 KB)  

    An approach to the design of concurrent software systems based on the constrained expression formalism is described. This formalism provides a rigorous conceptual model for the semantics of concurrent computations, thereby supporting analysis of important system properties as part of the design process. This approach allows designers to use standard specification and design languages, rather than forcing them to deal with the formal model explicitly or directly. As a result, the approach attains the benefits of formal rigor without the associated pain of unnatural concepts or notations for its users. The conceptual model of concurrency underlying the constrained expression formalism treats the collection of possible behaviors of a concurrent system as a set of sequences of events. The constrained expression formalism provides a useful closed-form description of these sequences. Algorithms were developed for translating designs expressed in a wide variety of notations into these constrained expression descriptions. A number of powerful analysis techniques that can be applied to these descriptions have also been developed. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • SARA (System ARchitects Apprentice): Modeling, analysis, and simulation support for design of concurrent systems

    Page(s): 293 - 311
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (4260 KB)  

    An environment to support designers in the modeling, analysis, and simulation of concurrent systems is described. It is shown how a fully nested structure model supports multilevel design and focuses attention on the interfaces between the modules which serve to encapsulate behavior. Using simple examples, it is shown how a formal graph model can be used to model behavior in three domains: control flow, data flow, and interpretation. The effectiveness of the explicit environment model in SARA is discussed and the capability to analyze correctness and evaluate performance of a system model is demonstrated. A description of the integral help designed into SARA shows how the designer can be offered consistent use of any new tool introduced to support the design process. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Salient features of an executable specification language and its environment

    Page(s): 312 - 325
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (3205 KB)  

    The executable specification language PAISLey and its environment are presented as a case study in the design of computer languages. It is shown that PAISLey is unusual (and for some features unique) in having the following desirable features: (1) there is both synchronous and asynchronous parallelism free of mutual-exclusion problems, (2) all computations are encapsulated, (3) specifications in the language can be executed no matter how incomplete they are, (4) timing constraints are executable, (5) specifications are organized so that bounded resource consumption can be guaranteed, (6) almost all forms of inconsistency can be detected by automated checking, and (7) a notable degree of simplicity is maintained. Conclusions are drawn concerning the differences between executable specification languages and programming languages, and potential uses for PAISLey are given. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Developing interactive information systems with the User Software Engineering methodology

    Page(s): 326 - 345
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (4236 KB)  

    User software engineering (USE) is a methodology, supported by automated tools, for the systematic development of interactive information systems. The USE methodology gives particular attention to effective user involvement in the early stages of the software development process, concentrating on external design and the use of rapidly created and modified prototypes of the user interface. The USE methodology is supported by an integrated set of graphically based tools. The USE methodology and the tools that support it are described. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Process-translatable Petri nets for the rapid prototyping of process control systems

    Page(s): 346 - 357
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (2364 KB)  

    A methodology for the rapid prototyping of process control systems which is based on an original extension to classical Petri nets is presented. The proposed nets, called PROT nets, provide a suitable framework to support the following activities: building an operational specification model; evaluation, simulation, and validation of the model; and automatic translation into program structures. PROT nets are shown to be translatable into Ada program structures concerning concurrent processes and their synchronizations. The authors illustrate this translation in detail using, as a working example, the problem of tool handling in a flexible manufacturing system. View full abstract»

    Full text access may be available. Click article title to sign in or learn about subscription options.
  • Real-time software life cycle with the model system

    Page(s): 358 - 373
    Save to Project icon | Request Permissions | Click to expandQuick Abstract | PDF file iconPDF (886 KB)  

    The use of an assertive specification language for real-time software development and maintenance is considered. The language is used for asserting the acts or relations inherent in the problem to be solved; this is in contrast to conventional programming languages, which are used to express the computer solution. Expressing a problem in Model consists of declaring array variables and defining their relationships through equations. This is different from conventional programming, which relates the problem in terms of computer operations. The language is supported by an automatic system which interacts with the user in soliciting missing definitions or correcting inconsistencies, and which translates the specification into a near-optimal computer solution. The main advantages of this approach are indicated. The use of Model in real-time software development and maintenance is reviewed. Differences from conventional programming are stressed through an example, which also illustrates the use of the three automatic components of the Model system. 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): 374
    Save to Project icon | Request Permissions | PDF file iconPDF (64 KB)  
    Freely Available from IEEE
  • Ada™ applications and environments

    Page(s): 1
    Save to Project icon | Request Permissions | PDF file iconPDF (355 KB)  
    Freely Available from IEEE
  • Call for papers

    Page(s): 1
    Save to Project icon | Request Permissions | PDF file iconPDF (193 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