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.
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…