See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/315796289

METHODS AND TOOLS FOR RAPID APPLICATION DEVELOPMENT

Conference Paper · March 2017

CITATIONS READS

4 2,591

2 authors:

Velin Kralev Radoslava Stankova Kraleva

South-West University "Neofit Rilski" South-West University "Neofit Rilski"
49 PUBLICATIONS   188 CITATIONS    65 PUBLICATIONS   209 CITATIONS   

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Software for working with graphs View project

The Relationship Economic Growth and Information Technologies : The Case of Bulgaria View project

All content following this page was uploaded by Radoslava Stankova Kraleva on 06 April 2017.

The user has requested enhancement of the downloaded file.

Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

Ph. D. Kralev V. S., Ph. D. Kraleva R. S.

Bulgaria, Blagoevgrad, South-West University "Neofit Rilski"

METHODS AND TOOLS FOR RAPID APPLICATION

DEVELOPMENT

This paper discusses the concept of rapid application development and some of
its specific features. Also, the main stages based on this concept in the development
of different types of applications are pointed out. These two stages are: application
design – when creating the application outlook; and event-oriented programming –
when the methods that will be executed when a specific event occurs are
implemented. The most commonly used application development environments are
presented and analyzed. The development of an application for calculating the values
of certain trigonometric functions and drawing their graphics are described. The
application is tested and the results of its execution are displayed. The guidelines for
further research are formulated.).
Keywords: application development; integrated development environment;
rapid application development; programming;

1. Introduction
The application development environments, such as Visual Studio, Visual
Basic, RAD Studio and many others, make it possible to create applications in
identical ways [1, 2]. The main differences are in the implementation of the class
libraries that developers use [3], or in the way of compiling these applications to
intermediate (mid) or main code (machine instructions) for the operating system on
which they will be run [4]. The programming languages evolve and their capabilities,
such as commands, reserved words, and class libraries are usually available in all
programming languages of this class [5, 6, 7, 8].
Most integrated development environments (such as Visual Studio and RAD
Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

Studio) offer a choice of programming language, from among several possible ones
[1]. This allows the teams of developers to use the same integrated development
environment but to implement different modules on various programming languages.
2. Stages in the application development
The IDEs provides a common conceptual framework for rapid developing
applications [9]. A visual environment for rapid application development allows a
user quickly create powerful applications for different problems and for different
operating systems [10]. This feature of the IDEs often described with the term cross-
platform application development [3].
The application development in this way include (most often) two main stages:
- Application design – creating a graphical user interface (GUI) of the
application by arranging components and controls [1, 3]. Each window (called a
form) of an application can be regarded as a container for components and controls
(such as buttons, text boxes, combo boxes, list controls, and many other). During this
stage, the developer sets the properties of the visual components, i.e. creates the
application appearance.
- Event-oriented programming – implementation of event handlers or custom
routines (methods and functions). Applications receive events such as messages that
are sent by the operating system. The event handlers and the custom routines
determine the application behavior.
There are many different integrated environments for rapid application
development. Two of them will be presented here:
- Visual Studio is the Microsoft IDE for application development. It provides
the ability to create Windows Forms-based applications, Web services, and Web
sites. Visual Studio provides several software platforms to develop, such as Windows
API (Application Programming Interface), WPF (Windows Presentation
Foundations), Windows Forms, Silverlight and many others. It provides many tools,
such as code editor with code completion, integrated debugger, form designer, web
page designer, class designer, database scheme designer and many others [1]. It
Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

supports different programming languages like C, C++ (Visual C++) VB.NET

(Visual Basic .NET), C# (Visual C#) and F #. Other programming languages such as
Python, Ruby, Oxygen (Object Pascal .NET) can be installed as a language services
too [4].
- RAD Studio is the Embarcadero IDE for application development. It includes
Delphi and C++ Builder. They are integrated environments for rapid application
development of different types of applications, such as console, desktop, mobile, and
web based. Embedded compilers can generate executable code for different operating
systems, such as Windows (x86 and x64), OS X (32-bit only), iOS and Android. The
RAD Studio integrated development environment includes a great set of tools, such
as: code editor with code completion and error detection in real time, form designer
to design GUI using visual components libraries VCL and FMX, integrated debugger
for all target platforms, source control and many others. It provides many class
libraries and component packages, but also enables new ones (developed by third
parties) to be added as well [3].
3. Creating a sample application
For the aims of this experiment the C++ Builder IDE (part of the RAD Studio
package) will be used. As mentioned above, it provides tools to design, develop, test,
debug, and deploy applications. The main tools and items of the IDE are:
 Form Designer - window on which to design the UI for the application.
 Tool Palette - displaying visual and nonvisual components that can use to
create (design) the user interface of the application.
 Object Inspector - using to set the properties of the objects and examining the
events.
 Structure View - displaying and changing a logical relationships (hierarchies)
of the components.
 Code Editor - writing and editing the program logic (source code of the
application).
 Project Manager - managing the files that make up one project (or more
Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

projects).
This section describes how to use the C++ Builder to create a GUI (Graphical
User Interface) of the application. First, customizing the main form, and adding the
necessary visual components. In Table 1 the components that make up the GUI of the
application are presented.
Table 1 – A list of the components that make up the application GUI
Component Name Class Name Owner Object Name
MainForm TMainForm None
- ImagePlot TImage MainForm
- ImageLeft TImage MainForm
- ImageTop TImage MainForm
- ImageBottom TImage MainForm
- ImageTopCorrner TImage MainForm
- ImageBottomCorrner TImage MainForm
- ColorDialog TColorDialog MainForm
- ImageList TImageList MainForm
- PanelLeft TPanel MainForm
- LabelRange TLabel PanelLeft
- ShapeColor TShape PanelLeft
- BevelRange TBevel PanelLeft
- LabelCommands TLabel PanelLeft
- BevelCommands TBevel PanelLeft
- ShapeSeparator TShape PanelLeft
- EditRangeLeft TEdit PanelLeft
- EditRangeRight TEdit PanelLeft
- ButtonSetColor TButton PanelLeft
- ButtonClearCanvas TButton PanelLeft
- UpDownRangeLeft TUpDown PanelLeft
- UpDownRangeRight TUpDown PanelLeft
- TreeViewFunctionList TTreeView PanelLeft
- MemoFunctionResults TMemo PanelLeft

In this way, the application design stage ends (see Section 2). This application
will calculate and draws graphs of some trigonometric functions. For this purpose it
is necessary to define a few variables and to implement a number of custom routines.
These specific characteristics of the source code are shown in Fig. 1.)
//MainUnit.h
enum TFuncType : unsigned char
Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

{ftSin, ftCos, ftTan, ftCot, ftSec, ftCsc,

ftSinh, ftCosh, ftTanh, ftCoth, ftSech, ftCsch};

class TMainForm : public TForm

{
__published: // IDE-managed Components
TImage *ImagePlot;
TTreeView *TreeViewFunctionList;
...
void __fastcall FormCreate(TObject *Sender);
void __fastcall TreeViewFunctionListDblClick(TObject *Sender);
...
private:// User declarations
int XCenter;
int YCenter;
double ScaleFactor;
double RangeLeft;
double RangeRight;
int PointX;
int PointY;
int LastPointX;
int LastPointY;
double XNew;
double YNew;
double __fastcall DegToRad(double X);
void __fastcall DrawFunction(TFuncType Func);
...
public: // User declarations
__fastcall TMainForm(TComponent* Owner);
};
...
//MainUnit.cpp
double __fastcall TMainForm::DegToRad(double X)
{ return ((X * M_PI) / 180); }

void __fastcall TMainForm::DrawFunction(TFuncType Func)

{
XNew = RangeLeft;
do
{
PointX = Round(XCenter+ScaleFactor*XNew);
switch(Func)
{
case ftSin : {YNew = Sin(XNew); break;}
case ftCos : {YNew = Cos(XNew); break;}
case ftTan : {if (Cos(XNew) != 0)
{YNew = (Sin(XNew) / Cos(XNew));} break;}
case ftCot : {if (Sin(XNew) != 0)
{YNew = (Cos(XNew) / Sin(XNew));} break;}
case ftSec : {if (Cos(XNew) != 0)
{YNew = Secant(XNew);} break;}
case ftCsc : {if (Sin(XNew) != 0)
Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

{YNew = Cosecant(XNew);} break;}

case ftSinh : {YNew = Sinh(XNew); break;}
case ftCosh : {YNew = Cosh(XNew); break;}
case ftTanh : {YNew = Tanh(XNew); break;}
case ftCoth : {if ((Tanh(XNew) != 0))
{YNew = (1/Tanh(XNew));} break;}
case ftSech : {if ((1/Cosh(XNew) != 0))
{YNew = (1/Cosh(XNew));} break;}
case ftCsch : {if (Sinh(XNew) != 0)
{if((1/Sinh(XNew) != 0))
{YNew = (1/Sinh(XNew));} break;}}
}
PointY = Round(YCenter-ScaleFactor*YNew);
ImagePlot->Canvas->MoveTo(LastPointX, LastPointY);
ImagePlot->Canvas->LineTo(PointX, PointY);
LastPointX = PointX; LastPointY = PointY;
XNew = (XNew + (1 / ScaleFactor));
} while (XNew < RangeRight);
}
Fig. 1 – Statements from the MainUnit.h and MainUnit.cpp files

After starting the application the main form OnCreate event occurs. At this
time the values of the global variables can be initialized. They will be used later in
the calculations. When the user chooses a trigonometric function (by double click on
the left mouse button on an item from the TreeViewFunctionList control) will be
called the method of drawing the graph of this function.
An example of the work session with the application is shown at Fig .2.
Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

Fig. 2 – The "Trigonometric Functions" application at runtime

To change the range of a trigonometric function is necessary in the
EditRangeLeft and EditRangeRight controls the corresponding values to be entered.
Then the left and right border of the range will be set up. These values in the
variables RangeLeft and RangeRigth are stored. To set the color of the function graph
(before its drawing) it is necessary to press the button [Color] and then to choose a
particular color. This sets the color of the ImagePlot->Canvas->Pen property. The
drawing canvas by pressing the button [Clear] can be cleared. The calculated values
of the function in the MemoFunctionResults control are displayed.
4. Conclusion
In this paper the concept of rapid application development and some of its
specific features were discussed. Also, the main stages based on this concept in the
development of different types of applications were pointed out. These two stages are
application design and event-oriented programming. The most commonly used
application development environments were presented and analysed. The
 Proceedings of the III International Scientific and Practical Conference "Methodology of Modern Research"
(March 29, 2017, Dubai, UAE), № 4(20), Vol.1, April 2017, pp. 21-24, ISSN 2413-1032.

development of an application for calculating the values of certain trigonometric

functions and drawing their graphics was described. The application was tested and
the results of its execution were displayed as well. The study may be extended in
conducting additional experiments with more functions.

REFERENCES
[1] Johnson, B. (2015) Professional Visual Studio 2015 1st Edition. Wrox; 1
edition (September 8, 2015). ISBN-13: 978-1-119-06805-1.
[2] Newsome, B. (2015) Beginning Visual Basic 2015 1st Edition. Wrox; 1 edition
(December 2, 2015). ISBN-13: 978-1-119-09211-7.
[3] Kouraklis, J. (2016) MVVM in Delphi: Architecting and Building Model View
ViewModel Applications 1st Edition. Apress; 1st edition (October 27, 2016).
ISBN-13: 978-1-484-22213-3.
[4] Esposito, D., Saltarello, A. (2014) Microsoft .NET - Architecting Applications
for the Enterprise (Developer Reference) 2nd Edition. Microsoft Press; 2
edition (September 18, 2014). ISBN-13: 978-0735685352.
[5] Donovan, A., Kernighan, B. (2015) The Go Programming Language
(Professional Computing Series) 1st Edition. Addison-Wesley Professional; 1
edition (November 5, 2015). ISBN-13: 978-0134190440.
[6] Scott, M. (2015) Programming Language Pragmatics, Fourth Edition 4th
Edition. Morgan Kaufmann; 4 edition (December, 2015). ISBN-13: 978-
0124104099.
[7] Sebesta, R. (2015) Concepts of Programming Languages (11th Edition) 11th
Edition. Pearson; 11 edition (February 16, 2015). ISBN-13: 978-0133943023.
[8] Kraleva, R., Kralev, V., Kostadinova, D. (2016) Investigating some
programming languages for children to 8 years. Proceedings of the II -nd
International Scientific and Practical Conference "New Opportunities in the
World Science (August 30 – 31, 2016, Abu-Dhabi, UAE)". № 9(13), Vol.5,
September 2016, pp. 4-6, ISSN 2413-1032.
[9] McConnell, S. (1996) Rapid Development: Taming Wild Software Schedules
1st Edition. Microsoft Press; 1 edition (July 12, 1996). ISBN-13: 978-
1556159008.
[10] Murch, R. (2012) Rapid Application Development Lifecycle- RAD - The
Complete Guide Kindle Edition. Amazon Digital Services LLC (July 19,
2012).

View publication stats