Emergence of Software Engineering?

5. Emergence of Software Engineering?

Ans:
  Early Computer Programming (1950s):

-        Programs were being written in assembly language.

-        Programs were limited to  about a few hundreds of lines of assembly code.

• Every programmer developed his own style of writing programs:

-        according to his intuition  (exploratory programming).

High-Level Language Programming (Early 60s)

• High-level languages such as FORTRAN, ALGOL, and COBOL were introduced:

-        This reduced software development efforts greatly.

• Software development style was still exploratory.

-        Typical program sizes were limited to a few thousands of lines of source code.

Control Flow-Based Design (late 60s)

• Size and complexity of programs increased further:

-        exploratory programming style proved to be insufficient. 

• Programmers found: 

                  -        very difficult to write cost-effective and correct programs

-        programs written by others very difficult to understand and maintain.

• To over come with this problem, experienced programmers advised: ``Pay particular attention to the   design of the program's control structure.'’               
• A program's control structure indicates:

-         the sequence in which the program's instructions are executed.

• To help design programs having good control structure:

-        flow charting technique was developed.

• Using  flow charting technique:

-        one can represent and design a program's control structure.

-        Usually one understands a program:

·        by mentally simulating the program's execution sequence

• A program having a difficult(messy) flow chart representation:

-        difficult to understand and debug.

• It was found:

-        GO TO statements  makes control structure of a program messy(difficult, unorganized)

-        GO TO statements alter the flow of control arbitrarily.

-        The need to restrict use of GO TO statements was recognized.

• Many programmers  had extensively used assembly languages.

-        JUMP instructions are frequently used for program branching in assembly languages,

-        programmers considered use of GO TO statements inevitable.

• But, soon it was conclusively proved:

-        only three programming constructs are sufficient to express any programming logic:

·        sequence  (e.g. a=0;b=5;)

·        selection (e.g.if(c=true) k=5 else m=5;)

·        iteration   (e.g. while(k>0) k=j-k;)

• Everyone accepted:

-        it is possible to solve any programming problem without using GO TO statements.

-        This formed the basis of  Structured Programming  methodology.