Stages of Emergence of Software Engineering

There are mainly Six Stages of Emergence of Software Engineering is given below:

1. Early Computer Programming: Early commercial computers were very slow and too elementary as compared to today’s standards. Even simple processing tasks took considerable computation time on those computers. No wonder that programs at that time were very small in size and lacked sophistication. Those programs were usually written in assembly languages.
Program lengths were typically limited to about a few hundreds of lines of monolithic assembly code. Every programmer developed his own individualistic style of writing programs according to his intuition and used this style ad hoc while writing different programs.

2. High-level Language Programming: Computers became faster with the introduction of semiconductor technology in the early 1960s. Faster semiconductor transistors replaced the prevalent vacuum tube-based circuits in a computer. With the availability of more powerful computers, it became possible to solve larger and more complex problems.
At this time, high-level languages such as FORTRAN, ALGOL, and COBOL were introduced. This considerably reduced the effort required to develop software and helped programmers to write larger programs.
Writing each high-level programming construct in effect enables the programmer to write several machine instructions. However, the programmers were still using the exploratory style of software development.

3. Control Flow-based Design: A program’s control flow structure indicates the sequence in which the program’s instructions are executed. In order to help develop programs having good control flow structures, the flowcharting technique was developed. Even today, the flowcharting technique is being used to represent and design algorithms.

4. Data Structure-oriented Design: Computers became even more powerful with the advent of Integrated Circuits (ICs) in the early 1970s. These could now be used to solve more complex problems. Software developers were tasked to develop larger and more complicated software. which often required writing in excess of several tens of thousands of lines of source code.
It is much more important to pay attention to the design of the important data structures of the program than to the design of its control structure. Design techniques based on this principle are called Data Structure-oriented Design.

Example: Jackson’s Structured Programming (JSP) technique developed by Michael Jackson (1975). In JSP methodology, a program’s data structure is first designed using the notations for sequence, selection, and iteration. The JSP methodology provides an interesting technique to derive the program structure from its data structure representation.

5. Data Flow-oriented Design: As computers became still faster and more powerful with the introduction of very large scale integrated (VLSI) Circuits and some new architectural concepts, more complex and sophisticated software were needed to solve further challenging problems. Therefore, software developers looked out for more effective techniques for designing software and Data Flow-Oriented Design techniques were proposed.
The functions are also called as processes and the data items that are exchanged between the different functions are represented in a diagram is known as a Data Flow Diagram (DFD).

6. Object-oriented Design: Object-oriented design technique is an intuitively appealing approach, where the natural objects (such as employees, etc.) relevant to a problem are first identified and then the relationships among the objects such as composition, reference, and inheritance are determined. Each object essentially acts as a data hiding is also known as data abstraction.
Object-oriented techniques have gained wide spread acceptance because of their simplicity, the scope for code and design reuse, promise of lower development time, lower development cost, more robust code, and easier maintenance.