CHAPTER 1

INTRODUCTION
1.1 OVERVIEW
An integrated development environment (IDE) is a software application that provides comprehensive
facilities to computer programmers for software development. An IDE normally consists of a source code
editor, build automation tools and a debugger. Most modern IDEs have intelligent code completion.
An integrated development environment (IDE) is a programming environment that has been packaged as
an application program, typically consisting of a code editor, a compiler, a debugger, and a graphical user
interface (GUI) builder. The IDE may be a standalone application or may be included as part of one or
more existing and compatible applications. The BASIC programming language, for example, can be used
within Microsoft Office applications, which makes it possible to write a WordBasic program within the
Microsoft Word application. IDEs provide a user-friendly framework for many modern programming
languages, such as Visual Basic, Java, and PowerBuilder.
Some IDEs contain a compiler, interpreter, or both, such as NetBeans and Eclipse; others do not, such as
SharpDevelop and Lazarus. The boundary between an integrated development environment and other
parts of the broader software development environment is not well-defined. Sometimes a version control
system, or various tools to simplify the construction of a Graphical User Interface (GUI) are integrated.
Many modern IDEs also have a class browser, an object browser, and a class hierarchy diagram, for use
in object-oriented software development.
The purpose of an IDE is to accelerate the development of an accurate, fast, robust, and maintainable
application.
To be sure, there has been a substantial effort to develop IDEs for NLP in recent years. Even going back
to the 1980s, Carnegie Group's LanguageCraft was a notable early attempt to commercialize an IDE. But
knowledge of NLP then was not what it is today and hardware was not as fast and capable, so
LanguageCraft and some other early efforts did not succeed commercially. Several IDEs under
development today are found in the universities and research organizations.
VisualText is by far the most ambitious and groundbreaking commercial IDE developed to date. The
reason we have not seen more effort in this area is that the shallow methods alluded to earlier have been
the "hot topic" of the 1990s. Why build and use an IDE when you can automate the processing of text?
As we have seen, the shallow methods are very useful, but are insufficient for engineering a complete and
accurate NLP system for a task of substantial complexity.
For most complex tasks, a combination of strategies is required. The ideal IDE will integrate shallow
methods with methods based on tokens, patterns, grammars, keywords, logic, and finite state automata.
It will integrate knowledge bases, expert systems, experts, planners, and other artificial intelligence
systems with the overall framework.
Integrated development environments are designed to maximize programmer productivity by providing
tight-knit components with similar user interfaces. IDEs present a single program in which all
1

development is done. This program typically provides many features for authoring, modifying, compiling,
deploying and debugging software. This contrasts with software development using unrelated tools, such
as vi, GCC or make.
One aim of the IDE is to reduce the configuration necessary to piece together multiple development
utilities, instead providing the same set of capabilities as a cohesive unit. Reducing that setup time can
increase developer productivity, in cases where learning to use the IDE is faster than manually integrating
all of the individual tools. Tighter integration of all development tasks has the potential to improve overall
productivity beyond just helping with setup tasks. For example, code can be continuously parsed while it
is being edited, providing instant feedback when syntax errors are introduced. That can speed learning a
new programming language and its associated libraries.
Some IDEs are dedicated to a specific programming language, allowing a feature set that most closely
matches the programming paradigms of the language. However, there are many multiple-language IDEs,
such as Eclipse, ActiveState Komodo, IntelliJ IDEA, MyEclipse, Oracle JDeveloper, NetBeans, Codenvy
and Microsoft Visual Studio. Xcode, Xojo and Delphi are dedicated to a closed language or set of
programming languages.
While most modern IDEs are graphical, text-based IDEs such as Turbo Pascal were in popular use before
the widespread availability of windowing systems like Microsoft Windows and the X Window System
(X11). They commonly use function keys or hotkeys to execute frequently used commands or macros.

CHAPTER 2
2

LITERATURE REVIEW
2.1 HISTORICAL BACKGROUND
IDEs initially became possible when developing via a console or terminal. Early systems could not
support one, since programs were prepared using flowcharts, entering programs with punched cards (or
paper tape, etc.) before submitting them to a compiler. Dartmouth BASIC was the first language to be
created with an IDE (and was also the first to be designed for use while sitting in front of a console or
terminal). Its IDE (part of the Dartmouth Time Sharing System) was command-based, and therefore did
not look much like the menu-driven, graphical IDEs popular as of 2015. However it integrated editing,
file management, compilation, debugging and execution in a manner consistent with a modern IDE.
(Flycheck, 2009)
Maestro I is a product from Softlab Munich and was the world's first integrated development
environment for software. Maestro I was installed for 22,000 programmers worldwide. Until 1989, 6,000
installations existed in the Federal Republic of Germany. Maestro was arguably the world leader in this
field during the 1970s and 1980s. Today one of the last Maestro I can be found in the Museum of
Information Technology at Arlington.
One of the first IDEs with a plug-in concept was Softbench. In 1995 Computerwoche commented that the
use of an IDE was not well received by developers since it would fence in their creativity. ( Textanalysis,

2004)
According to Wikipedia (as at 06-04-2016), From February 22, 2005 to June 2011 the project for DevC++ was not noticeably active, with no news posted nor any updated versions released. In a 2006 forum
post, lead developer Colin Laplace stated that he was busy with real-life issues and did not have time to
continue development of Dev-C++.
There are two forks of Dev-C++ since then: wxDev-C++ and the Orwell version.
wxDev-C++ is a development team that has taken Dev-C++ and added new features such as support for
multiple compilers and a RAD designer for wxWidgets applications.
On June 30, 2011 an unofficial version 4.9.9.3 of Dev-C++ was released by Orwell (Johan Mes), an
independent programmer, featuring the more recent GCC 4.5.2 compiler, Windows' SDK resources
(Win32 and D3D), numerous bug fixes, and improved stability. On August 27, after five years of
officially being in a beta stage, version 5.0 was released. This version also has its own separate
SourceForge page since version 5.0.0.5, because the old developer isn't responding to combining requests.
On July 2014, Orwell Dev-C++ 5.7.1 was released featuring the more recent GCC 4.8.1 which supports
C++11.
As of March 2015, the most popular IDEs are Eclipse and Visual Studio.

CHAPTER 3
3

DISCUSSION
3.1 REQUIREMENTS FOR AN IDE
In every well-established area of computer software, tools have sprung up to organize, accelerate, and
standardize the development of applications. Prime examples are computer programming applications,
which are now universally developed via integrated development environments (IDEs) such as Microsoft
Visual C++ (c). IDEs offer universally recognized features such as:
A graphical user interface (GUI) that enables users to conveniently manage the task at hand
A complete environment for building an application
Helpful views of the application and components under construction
Cross-references to provide instant feedback about changes to the application
Prebuilt framework, components, and tools that work together seamlessly
Open architecture for integrating multiple methods and external components
Debugging facilities to step through the running of the application and identify errors
Integrated documentation to help the developer answer technical questions quickly
The IDE used in building an application doubles as a platform for maintaining and enhancing the
application. The modular structure of an application built with an IDE enables developers other than the
creators of the application to understand, maintain, and enhance it. In addition, non-expert users of the
application should be able to maintain and enhance it, to a reasonable extent, using the IDE. The benefits
of IDEs include
Accelerated development of applications
Properly engineered, modular, and organized applications
Applications with reusable components
Highly extensible and maintainable applications
Bottom line: reduced resources needed to build and maintain applications

Figure 1: Diagram of a simple IDE

Figure 2: Diagram for a Sophisticated IDE

3.2 VISUAL PROGRAMMING

Visual programming is a usage scenario in which an IDE is generally required. Visual IDEs allow users to
create new applications by moving programming, building blocks, or code nodes to create flowcharts or
structure diagrams that are then compiled or interpreted. These flowcharts often are based on the Unified
Modeling Language.
This interface has been popularized with the Lego Mindstorms system, and is being actively pursued by a
number of companies wishing to capitalize on the power of custom browsers like those found
at Mozilla. KTechlab supports flow code and is a popular open source IDE and Simulator for developing
software for microcontrollers. Visual programming is also responsible for the power of distributed
programming (cf. LabVIEW and EICASLAB software). An early visual programming system, Max, was
modelled after analog synthesizer design and has been used to develop real-time music performance
software since the 1980s. Another early example was Prograph, a dataflow-based system originally
developed for the Macintosh. The graphical programming environment "Grape" is used to program qfix
robot kits.
This approach is also used in specialist software such as Openlab, where the end users want the flexibility
of a full programming language, without the traditional learning curve associated with one.
3.3 LANGUAGE SUPPORT
Some IDEs support multiple languages, such as GNU Emacs based on C and Emacs Lisp, and IntelliJ
IDEA, Eclipse, MyEclipse or NetBeans, all based on Java, or MonoDevelop, based on C#.
Support for alternative languages is often provided by plugins, allowing them to be installed on the same
IDE at the same time. For example, Flycheck is a modern on-the-fly syntax checking extension for GNU
Emacs 24 with support for 39 languages. Eclipse, and Netbeans have plugins for C/C++, Ada, GNAT (for
example AdaGIDE), Perl, Python, Ruby, and PHP, which are selected between automatically based on
file extension, environment or project settings.
3.4 ATTITUDES ACROSS DIFFERENT COMPUTING PLATFORMS
Unix programmers can combine command-line POSIX tools into a complete development environment,
capable of developing large programs such as the Linux kernel and its environment. The free
software GNU tools (GNU Compiler Collection (GCC), GNU Debugger (gdb), and GNU make) are
available on many platforms, including Windows. Developers who favor command-line oriented tools can
use editors with support for many of the standard Unix and GNU build tools, building an IDE with
programs like Emacs or Vim. Data Display Debugger is intended to be an advanced graphical front-end
for many text-based debugger standard tools. Some programmers prefer managing make files and their
derivatives to the similar code building tools included in a full IDE. For example, most contributors to the
PostgreSQL database use make and gdb directly to develop new features. Even when building
6

PostgreSQL for Microsoft Windows using Visual C++, Perl scripts are used as a replacement
for make rather than relying on any IDE features. Some Linux IDEs such as Geany attempt to provide a
graphical front end to traditional build operations.
On the various Microsoft Windows platforms, command-line tools for development are seldom used.
Accordingly, there are many commercial and non-commercial products. However, each has a different
design commonly creating incompatibilities. Most major compiler vendors for Windows still provide free
copies of their command-line tools, including Microsoft (Visual C++, Platform SDK, .NET
Framework SDK, nmake utility), Embarcadero Technologies (bcc32 compiler, make utility).
IDEs have always been popular on the Apple Macintosh's Mac OS, dating back to Macintosh
Programmer's Workshop, Turbo Pascal, THINK Pascal and THINK C environments of the mid-1980s.
Currently Mac OS X programmers can choose between native IDEs like Xcode and open-source tools
such as Eclipse and Netbeans, ActiveState Komodo is a proprietary multilanguage IDE supported on the
Mac OS.
With the advent of cloud computing, some IDEs are available online and run within web browsers.

3.5 SOFTWARE DEVELOPMENT STEPS

In any environment, to develop executable software source file(s) should be created, compile the source
files to produce machine code (object files), and link the object files with each other and any libraries or
other resources required to produce an executable file.
Source files contain the code statements to do the tasks your program is being created for. They contain
program statements specific to the language you are using. If programming in c, the source files contain c
code statements; java source files contain java statements. Usually source files names have extensions
indicating the code they contain. A c source file may be named "myfile.c". Compilers translate the
source files to appropriate machine level code for the target environment. Linkers take all the object files
required for a program and link them together, assigning memory and registers to variables, setting up
data. They also link in library files to support operating system tasks and any other files the program
needs. Linkers output executable files.
3.6 LIFE WITHOUT IDES
When not using an IDE, developers use an editor, compiler, and linker installed on their development
machine to create code files, compile, and link them.

Using the editor to create a source file, the code blocks, comments, and program statements are entered
and the file saved. There are no "corrective actions," taken as the editor does not know this is supposed to
be a "source file" as opposed to notes for class! If working in a position-dependent language like Python,
the developer would have to be very careful about indenting. The file has to be saved with the correct file
extension and in a directory where the compiler can find it.
Each source file has to be compiled separately; if the program has a few source files, they all have to be
named separately in the compiler. When invoking the compiler, it has to be directed to look in the correct
directory for the source files and where the output files should be stored. If there is an error in the source
file, the compiler will output messages and fail to complete. For any errors, the developer goes back and
edits the source file, working from line numbers and compiler messages to fix the problems... and these
steps continue until all the source files compile without errors.
When linking, each object file is specified as being part of the build. Again, the locations for the object
files and executable are given. There may be errors at this point because it isnt until the entire program is
linked that some errors can be detected. Assuming the linker finds all the variables and functions, it
produces a file that can be run.
If the program is run and it works, all's well! If it seems to do nothing.... that means it's debugging time!
Since there is no insight to what the program is doing, the developer may go back and put in some brute
force methods, like print statements to print messages out at certain points in the program or blink some
LEDs at strategic places, which means back to the editor, and the cycle continues.

3.7 USING IDES (Taking Dev-C++ as a Case Study)

Bringing up an IDE presents a workspace:

Figure 3: A Sample IDE at work

Note: This is the Dev-C++ 5.11 IDE. It was downloaded and installed to illustrate IDE concepts for this
article.
With an IDE, a Project provides a workspace where all the files for a program can be collected.

Figure 4: Using the file menu

Select the language and the type of program to create. This IDE supports c and c++ and various
application types

Figure 5: Creating a New Project

If set for a Windows Application in C, it brings up a template:

Figure 6: Template Windows Program

A console C program brings up a different template:

10

Figure 7: Template Console Program

Depending on the IDE, it may set up code blocks automatically, indent as required, track variable names
in colors, show comments. Compile? Just click the compile selection on the dropdown menu (or press
F9).

Figure 8: To compile a C code

Compiler results will show in one of the windows and in the log. Compiler options and directories are set
up using the Options menus.

11

Figure 9: IDE Options

Figure 10: IDE Environment Options

As source files are created, they are added to the project. The Rebuild selection rebuilds all the files, first
checking for the latest versions, then compiles and links to produce an executable result.
Errors on the compile or link? The offending code will be shown in the code window. The statement
containing the error or the lines around it is known, since the compiler, linker, and editor are seamlessly
connected. You can run the executable from the IDE by selecting Run:
12

Figure 11: A Sample Running Program

The results show in a separate window.
Problems when running your new program? Usually IDEs provide an option to create a debug version.

Figure 12: Debugging Facility in an IDE

With a debug version, the IDE controls the execution of the program, allowing insight to data variables
and memory locations. Some IDEs show both the high level source statements as well as the machine
code. The debugger may include options to "watch" local variables and track the contents of memory
locations, offer line by line execution, provide the ability to set break points to run to a certain point in the
program, and the ability to step into or over function calls.
13

Some IDEs include emulators, allowing debugging in the IDE environment without having to export the
code to the target device
Table 1: Below are lists of IDEs
Integrated Development Environment
C and C++

Anjuta, C++Builder, Code::Blocks, CodeLite, CodeWarrior, Dev-C++, Eclipse, GNAT

Programming Studio, IBM VisualAge, KDevelop, Kuzya, MonoDevelop, NetBeans,
Pelles C, QDevelop, Qt Creator, Sun Studio, Ultimate++, Visual Studio (Express),
wxDev-C++, Xcode

Java

Current

Android Studio, BlueJ, Codenvy, Eclipse, Greenfoot, IntelliJ IDEA,

JBuilder, JCreator, JDeveloper, jGRASP, KDevelop, MyEclipse,
NetBeans, IBM Rational Application Developer for WebSphere

Discontinued

Metrowerks CodeWarrior Pro for Java, Kalimantan, Sun Java Studio

Creator (superseded by NetBeans), Visual Age (superseded by Eclipse)
Visual Caf (aka Espresso, superseded by JBuilder), Visual J++ Xelfi
(became NetBeans)

.NET

MonoDevelop, SharpDevelop, Visual Studio (Express), PascalABC.NET

Flash

Adobe Flash Builder, FlashDevelop, Powerflasher FDT

PHP

Aptana, NetBeans, PHPStorm

Python

IntelliJ IDEA, PyCharm, PyDev, Wing IDE

CHAPTER 4
CONCLUSION
4.1 RECOMMENDATION
14

It will be best to try out a few of the free (and free trial) IDEs before making a choice as to which IDE to
use. Choosing an IDE depends on whether or not the IDE meets ones requirement.
There are a lot of IDEs out there to choose and the price can vary from no cost to pricing options
dependent on the environment and number of users. When producing commercial code it is important to
check for the license type for the IDE.
Some other things to check are; if it provides support for the development platform to be used, if it
provides support for the target programming language and if the supports the target environment.
It is also important to check for its capabilities by asking the following questions: What is included?
Does it have watch points for debugging? Can it single-step through code? Do you need to see the lowlevel language used or is source code debugging good enough?
Another important factor is its pricing and licensing. So the following questions are highly important:
Are you looking for a supported environment and willing to pay for it? Does your company need several
licenses? Are there royalties required? Are there fees per use?
4.2 CONCLUSION
Developers are passionate and opinionated about their IDEs because each individual has researched,
chosen, used and come to appreciate a specific IDE (or set of IDEs) for personal as well as practical
reasons.
Just as the IDE in these examples brought up template code blocks for certain applications, there are IDEs
that support specific microcontrollers. These specialized IDEs automatically set up some code for the
microcontroller.
An IDE makes software development and debugging easier by providing a single development workspace
containing all the tools needed for development; it tracks files automatically and saves time. Choosing
one suited for a particular programming need makes developing and debugging software much easier.

REFERENCES

1. Rehman, Christopher Paul, Christopher R. Paul. "The Linux Development Platform: Configuring,
Using and Maintaining a Complete Programming Environment". 2002. ISBN 0-13-009115-4

15

2. Flycheck, F. (2009). Maze Found | Read the Docs. Retrieved 10/04/2016, from
http://flycheck.readthedocs.org/en/latest/manual/introduction.html
3. Wikipedia, W. (2015). Integrated Development Environment. Retrieved 10 April, 2016,
from https://en.wikipedia.org/wiki/Integrated_development_environment
4. Textanalysis, T. (2004). A concise overview on text analysis. Retrieved 10 April, 2016,
from http://www.textanalysis.com/TAI-IDE-WP.pdf
5. All about circuits, A. (2012). What are Integrated Development Environments? Retrieved
10 April, 2016, from http://www.allaboutcircuits.com/technical-articles/what-areintegrated-development-environments/

16