Home   Learning Computing History

Software Engineering
 

Up

 

 

 

 

 

 

A Brief History of Software Engineering

 Software is a collection of computer programs, procedures, rules, associated documentation and data. [*IEEE]  Software Engineering is the discipline of software process, development, methods and tools.  It comprises standard specification, design techniques, formal analysis, established processes, architecture, and more. It addresses practical constraints and involves mathematics, management, psychology, and economics in addition to computer science.

 Software engineering is necessary for large projects, multiple subsystems, teams of developers and safety-critical systems for they are featured by complexity, conformity, changeability and invisibility.  The aim is to produce quality software using limited resources and time.  A well engineered software system has a good maintainability, reliability, efficiency, user interfaces and functionality. 

Before 60’s, there was no form for software, as soon as the bounds on what computer can do diminished, software engineering aspirated  by chronic failures of large software project and evolved through structured programming, functional decomposition, structured analysis and design, data-centered paradigm and object-oriented paradigm.

 

The History of Software Engineering:

1968-1980s Formation of Software Lifecycle Concept, it initialized programming and design methodologies, requirement engineering and description technologies, and project management. The goal is high software reliability and productivity with easy-to-test and easy-to-change structure.

  • 1968: Peter Naur et al coined the term “software engineering” at NATO conference in Garmisch-Partenkirchen and point out software should following an engineering paradigm, it was the response to software crisis which provided with too little quality, too late deliver and over budget.

  • 1975: Frederick P. Brook Jr. book on “Software Engineering” which tackles the question of how to organize and manage large-scale programming projects.

Programming and Design Methodologies:

  • 1972: E.W. Dijkstra book on structured programming
  • 1972: D.L. Parnas “Parnas Module” which indicated information hiding.
  • 1975: M.A. Jackson book on “Principles of Program Design”, which model data and algorithms largely separated.
  • 1978: G.J. Myers articles “Composite/Structured Design” for composite design.
  • 1979: Edward Yordon and L.L. Constantine book on structured design

 They affected heavily on how programming languages were being structured then after.

 

User’s Requirements, Requirement Engineering and Description Technologies:

  • 1977: D. Teichrow and E. Hershey paper on prototyping as a tool in the specification of user requirements.
  • 1977: D. Ross paper on structured analysis.
  • 1977: M.W. Alford paper on the use of lexical affinities in requirements extraction

 

Project Management Technologies:

  • 1981: Barry Boehm book on “Software Engineering , Economics” which addresses the cost estimation issues

  • 1976: T.J. MaCabe paper on software complexity measures and the detection of risky factors.

  • 1977: M.H. Halstead book -- “Elements of Software Science” which coined the term E measure – efforts measure.

  • 1978: ICSE, Proceedings of the 3rd International Conference on Software Engineering

  • 1982: C.V. Ramamoorthy and F. B. Bastani paper on estimation of terminating test activities.

At this phase, procedures started to be separated form the data, further more related procedures and data were brought together into subsystems.

 

1980-1990 Prototyping technologies and formalization, partial automation in upstream, includes analysis of dynamic, formal methods, and CASE tools.

  • 1986: William. W. Agresti paper on appearance of prototyping technologies, which discarded water fall model and shift to prototyping.

Analysis of Dynamic Behavior of Specification:

  • 1983: M. A. Jackson book on JSP (Jackson Structured Programming), a method for designing programs as compositions of sequential processes and JSD (Jackson System Development), a method for specifying and designing systems
  • 1986: Paul T. Ward paper on real-time data flow
  • 1986: Pamela Zave and William Schell paper on PAISLey, an executable specification language which is accompanied by a set of specification methods, analysis techniques, and software support tools.
  • 1986: Giorgio Bruno and Giuseppe Marchetto paper on PROTnet, a Process-Translatable Petri Nets for the Rapid Prototyping of Process Control Systems
  • 1986: Anthony I. Wasserman et. al paper on user interface simulation

Formal Methods:

  • ISO standardization, such as GKS (1985), the computer graphics standard, and PREMO (1998) the multi-media standard.
  • SRI’s PVS (Prototype Verification System) Theorem Prover
  • Bell Labs’s SPIN model checker

 

CASE (Computer Aided Software Engineering) Tools:

  • 1988:  Meilir Page-Jones book “The Practical Guide to Structured System Design”, which features SA/SD--Structured Analysis/Structured Design with modularized view, A structure chart is used to show the programmers of a system how the system is partitioned into modules.
  • 1989:ISSRE Proceedings of the Sixth International Symposium on Software Reliability Engineering

Around this time, subsystems began to be layered.

 1985-1995 Software Process Model, this includes process programming, CMM, integrated environment, and analyzing and supporting human factor.

 Software Process and SPI – Software Process Improvement:

  • 1986: Frederick P Brooks, Jr. paper on information processing which address the essence and accidents in software development and the ratio between them, summarized as “ No Silver Bullet”
  • 1987: Lee Osterweil paper on process programming
  • 1989: Watts S. Humphrey book “Managing the Software Process”, featured CMM--Capability Maturity Model, which optimize software process in five levels: initial, repeatable, defined, managed, optimizing.

 Integrated Environments:

  • 1993: Lois Wakeman and Jonathan Jowett book “PCTE – The Standard for Open Repositories” which discussed tool integration.

 Analyzing and Supporting Human Factor:

  • 1986: Bill Curties paper on protocol and human factors analysis
  • 1988: Colin Potts and Glenn Bruns paper on design decision, which discussed communication support.
  • 1992: FSE 7th European engineering conference held jointly with the 7th ACM SIGSOFT international symposium on Foundations of software engineering

  

1985-present Network Age, this includes Object oriented technologies, distributed computing, open source software development and web engineering.

 

Object Oriented Technologies:

Programming Language

  • 1967: O.J. Dahl papers on SIMULA, a precursor to the OO language Simula, which featured class, instance and module.

  • 1976: Lampson et al introduced EUCLID, a related type systems Euclid, one of the first languages that considered the problem of aliasing, and included constructs to express.

  • 1976: Niklaus Wirth introduced Modula, a language derived from Pascal, which featured the module.

  • 1977: B. Liskov paper on CLU, which was the first implemented programming language to provide direct linguistic support for data abstraction and featured cluster.

  • 1979: JD lchbiah et al  Ada, a programming language which featured package

  • 1981: Alan kay and Dan Ingalls et al/Xerox introduced Smalltalk 80, an object-oriented programming language.

  • 1986: Brad Cox  introduced the first Objective-C compiler

  • 1986 Bjarne Stroustrup introduced C++ Programming Language

  • 1988: Bertrand Meyer Eiffel, an elegant object oriented language, designed to support reuse, and including support for logical assertions.

  • 1989: David. A. Moon introduced CLOS -- Common Lisp Object System

  • 1995 James Gosling/Sun Microsystems introduced Java, a simplified C++ like OOP which expressly designed for use in the distributed environment of the Internet.

Object Oriented Analysis and Design

  • 1986: G. Booch introduced OOD(Object-Oriented Design)

  • 1988: Shlare-Mellor papers on viewing systems as architecture, it corresponds to breaking a large system up into components.

  • 1991: Peter Coad , Edward Yourdon  book on the principles of object-oriented technology

  • 1991: J. Rumbaugh book on Object-Oriented Modeling and Design and introduced OMT (Object Modeling Technique).

  • 1995: Ivar Jacobson paper on using case driven approach, which introduced OOSE (Object-Oriented Software Engineering).

  • 1995: Eric Gamma, Richard Helm, Ralph Johnson, John Vlissides book on design patterns

  • 1995: Ted Lewis et al book “Object Oriented Application Frameworks”

  • 1997: Clemens Szypersky book “Component Software – beyond object-oriented programming” introduced software components

  • 1999: Ivar Jacobson, James Rumbaugh, Brady Booch books on the unified software development process, modeling and language, which introduced UML

Here are the big object orientation methodologies, and layering and OOP are quickly in complementing to each other.

 

Open Source Software Development

  • 1997: Eric S. Raymond outlined the core principles of open source movement in a manifesto called "The Cathedral and the Bazaar".

Current Topics:

  • Design patterns

  • Application frameworks and software components

  • Distributed Computing

    • Concurrent Object Oriented Languages

    • Distributed Object oriented Languages

    • Middleware

      • RPC

      • RMI

      • Corba

    • Open Source Software Development

    • Web Engineering

 

Summery: The software engineering has advanced lots over the past three decades, it follows IT technologies step by step and evolving itself along; Today’s trends strong on qualitative breakthroughs, such as quantification, cause-effect modeling, and process orientation.  However, from fundament principle to web and distributed engineering, it still has a quite bit to work out if it is not merely with one opinion to against another.

 
Last modified: 2004 December 5