A Short History

Software development started with the arrival of the first computers in the 1960’s. Programming started to be hard-wired (fixed programming) or soft-wired (reprogramming was possible by changing the position of plugs). Later, programs could be fed to the computer. First in binary code, then assembler languages were developed (second generation) which were more readable to programmers. The next step in programming was the introduction of procedural languages (third generation) like Cobol and Basic. Although these languages were even closer to the human language and hide a lot of low level procedures and direct addressing of memory from the programmer, they were still modeled close to how a computer works, performing a number of tasks in the right order to get to the right result. But since computers were mainly concerned with heavy data processing and number crunching in those days, procedural languages worked fine.

The way programming took place ranged from very lightweight and informal (or even cowboy coding) to very formal and heavy processes, like the waterfall model used by NASA and the Department of Defense at that time. The waterfall model divides software development into 5 phases:

1. Requirements specification
2. Design
3. Implementation
4. Validation
5. Maintenance

To follow the waterfall model, the milestone of completing a phase must be reached, before continuing to the next phase. Though this is fine when the goal and requirements are clear, such a rigid process breaks down when assignments get too complex to do all design upfront and when shifting requirements and new insights are to be expected during implementation. That is why over time many improvements have been made on this model.

As tooling got better, tasks assigned to computers got more and more complex. Think of distributed systems, artificial intelligence, graphical user interfaces and integration of multimedia in applications like word processors, administrative systems, games, internet and so on. With this increase of possibilities, expectations of users grew and with them the complexity of the systems we are building. To manage this complexity and keep code comprehensible, programming languages had to be modeled closer to the way our brain works. In the 1980’s this resulted in a number of object oriented languages like Smalltalk. Here a program is viewed as a collection of cooperating objects. An object is a reusable unit of code, combining data structures and the logic to operate on them. These objects are modeled close to real life business objects like ‘customer’ or ‘savings account’. In the 1990’s object orientation became the most dominant form of programming with languages like C++ and Java.

With these new languages came the need for new ways of modeling and building software. To ensure customer satisfaction, more interaction with users was needed and software had to evolve, rather than be constructed following a pre-defined grand design. Several software development methods emerged, which can be qualified as iterative and incremental. ‘Iterative’ means that you repeat the same process steps over and over until you reach the desired result. ‘Incremental’ means that you start with implementing a small piece of functionality into a usable solution and proceed with adding pieces of functionality until you reach the desired result.

An overview of events surrounding early IT and software development is shown in Figure 1.


Figure 1: Timeline Early IT and Software Development