Development tools

If you want to write your own software, you need some development tools
first. As long as your software isn’t intended to run on special
external hardware, you only need a computer as far as the hardware goes.
On the software side, you need some programs for writing your own
software.

In the following paragraphs I will try to give a brief overview of the most commonly used software tools in the area of computer programming:

Back in the 1980s, most computers were sold with a BASIC language interpreter.
This was either build into the operating system ROMs – like in the
Apple II computers or the Acorn BBC model B – or supplied on separate
tapes or disks, like Omicron BASIC for the Atari ST computers. Even IBM
PCs and their clones were shipped with the original Microsoft BASIC.

These BASIC interpreters were – and still are - a good starting point
for programming beginners. Just start up the interpreter program and
enter commands in the (BASIC) language or write some lines of code in
the integrated text editor. Then just start the program without
any further steps. The interpreter allows you to save and load your
program just like you save or load a normal text in a word processor
program.

With an interpreter you can change and test your own program pretty
fast. If an error occurs, the program is usually stopped. You can then
jump to the location in your program where the error occurred.

While the fast development is a real plus for the interpreters, they also have some shortcomings.

Programs within the interpreter are executed line by line. If there are
any errors – even just syntactical ones – the interpreter only
recognizes them once the relevant line of code is actually interpreted.
The line-by-line translation of your program into executable commands
for the computer also makes the programs relatively slow on execution.

Also, the programs require an interpreter program in order to run. If
you want to let your friends and family use your programs on their own
computers, they have to install the same (or at least a compatible)
interpreter program on their computers.

This is where compiler programs come in useful. They take your
program code and translate it into machine code. The end result is a
stand-alone program which can run on other computers without the need
for an additional installation of an interpreter program.

The machine code is also optimized during the compile process. This
makes the program run considerably faster than when it is interpreted.

As compilers need a finished program code which they can turn into a
machine code program, you need a text editor first. There are
specialized editors for different programming languages, but you can
also use a simple standard editor like Notepad, TextEdit or a word
processor. The specialized editors usually offer additional features
line automatic highlighting of specific code words or even syntax checks
for the computer language you are using.

When the compiler turns your code into machine code, it usually also uses an additional program called linker.
The linker combines the code of your own program with code from
standard function libraries for the specific operating system. This
provides a necessary foundation on which your program can run. It also
lets your program communicate with the underlying operating system and
computer hardware. In addition to this, precompiled function libraries
let you reuse already working code more easily.

One downside of using compilers and linkers for development lies in the
more complicated debugging process. If your program is running inside an
interpreter program, it will simply be stopped when it runs into an
error. Usually the interpreter will show the line of code in your
program where the error occurred. This makes it easy to fix the error.

If your program has been compiled and linked and runs independently, any
error will only create a system error message or simply stop your
program without any message. Apart from the message you might get from
the error, you will not see directly where and why the error occurred.
As the syntactical errors and most data type errors are already shown
and corrected during the compilation of your program, the error that
stopped it will most likely be some kind of logical or value-based
error.

If you already have a good idea as to what caused the error, you might
use some additional output in your program which allows you to track the
execution of its code lines and the changes in its internal status. But
if you have no idea where the error might come from, the only tool that
can help you locate it is a debugger program.

Debuggers can usually run alongside your program, often in a way similar
to the way an interpreter would run your program. Usually you can
either follow the execution of your own program in the debugger step by
step (one line of code at a time) or you can set stop marks called
“breakpoints” where the debugger will stop the program execution. You
can then analyse the state of the program at the current breakpoint,
continue the execution up to the next breakpoint or execute the
following lines of code line by line.

Once you have found the hidden errors in your program, you have to call
up the source code in your editor, make corrections and then recompile
and run the program. This takes marginally longer than correcting an
error in an interpreter, but not too much – unless your program is
really long and complicated.

Longer and more complicated programs are usually split up into different
parts. This allows the programmer to focus on a specific task for each
part of the code. It also makes it easier to develop larger programs
within a team of programmers. Also, highly reusable code like specific
function or object libraries can be packed into single,
program-independent library modules.

In order to combine the different elements and code files, the way in
which they have to be compiled and linked is documented in special
project files. These files can be interpreted by special project builder
programs (also known as “make” programs). The project builder will take
care that all the files you specified will be compiled and linked into a
final, single program. So you don’t have to remember all necessary
files all the time.

When you are working on a program together with other programmers, you
have to make sure that code you are working on is not changed by another
developer at the same time. If the operating system allows more than
one user to open the relevant file at the same time, this can create a
problem. This is where code management tools come into play.

Tools like Microsoft Visual Source Save, CVS (concurrent version system)
or RCS (revision control system) handle source code files like a
library handles single books. One single file can only be “checked out”
of the system by one single person at any time. If another programmer
wants to change the same file, he or she gets an error message and can
only read the file without being able to change it. The file can only be
changed after it has been “checked in” again. After this the new
version will be available to the other developers.

These code management tools often also allow you to keep older versions
of the source code. So if some new version does not work as it should,
you can go back to a previous version. You can generate different code
“branches” this way, too.

Modern code management tools like git and subversion use a different, decentralized method for code management. The initial code repository for a programming project can be created locally on a development computer or centrally on a server. After uploading it to a central server, each developer can create a separate copy of the central repository. Changes can be synchronized with the main repository or added as new code branches.

All the mayor tools – text editor, compiler, linker and debugger – are
often integrated into an integrated development environment (IDE).
Usually this environment also contains an online help system for the
language and additional tools like project and code management tools.

While the IDE is usually only a piece of software which is installed
alongside the single programming tools, it allows you to start all the
different tools from within a single program. Usually this is handled in
a specific internal workflow process. If you want to write a program,
you start out by creating a project for the new program. Then you go on
by writing your program with the integrated editor, adding libraries or
other code files from different projects etc. In the end you can test
and debug your program and create a stand-alone compiled program from
it.

Integrated development environments today are mostly bundled with the
rest of the development tools for a specific programming language, e.g.
Microsoft’s Visual BASIC or Visual C++. For the “open-source”
development tools like the GNU compilers and linkers there are IDEs
which can be installed separately, like the “Eclipse” software package.
Setting up a separate IDE like Eclipse requires a good knowledge about
the programming language you want to use and specifically the relevant
development tools. For a programming beginner, using an IDE with
predefined and well integrated development tools is definitely better.
Even most experienced developers usually use this way unless they
require some special additional tools.

Once you have set up your IDE with editor, compiler, linker and
debugger, you are good to go. Just for your information however, let me
get in a few words about some possible additional development tools.

Sometimes you might need to find out where and why your program is
slowed down. This is especially important if your program is aiming at
high performance and fast data processing. If this is the case, you can
use a profiler software. While software profiling is not easy,
the profiler will usually give you a good idea about where your program
uses up the most processor time while running. Then you can analyze the
code in this area and work on optimizing its performance.

If you are working on a network program of some kind, a special network analyzer
software can usually be helpful. There are different tools in this
category, like network package monitors, package filters and a few
others. Some work on a relatively high level, others on a very low
level. Usually such tools are only needed if you are writing very
special network applications. For most applications, using standard
functions for network and internet access will be sufficient.

A lot of applications in the commercial area today are using databases
or database functionality in order to store and manage all the data they
have to process and store. Once the database tables become big and the
database structure reaches a certain level of complexity, database explorer and database analyzer
tools come in handy. These allow you to filter data in the different
tables and analyze it. Sometimes you can even analyze the performance of
specific database search requests. This allows you to optimize the
requests for a maximum speed before you use them in your own database
application.

Final words

This is just a short overview of the different kinds of development
tools which are used in computer programming. It is no complete list as
there are several special tools which only very few people actually
need.

Also, I do not know all the tools myself even with all the long
years of active programming. Once new technology emerges, you often will
not find tools which allow programming for this new technology. In this
case, someone will use the available tools to create a new programming
tool for the new technology. It might even be yourself…