Lesson 1

Introduction to Rapid Application Development using

Visual Basic
RAD (Rapid Application Development) refers to a development life cycle designed to
give much faster development and higher-quality results than those achieved with the
traditional life cycle. In general, RAD systems provide a number of tools to help build
graphical user interfaces that would normally take a large development effort. Two of
the most popular RAD systems for Windows are Visual Basic and Delphi.

Historically, RAD systems have tended to emphasize reducing development time,

sometimes at the expense of generating efficient executable code. Nowadays, though,
many RAD systems produce extremely fast code. Conversely, many traditional
programming environments now come with number of visual tools to aid
development. Therefore, the line between RAD systems and other development
environments has become blurred.

Problems addressed by RAD

With conventional methods, there is a long delay before the customer gets to
see any results.
With conventional methods, development can take so long that the customers
business has fundamentally changed by the time the system is ready for use.
With conventional methods, there is nothing until 100% of the process is
finished, then 100% of the software is delivered.

Why use RAD

1. Bad reasons for using RAD

o To prevent cost overruns (RAD needs a team already disciplined in

cost management)
o To prevent runaway schedules (RAD needs a team already disciplined
in time management)

2. Good reasons for using RAD

o To converge early toward a design acceptable to the customer

and feasible for the developers
o To limit a project's exposure to the forces of change
o To save development time, possibly at the expense of economy or
product quality

CSC 204 2.0 Rapid Application Development Page 1 of 5

Characteristics of RAD

RAD uses hybrid teams

Teams should consist of about 6 people, including both developers and full-
time users of the system plus anyone else who has a stake in the requirements.
Developers chosen for RAD teams should be multi-talented "renaissance"
people who are analysts, designers and programmers all rolled into one.

RAD uses specialized tools that support...

"visual" development
Creation of fake prototypes (pure simulations)
Creation of working prototypes
Multiple languages
Team scheduling
Teamwork and collaboration
Use of reusable components
Use of standard APIs
Version control
(because lots of versions will be generated)

RAD uses iterative, evolutionary prototyping

I. JAD (Joint Application Development) meeting High-level end-users and
designers meet in a brainstorming session to generate a rough list of initial
requirements.
Developers talk and listen
Customers talk and listen
II. Iterate until done
Developers build / evolve prototype based on current requirements.
Designers review the prototype.
Customers try out the prototype, evolve their requirements.
FOCUS GROUP meeting Customers and developers meet to review
product together, refine requirements, and generate change requests.
Developers listen.
Customers talk.
Requirements and change requests are "timeboxed".
Changes that cannot be accommodated within existing timeboxes are
eliminated.
If necessary to stay "in the box," secondary requirements are dropped.

Important RAD constraints

"Fitness for a business purpose" must be the criterion for acceptance of

deliverables.
All constituencies that can impact application requirements must have
representation on the development team throughout the process.
Customers, developers and management must accept informal deliverables.
Development teams must be empowered to make some decisions traditionally
left to management.
End-to-end timescale must be 6 months or less.

CSC 204 2.0 Rapid Application Development Page 2 of 5

 Iteration must be used in such a way that the development process converges
toward an acceptable business solution.
Prototyping must incorporate evolving requirements quickly, in real time, and
gain consensus early.
There must be a "buy before build" bias.

When RAD works and when it doesn't

RAD tends to work when

1. The application will be run standalone.
2. Major use can be made of preexisting class libraries (APIs).
3. Performance is not critical.
4. Product distribution will be narrow (in-house or vertical market).
5. Project scope (macro-schedule) is constrained.
6. Reliability is not critical.
7. System can be split into several independent modules.
8. The product is aimed at a highly specialized IS (information systems) market.

RAD tends to fail when...

1. Application must interoperate with existing programs.
2. Few plug-in components are available.
3. Optimal performance is required.
4. Product development can't take advantage of high-end IS tools (e.g., 4GLs).
5. Product distribution will be wide (horizontal or mass market).
6. RAD methods are used to build operating systems (reliability target too high
for RAD), computer games (performance target too high for RAD).
7. Technical risks are high due to use of "bleeding" edge technology.
8. The product is mission- or life-critical.
9. The system cannot be modularized (defeats parallelism).

Evaluation of RAD

Advantages of RAD
Buying may save money compared to building
Deliverables sometimes easier to port (because they make greater use of high-
level abstractions, scripts, intermediate code)
Development conducted at a higher level of abstraction (because RAD tools
operate at that level)
Early visibility (because of prototyping)
Greater flexibility (because developers can redesign almost at will)
Greatly reduced manual coding (because of wizards, code generators, code
reuse)
Increased user involvement (because they are represented on the team at all
times)
Possibly fewer defects (because CASE tools may generate much of the code)
Possibly reduced cost (because time is money, also because of reuse)

CSC 204 2.0 Rapid Application Development Page 3 of 5

 Shorter development cycles (because development tilts toward schedule and
away from economy and quality)
Standardized look and feel (because APIs and other reusable components give
a consistent appearance)

Disadvantages
Buying may not save money compared to building
Cost of integrated toolset and hardware to run it
Harder to gauge progress (because there are no classic milestones)
Less efficient(because code isn't hand crafted)
Loss of scientific precision(because no formal methods are used)
May accidentally empower a return to the uncontrolled practices of the early
days of software development
More defects (because of the "code-like-hell" syndrome)
Prototype may not scale up, a B-I-G problem
Reduced features (because of timeboxing, software reuse)
Reliance on third-party components may ...
Requirements may not converge (because the interests of customers and
developers may diverge from one iteration to the next)
Standardized look and feel (undistinguished, lackluster appearance)
Successful efforts difficult to repeat (no two projects evolve the same way)
Unwanted features (through reuse of existing components)

Visual Basic
Visual Basic (VB) is an event driven programming language and associated
development environment from Microsoft. VB has been replaced by Visual Basic
.NET. The older version of VB1 was derived heavily from BASIC and enables rapid
application development (RAD) of graphical user interface (GUI) applications, access
to databases using DAO, RDO, or ADO, and creation of ActiveX controls and
objects.
A programmer can put together an application using the components provided with
Visual Basic itself. Programs written in Visual Basic can also use the Windows API,
but doing so requires external function declarations.

Language features

Visual Basic was designed to be easy to learn and use.

The language not only allows programmers to easily create simple GUI
applications, but also has the flexibility to develop fairly complex applications as
well.
Programming in VB is a combination of visually arranging components or
controls on a form, specifying attributes and actions of those components, and
writing additional lines of code for more functionality. Since default attributes and
actions are defined for the components, a simple program can be created without
the programmer having to write many lines of code.

CSC 204 2.0 Rapid Application Development Page 4 of 5

 Performance problems were experienced by earlier versions, but with faster
computers and native code compilation this has become less of an issue.
Although programs can be compiled into native code executables from version 5
onwards, they still require the presence of runtime libraries of approximately 2
MB in size. This runtime is included by default in Windows 2000 and later, but
for earlier versions of Windows it must be distributed together with the
executable.
Forms are created using drag and drop techniques. A tool is used to place controls
(e.g., text boxes, buttons, etc.) on the form (window). Controls have attributes and
event handlers associated with them. Default values are provided when the control
is created, but may be changed by the programmer. Many attribute values can be
modified during run time based on user actions or changes in the environment,
providing a dynamic application. For example, code can be inserted into the form
resize event handler to reposition a control so that it remains centered on the form,
expands to fill up the form, etc. By inserting code into the event handler for a
keypress in a text box, the program can automatically translate the case of the text
being entered, or even prevent certain characters from being inserted.
Visual Basic can create executables(EXE), ActiveX controls, DLL files, but is
primarily used to develop Windows applications and to interface web database
systems.
Dialog boxes with less functionality (e.g., no maximize/minimize control) can be
used to provide pop-up capabilities.
Controls provide the basic functionality of the application, while programmers can
insert additional logic within the appropriate event handlers. For example, a drop-
down combination box will automatically display its list and allow the user to
select any element.
An event handler is called when an item is selected, which can then execute
additional code created by the programmer to perform some action based on
which element was selected, such as populating a related list.
Unlike many other programming languages, Visual Basic is generally not case
sensitive, although it will transform keywords into a standard case configuration
and force the case of variable names to conform to the case of the entry within the
symbol table entry. String comparisons are case sensitive by default, but can be
made case insensitive if so desired.

CSC 204 2.0 Rapid Application Development Page 5 of 5