Software development occurs simultaneously in two opposite directions.

Life of any program usually goes through three stages, and in their work developers and designers must take into account all three stages. Usually only the development stage and the stage of use are considered. However, in the early stages of development, the support (maintenance) or continuing development stage should also be taken into account.

There are six stages of software development: defining requirements, designing, writing commands, layout, testing and documentation.

Development of large software systems often depends on available hardware.

Any process can be expressed by several different "correct" command sequences.

The software is abstract in nature which makes the process of software development more complicated.

The main tool for creating new software is the calculating machine and its software.

When developing software, the main difficulty is usually not the function that the system should perform, but the method of interaction with the user to which the system should comply.

Some types of software can be developed using the same methods as the hardware; others cannot be developed the same way.

The correct software is not subject to any failures. The term "support" in relation to software is therefore incorrect.

The development of large programs is a very versatile activity, by no means related only to work on a computer.

A large software system can never be fully debugged, even after several years of testing and use.

Software development is often a very time consuming and expensive process.

Software is not a goal, but a means.

Software development occurs simultaneously in two opposite directions. In the mid 30's, the English mathematician Alain Turing proved that any process that can be described by any algorithm can be implemented with a simple machine that performs only six different commands, although this can take a very long time. From this principle, it follows logically that a computing machine - any general purpose computing machine - can do anything that can be described by any algorithm. Modern software is becoming more and more complex, finding wider and more complex applications, and at the same time being "ordinary" products of everyday use of the general public.

The huge progress in integrated circuit technology has dramatically lowered the price of the hardware, and this process will continue. What seemed to be inaccessible a few years ago due to price or lack of time is quite achievable today.

At the same time, the simultaneous reduction in cost and increase in machine power have extended the scope of the computer's application immediately to the upper and lower levels.

At the upper level, associated with large-scale efforts, computing machines are able to perform tasks in the required time, and these tasks have now been solved. And at the lower level, simple machines with low performance become so cheap that it is now cost-effective to use them to automate those processes that a year or two ago did not make sense to automate.

This development of computer technology in two directions should not seem to surprise or embarrass anyone, but sometimes it happens. Software for the upper level is becoming more and more complex, and for the lower level programs are constantly being simplified.

Software consists of many different types of programs. Programs do the best they can; they can be small and trivial, but they can also be large and complex, very expensive. Software can only be talked about by using at least one qualifying word. Are we talking about "project software" or "software as a product"? Is it "real time" or "package"? Or maybe it's about "dialogue"? What do we mean: "interference immunity", "noise immunity" or just reliability? What software are we talking about - "instrumental", "system" or "application"? Are we talking about "large-scale" or "small-scale" software? Each of these categories has its own characteristics that are unique to it.

The life of the program is divided into three phases. Too often program developers focus their attention only on the development phase, sometimes also on the phase of use and very rarely on the maintenance phase or ongoing development to greater damage to the latter. Something can and should be done during the development phase to facilitate other phases. Most developers ignore this aspect. Many books on the development and use of programs ignore the fact that these three phases exist separately from each other, have different objectives and are often guided by different people.

Software development consists of six phases: defining requirements, designing, writing commands, layout, testing and documentation. The easiest part of this list is writing commands. It is very difficult to design the optimal or at least correct interaction of a large number of programs. For large systems, it is most difficult to define the requirements of users, and therefore of these systems themselves. However, most of the training courses and books are mainly focused on writing commands. As we will see in the future, special attention must be paid to defining requirements and designing them.

Software development for large systems often depends on hardware. Larger systems usually require that the hardware is used optimally in order to save and increase performance.

It is especially important to properly plan the CPU load and define all memory requirements. All of this forces designers to consider the parameters and characteristics of the system hardware when designing programs. This is not the case with small programs.

The performance of the system - i.e. the ability of the computer to complete a task in a certain period of time - depends largely on the hardware used, its power and composition. If the hardware is not suitable for the task, the whole burden of achieving the necessary performance limits rests on the shoulders of software developers, and especially those involved in the design. This is the main reason that sometimes developers of large systems or real-time systems have to give up using high-level languages. We will see a few more examples of how the requirement to achieve high performance complicates development.