The choice of application development techniques becomes the No. 1 challenge in the face of rapid market growth. According to research by Gartner, as early as 2015, the world spent 310 billion US dollars on software for enterprises. The development of the Rapid Application Development (RAD) concept was the basis for creating a flexible, adaptive application development system that would be a counterweight to the rigid “waterfall” model.
The term Rapid Application Development usually refers to a software development process that contains 3 elements:
– a small team of programmers (from 2 to 10 people);
– a short but carefully worked out production schedule (from 2 to 6 months);
– a repetitive cycle in which developers, as the application begins to take shape, request and implement the requirements received through interaction with the customer in the product.
The development team should be a group of professionals with expertise in analysis, design, code generation and software testing using CASE tools. Members of the team should also be able to transform into working prototypes the end-user offerings.
The life cycle of software using the RAD methodology consists of four phases:
- the analysis and requirements planning phase;
- the design phase;
- phase of construction;
- introduction phase.
In the phase of analysis and requirements planning, system users define the functions that it must perform, identify the most priority ones, which need to be worked out in the first place, describe information needs. The definition of requirements is carried out mainly by the forces of users under the guidance of specialist developers. The scope of the project is limited, the timeframe for each of the subsequent phases is determined. In addition, the very possibility of implementing this project in the established funding framework, on these hardware, etc., is determined. The result of this phase should be the list and priority of future Information system functions, preliminary functional and information models of Information system.
During the design phase, some users take part in the technical design of the system under the guidance of development specialists. CASE tools are used to quickly get working prototypes of applications. Users, directly interacting with them, refine and supplement the system requirements that were not identified in the previous phase. The system processes are discussed in more detail. The functional model is analyzed and, if necessary, corrected. Each process is considered in detail. If necessary, for each elementary process, a partial prototype is created: a screen, a dialog, a report that eliminates ambiguities or ambiguities. The requirements for differentiating access to data are defined. At the same phase, a set of necessary documentation is being determined.
After a detailed determination of the composition of the processes, the number of functional elements of the system being developed is estimated and a decision is made to divide the IP into subsystems that can be implemented by one development team for a time acceptable for RAD projects – about 60 to 90 days. Using CASE-tools, the project is distributed among different teams (the functional model is divided). The result of this phase should be:
– general information model of the system;
– functional models of the system as a whole and subsystems implemented by individual development teams;
– precisely defined by means of CASE-means interfaces between autonomously developed subsystems;
– built prototypes of screens, reports, dialogues.
All models and prototypes should be obtained with the use of those CASE-means, which will be used later in the construction of the system. This requirement is caused by the fact that in the traditional approach when information about the project is transferred from stage to stage, there can actually be an uncontrolled distortion of data. The use of a single information storage medium about the project avoids this danger.
Unlike the traditional approach, which used specific prototyping tools not designed to build real applications, and the prototypes were discarded after the task of eliminating ambiguities in the project, in the RAD approach, each prototype develops into a part of the future system. Thus, more complete and useful information is transmitted to the next phase.
At the construction phase, the very rapid development of the application itself is performed. At this phase, the developers perform an iterative construction of a real system based on the models obtained in the previous phase, as well as non-functional requirements. The program code is partially generated using automatic generators that receive information directly from the CASE repository. End users in this phase evaluate the results and make adjustments if the system ceases to meet the previously defined requirements during the development process. The system is tested directly in the development process.
After the completion of each separate team of developers, this part of the system is gradually integrated with the rest, the complete code is generated, the joint work of this part of the application with the rest is tested, and then the system as a whole is tested. The physical design of the system is completed:
- the need for data distribution is determined;
- data usage analysis;
- the physical design of the database is performed;
- requirements for hardware resources are defined;
- how to increase productivity;
- the development of project documentation is being finalized.
The result of the phase is a ready-made system that meets all agreed requirements.
During the implementation phase, users are trained, organizational changes and, in parallel with the implementation of the new system, work is carried out with the existing system (until the new system is fully implemented). Since the phase of construction is rather short, planning and preparation for implementation must begin in advance, as a rule, at the design stage of the system. The above scheme of IS development is not absolute. Various options are possible, depending, for example, on the initial conditions in which the development is being carried out: an entirely new system is being developed; The enterprise survey has already been carried out and there is a model of its activity; At the enterprise already exists some IS, which can be used as an initial prototype or should be integrated with the developed one.
It should be noted, however, that RAD methodology, like any other, can not claim universality, it is good first of all for relatively small projects being developed for a specific customer. If a typical system is developed that is not a finished product, but is a complex of typical components that are centrally followed, adapted to software and hardware platforms, databases, telecommunications, organizational and economic features of implementation sites and integrated with existing developments, such project indicators as controllability and quality, which may conflict with the simplicity and speed of development. Such projects require a high level of planning and strict design discipline, strict adherence to predefined protocols and interfaces, which reduces the speed of development.
The RAD methodology is not applicable for building complex calculation programs, operating systems or spacecraft control programs, i.e. programs that require writing a large volume (hundreds of thousands of lines) of unique code.
Are not suitable for development using the RAD methodology of an application in which there is no clearly defined interface that visually determines the logic of the system (for example, real-time applications) and applications on which human security depends (for example, control of an airplane or a nuclear power plant), since iterative the approach assumes that the first few versions will certainly not be fully operational, which in this case is excluded.
The size of applications is estimated on the basis of so-called functional elements (screens, messages, reports, files, etc.). Such a metric does not depend on the programming language on which the development is carried out. The size of the application, which can be performed using the RAD methodology, for a well-developed IDE with the maximum reuse of software components, is defined as follows:
|<1000 functional elements||one person|
|1000-4000 functional elements||one development team|
|> 4000 functional elements||4000 functional elements per one development team|
As a summary, we list the main principles of the RAD methodology:
- development of applications by iterations;
- it is not necessary to complete the work at each stage of the life cycle;
- mandatory involvement of users in the process of developing IP;
- The necessary application of CASE-tools that ensure the integrity of the project;
- application of configuration management tools that facilitate the introduction of changes to the project and maintenance of the finished system;
- the necessary use of code generators;
- use of prototyping, which allows to fully understand and satisfy the needs of the end user;
- testing and development of the project, carried out simultaneously with the development;
- development of a small, well-managed team of professionals;
- competent management of system development, clear planning and monitoring of work performance.