Stages of Emergence of Software Engineering

Emergence of Software Engineering:

There are mainly Six Stages of the Emergence of Software Engineering:

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 usually written in assembly languages.

Program lengths typically limited to about a few hundred lines of monolithic assembly code. Every programmer developed his 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 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. 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 more than 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 was needed to solve further challenging problems.

Therefore, software developers looked out for more effective techniques for designing software and Data Flow-Oriented Design techniques proposed. The functions also called processes and the data items that exchanged between the different functions represented in a diagram 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. Then the relationships among the objects such as composition, reference, and inheritance are determined. Each object essentially acts as a data hiding also known as data abstraction.

Object-oriented techniques have gained widespread 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.