|Software Developer's Guidebook|
Software Development Tools
A software developer has a wide range of tools to assist in creating the software. It is vitally important to know what tools are available and how to use the tools effectively. The following list is not exhaustive but instead lists the most commonly used tools.
The word processor is used to create specifications and documentation. All members of the team must use the same word processor. This allows developers to collaborate on specifications and to make additions and corrections to the document over time. A software development organization should define a set of boiler-plate documents for each type of specification that is normally produced. This allows all documents from the team to be consistent in appearance and also helps insure that all important information is covered in the document. The word processor should not be used for code editing since it is optimized for prose and typically must embed formatting commands into the text.
User Interface Builder
The user interface builder is a tool that allows interactive creation and editing of the user interface. The usefulness of this type of tool generally depends on how many different user interface controls are available. To be truly useful, the developer should be able to add his own controls to the tool. In addition, the user interface builder should be well integrated with the programming language and code editor the developer is using. Some user interface builder tools produce code directly while other produce a resource file that is loaded and parsed by standard libraries. The resource file type is generally more useful since it separates the user interface definition from the actual code. This allows the developer more flexibility in writing the code.
Developers should not depend entirely on the user interface builder tool to produce a good user interface. It is still the responsibility of the developer to understand basic user interface concepts and techniques and tomodify the tools' defaults to achieve the best interface.
The code editor is used to write program code. The code editor should produce plain text, without embedded formatting, in the standard text file format for the target system. The code editor should also have powerful search and replace features that allows using regular expressions as the search string.
Ideally, all members of the development team should use the same code editor. However, because developers use the code editor more than any other tool, it may be desirable to allow some flexibility in each developer's choice of editor. Developers will develop a high degree of proficiency with their favorite code editor and will be much more productive if allowed to use an editor they are familiar with. However, the editor must not perform automatic reformatting of the text. For example, some editors use tab characters for indentation, some use spaces, while others use a combination of tabs and spaces. This can create problems when text is moved from one editor to another. Usually, setting the editor's options can control this type of formatting. If the organization has defined a coding standard that includes standard formatting rules, then each developer need only to set his editor so that it produces compliant code.
A code generator produces code using a template and set of options. In some cases, the code generatoruses the user interface definition as a basis for code generation. These types of tools can be extremely useful and can often dramatically reduce the time needed to produce the code. However, code generators can also be inflexible. The code generator has an internal model, either architecture or module design, which makes many assumptions about what the programmer is trying to accomplish. If this model does notmatch the programmer's needs, the code generator can actually increase the amount of time needed to write the code. The programmer is reduced to manually modifying the output of the code generator, but loses his changes if the code generator is executed a second time. For these reasons, great care must be taken in selecting automated code generation tools.
The compiler converts the developer's code into the instructions for the processor. By compiler, I also mean interpreters, linkers and loaders. Technically, there are differences between these tools, but generally they work together to producing an executing set of instructions and thus can be grouped together.
A developer needs to be thoroughly familiar with the options and parameters of the compiler. Many times,the code quality can be significantly improved by changing the way the compiler generates code. In addition, the developer should make an effort to understand how the compiler will treat the developer's code. This allows the developer to choose the code that produces the most efficient and smallest output. Understanding how the compiler converts code into instructions will also help the developer during the testing and debugging activities. It is sometimes necessary to view the compiler's output in order to locate the problem. The better the developer understands the compiler, the quicker the problem can be found.
The debugger is a tool used to assist in finding and correcting problems in the code. However, the debugger is probably just as useful as a unit test tool. After the code for a function or module iscompleted, the developer should step through the code and examine the state of variables and return codes to insure that the code is operating as expected. Another good use of the debugger is to test code paths that are not normally executed. For example, error-handling code will not be executed if the program is functioning normally. From inside the debugger, the developer can set variables or registers in order to force an error and thus force execution of the error handling code.
Automated test utilities run a system without operator intervention, collect output and analyze the output for correct operation. An automated test is normally used by QA but is useful to anyone on the development team. In order for an automated test to be useful, the configuration of the test must be kept synchronized with changes in the code. Otherwise, the tests will generate false errors and become more a waste of time than a help. Thus, an automated test utility is only useful if QA is fully integrated into the project at all stages. Attempting to automate testing at the end of the project is not likely to be as useful.
Source Code Management
The source code management tool is used to keep all project source code in one location and to track changes to the code. At a minimum, the source code management tool should be capable of extracting any version of the code so that later changes can be ignored or discarded. In addition, the tool should be able to create groups of changes or versions and allow labeling of the version. Good source code management tools will also allow multiple developers to make changes simultaneously and then merge the changes together automatically. On large teams, this feature is essential.
To the coder or tester, the source code management tool has the added benefit of allowing the developer to review the changes made to the code and show the difference between a previous version and the current version. If some part of the system stops functioning correctly, often all that is needed to find the problem is to examine the area of the latest change.