The process of software development requires the use of several key tools. Source code must be written, compiled, and more often than not debugged when something goes wrong.
Most software developers have a favorite editor that they prefer to use for writing and updating source code. For an editor to be useful for code development syntax highlighting and search capabilities are a must. Other useful features include;
- Text hover
- Command completion
- Automatic formatting
- Refactoring tools
One of the most controversial features of source code editors is the method by which tabs are inserted into the code. Some by default insert spaces instead of the actual TAB character. Some editors display the tab character as 4 spaces on the screen, other 8 spaces. Some of the better editors detect the method used in the file that is currently open and most editors allow the tab insertion mechanism to be specified by the user.
Before a developed application can be executed on a particular platform, it must be compiled for that platform. This process involves converting the source code into native instructions for the platforms processor. For most desktop applications, the compiler is generating instructions for the same CPU on which the compiler itself is running i.e. the compiler is running on an x86 platform and generating an application to run on an x86 platform. In embedded applications the compiler is more often than not generating instructions for a different CPU type i.e. the compiler is running on an x86 platform and generating an application that runs on the ARM platform. This compiler is called a 'cross' compiler.
Once the application is compiled, it can be executed on the destination platform. When it does not work as expected, the developer must debug the application to determine what has gone wrong. Debugging tools provide a method of probing the internal state of an executing application while it is running. Because it is difficult (although not impossible) for human beings to interpret a processor's native instructions, most debugging tools provide a method of linking the symbols and source code to the instructions in the assembled executable. 'Single-stepping' an application involves stepping one instruction (or source code line) at a time in order to anaylse the operation of the application.
Integrated Development Environment's
Because the act of software development almost always requires editing, compiling and debugging, some software tools link the three together using an Integrated Development Environment (IDE). This IDE hides the interaction between the separate tools from the user and attempts to provide some consistency across the tools (e.g the editors view of the source code is reused during single step debugging).
Common Software Tools
The ARM tool-chains are considered to be the best performing tools when targeting embedded ARM devices. While the RealView IDE has in the past been considered a little clumsy, ARM have recently released Eclipse plug-ins that allow the ARM tool-chain to be used with the popular Eclipse IDE. More information about using the RealView tools with Eclipse can be found here Eclipse RVDS.
Microsoft Visual Studio
Microsoft's IDE for software development is Visual Studio. It provides an editor, compilers and debugger that can be used for software development in many languages for all of the Windows variants (including the embedded platforms like Windows CE). It is considered the best of the IDEs available with the main disadvantage being that it can can only be used to target Win32 platforms (and you have to pay for it). More information about Visual Studio can be found at .
The GNU tool-chain is loosely used to describe the free set of UNIX-like software development tools. The main components of the GNU tool-chain are; GCC the GNU Compiler Collection, binutils the GNU Binary Utilities and glibc the GNU C Library. More information about the GNU toolchain can be found at http://gcc.gnu.org/.
The Cygwin tool-chain provides a POSIX emulation layer on top of Windows. The GNU tool chain has been ported to Cygwin and can be used to compile many UNIX applicaitons without any changes at all. As the aim of the project is for good POSIX compatibility, the performance of applications compiled under Cygwin is somewhat less than applications compiled to run using native Win32 calls. As GCC also uses the emulation layer, the compilation of large projects (e.g. the Linux kernel) can be slow under Cygwin. More information about Cygwin can be found at http://www.cygwin.com/.
Minimalist GNU for Windows is a port of the GNU tool-chain to the Win32 platform. Unlike Cygwin compiled applications, the resulting binary uses native Win32 calls. This means MinGW compiled applications have better performance on Windows. It is however at the expense of compatibility with UNIX when porting applications. The tool-chain also includes public domain versions of the Win32 header files. More information about MinGW can be found at .
Everyone has their own favorite stand alone editor. When a display is not available (i.e. when SSH'd into that development server in Siberia!) small text based editors are invaluable. Even on the desktop, a stand-alone editor is useful when you need more functionality than notepad, but do not want to start up a project orientated IDE. Some examples of commonly used stand-alone editors include;
- vi - http://www.vim.org/
- emacs - http://www.gnu.org/software/emacs/
- gedit - http://www.gnome.org/projects/gedit/
- kate - http://kate-editor.org/
- scite - http://www.scintilla.org/SciTE.html
Eclipse is a cross platform Integrated Development Environment (IDE) written in Java. It is highly configurable through its plug-in API and can be linked to many different compilers. Because it is cross platform it has an identical look and feel on Linux and Windows. More information about Eclipse can be found at http://www.eclipse.org/.
Bluewater Systems Experience
At Bluewater we use a wide range of software tools. Every project is different and it is useful to be able to choose the tool chain that is most suitable for that project. Where possible we try to use cross platform (OS) tools so that we have a consistent development environment with that of our customers. For embedded Linux applications we use the GNU tool-chain running on Linux desktops and Realview when better performance is required. For Windows CE development we use Microsoft's Platform Builder (for kernel development) and Visual Studio (for application development) combination. For Desktop PC applications we often use the QT framework to create cross platform code that generates applications that have the same look and feel on windows as on Linux.