Useful Software Development Tools

Here�s a quick survey of some other candidates for every programmer�s toolbox.

Testing Tools
FitNesse: http://fitnesse.org/
FitNesse is an acceptance testing tool that allows tests to be expressed as tables of input data and expected output data, described in Fit for Developing Software: Framework for Integrated Tests.

Watir: http://wtr.rubyforge.org/
Watir is an open source library for automating web browsers allowing automated testing of web applications. It started out on Internet Explorer on Windows but is in the process of being ported to other browsers.

Selenium: http://selenium.openqa.org/
Selenium is a cross-platform suite of tools to automate web application testing.

Sahi: http://sahi.co.in/
Sahi is an automation and testing tool for web applications that runs as a proxy server.

The Grinder: http://grinder.sourceforge.net/
This is an open source load testing tool in which scripts are written Jython.

JMeter: http://jakarta.apache.org/jmeter/
This is an open source load testing tool in which scripts are written in Java.

QuickTest Professional and LoadRunner: http://www.hp.com/
QuickTest Professional is an automated functional GUI testing tool, and LoadRunner is a performance and load testing product.

Peach Fuzzing Platform: http://peachfuzzer.com/
Peach is a fuzzer that is capable of performing both generation and mutation-based fuzzing.

RFuzz: http://rfuzz.rubyforge.org/
RFuzz is a Ruby library that allows web applications to be easily fuzz tested.


Runtime Analysis Tools
Valgrind: http://valgrind.org/
Valgrind is an instrumentation framework for Linux and includes, among other things, memory analysis and profiling tools.

BoundsChecker: http://www.compuware.com/products/devpartner/visualc.htm
BoundsChecker is part of Compuware�s DevPartner for Visual C++ BoundsChecker Suite. It analyzes running programs to detect memory and other issues.

Purify: http://www.ibm.com/software/awdtools/purify/
IBM�s Rational Purify detects memory leaks and corruption within running programs.

DTrace: http://opensolaris.org/os/community/dtrace/
DTrace is a highly regarded dynamic tracing framework created by Sun Microsystems for troubleshooting kernel and application problems. It is also incorporated in Mac OS X �Leopard,� including a GUI called Instruments.


Network Analyzers
If your software relies upon network communication (and it�s becoming difficult to find software which doesn�t), it can be very useful to see what�s really being transferred over the network. A network analyzer (sometimes called a packet sniffer) sits on the network capturing and analyzing all the packets crossing it. You can then filter these packets to extract only those that you�re interested in and examine their contents. Broadly speaking, a packet sniffer is a low-level tool. It can capture all the traffic on the network but doesn�t necessarily have a deep understanding of the protocol being used. So if, for example, the communication is encrypted, a packet sniffer is unlikely to be able to display the information being exchanged.

TCPDUMP: http://www.tcpdump.org/
TCPDUMP is a widely distributed open source packet sniffer.

Wireshark: http://www.wireshark.org/
Wireshark (previously known as Ethereal) is an open source tool that provides similar functionality to TCPDUMP, but it has a graphical front end and a wider selection of built-in analysis tools.


Debugging Proxies
A debugging proxy is a higher-level tool than a network analyzer, targeted to a particular protocol. You normally need to configure your software slightly differently so that it communicates via the proxy rather than directly, but having done so very often you can get a deeper analysis of the conversation. Some debugging proxies can even view encrypted data.

Charles: http://www.charlesproxy.com/
Charles is a cross-platform HTTP proxy that, among other things, supports debugging encrypted communications.

Fiddler: http://www.fiddlertool.com/
Fiddler is a Windows HTTP proxy that, as its name suggests, allows you to �fiddle� with incoming or outgoing data.


Debuggers
In most cases, your choice of debugger is going to be governed by your choice of language, IDE, or tool chain, so there�s little value in me providing a list of choices here. There is one particular debugger that I have to mention, however:

Firebug: http://getfirebug.com/
Firebug has transformed web development by providing dramatically improved client-side debugging facilities. It allows you to inspect and edit the DOM and CSS, as well as monitor and profile network activity, and it provides full JavaScript debugging support.

Source of Information : Paul Butcher - Debug it Find repair and prevent bugs

Useful Software Development Libraries

Not all tools are stand-alone�many, covered in this section, come in the form of libraries that we need to link with our own code.


Testing
The last few years have seen an explosion in the number of test frameworks, many of which are based upon the seminal JUnit. There�s no way that I can begin to cover them all here, so I will restrict myself to referencing the �big two� in the Java community:

JUnit: http://www.junit.org/
This is the library that started it all.

TestNG: http://testng.org/
This is a more recent test framework, which builds upon the ideas in JUnit but takes a few different approaches and is starting to gain a considerable following.


Debugging Memory Allocators
Debugging Memory Allocators, on in languages like C and C++ that don�t provide memory management, a debugging memory allocator is an essential tool to avoid memory leaks, corruption, and other common issues.

libcwd: http://libcwd.sourceforge.net/
This is an open source debugging support library that provides memory debugging along with other features.

Microsoft Visual C++: http://msdn.microsoft.com/visualc/
Microsoft�s Visual C++ ships with a debugging memory allocator built in. Search for Memory Leak Detection and Isolation in the documentation for further information.

Mudflap: http://gcc.gnu.org/wiki/Mudflap_Pointer_Debugging
Mudflap is a technology built into some versions of the GNU C and C++ compiler that instruments all risky pointer and array dereferencing operations, some standard library string and heap functions, and some other associated constructs with range and validity tests.

Dinkumware: http://www.dinkumware.com/
Dinkumware sells C and C++ standard libraries that include comprehensive support for memory debugging.

Electric Fence: http://perens.com/works/software/ElectricFence/
This uses virtual memory hardware to detect memory overwrites and reuse of freed memory.


Logging
Logging frameworks provide the ability for your code to contain configurable logging that can be enabled, disabled, or increased in detail, typically at runtime and by individual feature.

log4j: http://logging.apache.org/log4j/
Apache log4j is probably the best-known Java logging library, and ports exist to most major languages.

Logback: http://logback.qos.ch/
Logback was designed by Ceki G�lc�, the founder of log4j, to be its successor.

java.util.logging: http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/
As of 1.4.2, Java includes a standard logging API java.util.logging, commonly known as JUL.

SLF4J: http://www.slf4j.org/
The Simple Logging Facade for Java is an attempt to tame the plethora of Java logging APIs by providing a common interface that can write to different implementations at deployment time.

syslog-ng http://www.balabit.com/network-security/syslog-ng/
syslog-ng is the most popular implementation of The BSD syslog Protocol, allowing log data to be integrated from many different systems into a central repository and rich content-based filtering.

Source of Information :  Paul Butcher - Debug it Find repair and prevent bugs

Build and Continuous Integration Tools

We�ve examined at length the benefits of automating your build process, and as you would expect, there are many off-the-shelf tools that will help you to do so.


Build Tools
The granddaddy of build tools is the venerable make. Things have moved on, however, and several much better choices are now available.

GNU Make: http://www.gnu.org/software/make/
Although based upon make, GNU Make supports a number of significant extensions allowing much more sophisticated control over the build process than has traditionally been available.

Autoconf: http://www.gnu.org/software/autoconf/
Autoconf is particularly appropriate for open source software that needs to support building in a wide range of different environments. It allows the build system to automatically determine what facilities are available on the host system and behave accordingly.

Jam: http://www.perforce.com/jam/jam.html
Jam is an alternative to make that typically requires much less configuration to build a given project.

Boost.Build: http://www.boost.org/doc/tools/build/
Built on top of Jam, Boost.Build provides a standard build system particularly appropriate to building C++ software.

SCons: http://www.scons.org/
This is a make replacement integrating autoconf-like functionality.

Ant: http://ant.apache.org/
Ant is a make replacement that has become the de facto standard build tool within the Java world.

Maven: http://maven.apache.org/
Maven is a software project management tool that does much more than simply manage the build process, bringing package management, deployment, and other facilities to the Java world and rapidly gaining mind share from Ant.

Capistrano: http://www.capify.org/
Not a build tool per se, Capistrano manages the task of deploying software on a number of different servers. Although particularly associated with Ruby on Rails, it can be used to deploy products created with any technology.


Continuous Integration Tools
Many of the proprietary systems we�ve already discussed (such as Microsoft�s Visual Studio Team System) come with their own continuous integration solutions. In addition, there are a number of open source systems available:

CruiseControl: http://cruisecontrol.sourceforge.net/
This is probably the best known open source continuous integration system. As well as the main Java implementation, there are also .NET and Ruby on Rails variants.

Hudson: http://hudson.dev.java.net/
This is an open source J2EE continuous integration server.

Source of Information :  Paul Butcher - Debug it Find repair and prevent bugs

Source Control and Issue-Tracking Systems

The problem with choosing a source control and issue-tracking system isn�t so much finding one that�s right for you as picking through the huge range available. So, what might sway your decision? Some things (not an exhaustive list) to consider include the following:

� Open source or commercial?

� Do you need to host it yourself (behind your firewall, for example), or do you want to use one of the many services that provide hosting for you?

� Do you need your source control and issue-tracking systems to be tightly integrated with each other?

� What level of support for distributed development do you need?

I can�t possibly give a complete survey of all the different source control and issue-tracking systems here, but I can give you pointers to a few of the major players and why you might consider them.


Open Source Solutions
CVS: http://www.nongnu.org/cvs/
Until fairly recently, the only real open source choice was CVS. CVS has a number of well-known limitations, however, not least of which are the fact that check-ins aren�t atomic and it doesn�t version directory structures.

Subversion: http://subversion.tigris.org/
Over the last few years, CVS has been almost entirely supplanted by Subversion, which addresses most of CVS�s obvious weaknesses and has become the default open source choice.

Git: http://git.or.cz/
Coming up fast on the rails is Git, which is gaining mind share with a number of high-profile projects switching to it, in part because of its excellent support for distributed development.

Mercurial: http://www.selenic.com/mercurial/
This is a cross-platform, distributed system with very similar goals to Git and particularly good support for branching.

Bazaar: http://bazaar-vcs.org/
This is designed to just work and adapt to your team�s workflow instead of imposing its own model.

Bugzilla: http://www.bugzilla.org/
For a long time, Bugzilla, developed as part of the Mozilla project, was the default open source choice for issue tracking. Recently a number of alternatives have become available, however.

Trac: http://trac.edgewall.org/
Trac uses a minimalist approach, aiming to keep out of the way of developers as much as possible. It�s particularly notable for tight integration with its integrated wiki.

Redmine: http://www.redmine.org/
A relative newcomer on the scene, Redmine seems to be well supported and making good progress. Where open source solutions have traditionally been weak is integration between source control and issue tracking and with development environments. The situation has improved considerably recently with IDEs such as Eclipse providing excellent Subversion support, for example.


Hosted Solutions
SourceForge: http://sourceforge.net/
SourceForge is the best known of a number of similar sites that provide hosting for open source projects, integrating a number of tools such as source control, issue tracking, documentation tools, and so on. Others include Google Code (http://code.google.com/hosting/) and language-specific sites such as RubyForge (http://rubyforge.org/).

GitHub: http://github.com/
GitHub provides Git hosting and has recently gained a lot of attention when it started hosting the Ruby on Rails project.

Lighthouse: http://lighthouseapp.com/
This is a hosted issue-tracking system with integration for Subversion and Git.

Unfuddle: http://unfuddle.com/
This is a secure, hosted project management solution providing Subversion or Git hosting together with integrated issue tracking.

Rally: http://www.rallydev.com/
Rally provides Agile life-cycle management tools.

VersionOne: http://www.versionone.com/
This is a project management and planning tool designed specifically for agile software development. This is also available for local installation as well as hosted.

Pivotal Tracker: http://www.pivotaltracker.com/
Tracker is a free, award-winning, story-based project-planning tool that allows teams to collaborate in real time.


Commercial Solutions
Perforce: http://www.perforce.com/
Perforce is a source control system that particularly concentrates on cross-platform support and performance. It also includes a simple issue-tracking system or can integrate with various open source or commercial solutions.

FogBugz: http://www.fogcreek.com/FogBugz/
FogBugz, from Fog Creek Software, is a flexible bug tracking and project planning tool, available for local installation or as a hosted solution. It�s traditionally been available for Windows, but is in the process of being ported to Linux and Macintosh.

Visual Studio Team System: http://msdn.microsoft.com/teamsystem/
Microsoft�s Visual SourceSafe has long been a favorite punch bag, criticized for a range of failings. To be fair, Microsoft can hardly complain about this given that it never seemed to use it itself despite its famous policy of eating its own dog food. Thankfully,
Microsoft�s offering in this area seems to have improved to no end recently with the introduction of Visual Studio Team System, a fully integrated source control and project management solution.

Rational ClearCase and ClearQuest: http://ibm.com/software/awdtools/clearcase/
The ClearCase source control system and its associated issuetracking solution ClearQuest used to be considered the default enterprise choice. They are expensive and complex, however, and inappropriate for anything other than large teams with dedicated
support organizations.

StarTeam: http://www.borland.com/starteam/
This is a fully integrated source control and project management system.

BitKeeper: http://www.bitkeeper.com/
This is a distributed system with similar goals to Git.

Source of Information :  Paul Butcher - Debug it Find repair and prevent bugs