Rapid Application (RAD) and Component-Based Development

Introduction

Traditional methods of software engineering are considered to be process-heavy and cumbersome. Large, complex, and slowly evolving software requires procedure-centric, bureaucratic methods of development and handling. It takes years together to complete the project.

Software engineering provides a parallel process model that allows building different components in an incremental model. One such type of process model is Rapid Application Development (RAD). The RAD model is flexible and adaptable to changes as it employs short development cycles.

Rapid Application Development (RAD)

RAD is a software development methodology that uses very little planning. The concept of parallelism is used in this model, several prototypes representing functional modules are developed in parallel, which are later combined to get the final product. This process aids in quicker product delivery.

This process employs minimal planning and hence can accommodate changes. It uses iterative and incremental development strategies. Small dedicated teams work progressively on their modules and develop reusable prototypes.

It involves user participation thereby increasing chances of early user community acceptance and an overall reduction in project risk. The result is high-quality software in the least possible time duration and with higher customer satisfaction.

The RAD process has three main objectives to meet:

• Timely and speedy delivery of a working application
• Helping the customer to identify the requirements properly
• Meet the customer's requirements with accuracy using prototypes and iterations
  
  
  

1. RAD Phases

The RAD life cycle includes all the activities such as analysis, design, construction, and testing in the series of cycles that promote short and iterative development.

The phases in the RAD model are as follows:

• Business Modeling - In this phase, a business model of the developed product is designed. The design model identifies the flow of information between the various functions of the business. This plays an important role in business analysis.
  
  
• Data Modeling - In this phase, the information gathered during the business analysis is reviewed in terms of the data objects involved in the business. For example, in a banking application development, the valid data objects will be information related to customers, accounts, and so on. The data objects are represented with a set of attributes and also their relationship with other data objects is identified.
  
  
• Process Modeling - In this phase, the identified data objects are implemented to achieve the identified information flow in the business. Detailed descriptions are provided on how operations such as insertion, deletion, or updation are performed on a data object.
  
  
• Application Generation - In this phase, prototypes of actual systems are built by providing an implementation for identified processes and data models.
  
  
• Testing and Turnover - As each prototype is independently tested in the RAD model, the total time taken to test the overall system is reduced. This may also reduce the major problems that may be identified when the final project is tested.
  
  
  

2. Applications of the RAD Model

The RAD model can be chosen for projects with the following criteria:

• When there is a need to develop the system as a set of working modules that are delivered in increments.
• Resources such as modeling designers, high-budget, and automated code-generating tools are available.
• Skilled manpower with strong business knowledge is available.
  
  
  

3. Advantages and Disadvantages of RAD Software Development

Some of the advantages of the RAD model are as follows:

• As the project is delivered in small increments, so the time taken to build the project is reduced.
• The project manager can estimate project costs accurately.
• Reusability of prototypes saves cost in terms of project budget and project time.
• Components ready for the repository are already tested and need not be tested again.
• Requirements are gathered dynamically and a suitable prototype is developed. Any additional requirement is addressed in the next version of the prototype.
• There is strong participation by the customer who gives feedback continuously.
  
  

The disadvantages of RAD are as follows:

• Higher dependency on technical skills to identify business requirements.
• Not suitable for projects with low cost, as the generation of automated code is high.
• Highly skilled manpower is required for such projects.
• Rapid development sometimes compromises quality parameters such as standardization, reliability, and consistency leading to issues later on.
• Promotes component-based development which can be scaled as per the business needs.
  
  
  
  

Component-Based Development

Component-based development is a variation on general application development, in which:

• The application is built from discrete executable components, which are developed and deployed relatively independently of one another, potentially by different teams.
  
  
• The application may be upgraded in smaller increments by upgrading only some of the components that comprise the application.
  
  
• Components may be shared between applications. creating opportunities for reuse, but also creating inter-project dependencies.
  
  

One of the various ways of approaching software development is trying to model the real world as closely as possible. The object-oriented paradigm that is used to model real-world situations as a series of objects emphasizes the creation of classes that encapsulate both data and the algorithms that are used to manipulate the data.

Object technologies provide the technical framework for a component-based process model for software engineering. If properly designed and implemented, object-oriented classes are reusable across different applications and computer-based system architectures. The component assembly model incorporates many of the characteristics of the spiral model. It is evolutionary, demanding an interactive approach to the creation of software. However, the component assembly model comprises applications from prepackaged software components, sometimes called 'classes'.

The engineering activity begins with the identification of candidate classes. The data that are to be manipulated by the application and the algorithms that will be applied to accomplish the manipulation are examined to identify the required components. Corresponding data and algorithms are packaged into a class.

Once candidate classes are identified, the class library is searched to determine if these classes already exist. If they do, they are extracted from the library and reused. If a candidate class does not reside in the library, it is engineered using object-oriented methods. The first iteration of the application to be built is then composed, using classes extracted from the library and any new classes built to meet the unique needs of the application. Process flow then returns to the spiral, and will ultimately re-enter the component assembly iteration during subsequent passes through the engineering activity.

The component assembly model leads to software reuse and reusability provides the software engineers with several measurable benefits.

Based on reusability studies, reports indicate that component assembly leads to a 70% reduction in development cycle time, an 84% reduction in project cost, and a productivity increase of 26.2, compared to an industry norm of 16.9. Although these results are a function of the robustness of the component library, there is little question that the component assembly model provides significant advantages for software engineers.

Architectures that are commonly used in BD are as follows:

• ActiveX
• Common Object Request Broker Architecture (CORBA)
• Remote Method Invocation (RMI)
• Simple Object Access Protocol (SOAP)
  
  
  

1. Advantages of Component-based Development

General advantages:-

• Flexible: A runtime component can work independently and is less dependent on the software environment.
• Reusable: A developed component can be reused across programming languages and operating systems.
• Easy to maintain: Components are easier to test and maintain as their functionality is implemented only once.
• Cost and time-efficient: Lower development cost and less time to develop.
  
  
  

Improving business processes:-

It is easier to reconfigure component-based software to match changes in the business process. The changes can be implemented in the following ways:

• Simplification: Involves removing unnecessary and redundant steps, and reducing variety in processes. This can be reflected in the software by replacing components and improving the application step-by-step.
• Integration: Requires combining unconnected processes into a larger coordinated process. This can be done by including additional components in the software and linking them to the existing components.
• Transformation: The entire business process is overhauled in this case. Components are disassembled and put together in a different way to transform the way a business process is carried out.
  
  
  

Improving software:-

• Greater functionality can be delivered faster by using already existing components.
• Replacing individual components can be replaced easily making maintenance easier.
• A single graphical user interface can be used for standard components.
• Performance can be increased on a component-to-component basis, by optimizing the performance within each component. This can improve the overall efficiency. As components can be made to suit any platform, their usability is very high.
• If an application can be broken down into components such that each component can completely implement the requirement for which it is designated, then the overall software's reliability is considered to be excellent.
• Components are portable and can be quickly adjusted to work on different platforms without affecting other components.
  
  
  
  

2. Disadvantages of Component-based Development

• Building an environment that fits the components is challenging.
• There are not sufficient standards governing middleware in which components work.
• Comparison between the available standards is not possible, as only CORBA is language-independent.
• It may not always be possible to find the best-fit components for the requirements specification.