It is one of the most mind-numbing tasks in the software development process, and one loathed by both developers and customers alike - akin to self-editing a manuscript for a writer who has spent three months pouring over the same text - bug checking is by no means a fun exercise and can be quite frustrating when facing deadlines and customers eager to launch their sites.

Nonetheless, bug testing is an inevitable necessity for any software development project, including website development.  For someone who's not familiar with software development, bug testing seems like it shouldn't be necessary, "How come you guys didn't just get it right the first time?"  Of course, anyone who's actually coded anything themselves knows that it is virtually impossible to code anything with out any errors in a single pass. Just as a writer needs to create a first draft, then get feedback from an editor and other readers before making a series of adjustments before their publisher approves and prints the final edition, software development requires review, feedback, and modification to produce fully-functional websites that are ready to launch to the public.

And so we must anticipate and budget for bug testing for all website development projects, and there are a number of ways to do this. Most approaches rely on creating lists of "bug reports" that are processed by developers until the list is exhausted and the website is ready to be launched.  Whether it's done on a piece of scratch paper or with an advanced ticket management system, the purpose of creating bug reports is to document each and every fix, tweak, error, and adjustment that needs to be made to the site to bring it up to acceptable professional usability standards.

However, not all approaches to bug testing are equally effective, and disorganized approaches will very quickly expose the need to implement efficient and effective practices for documenting, assigning, and completing bugs as they are discovered and resolved often by a team of multiple individuals.  In order for multiple workers to coordinate their efforts, proper bug reporting becomes essential, not only for ensuring that all work is correctly completed, but also because poor bug reporting will result in redundant work, excessive time spent clarifying bugs, and ultimately a longer development period (which extends the cost of hourly or salaried workers).

An effective bug-reporting process should include the following:

• multiple bug-testers whose job is to find bugs and report them
• a system that allows bugs to be listed and each bug delegated to a single developer responsible for correcting the bug
• a quality assurance tester who re-checks the work done to correct each bug
• a process for re-iterating bugs that are not corrected the first time

Establishing a process that includes these functions will ensure that bug testing is efficiently managed, and that bugs are systematically rooted out from your website. But simply implementing such a system is not enough. What's equally important, is that bugs are sufficiently described when they are created (see more on effective bug reporting here)

To maximize the efficiency of bug testing, make sure that each bug report include the following:

• A clear description of the problem and how it can be duplicated
• Show screenshots with annotations as possible (hint: get SnagIt - or another screen capture tool and use it).
• Give a URL whenever possible rather than just referring to a page or jumping right into a description of a problem
• Provide information on browser type and build you are using so the developer can accurately reproduce the error
• If the website has multiple user roles, be sure to indicate for which role the error is occurring
• Make sure you do a "Hard-Refresh" on your browser when checking fixes, especially for CSS and image changes, as your browser will often cache these items and show you old versions of the files if you do not do this. For PCs, this is usually done with CTRL+F5

Effective bug reporting will ensure more rapid development periods and will help you bring your website to market faster. This will result in dramatic cost savings for your overall project, and allow you to focus more effort and resources on the "next features" so your website can continue to evolve and grow.

So you've paid your coders and they've delivered the agreed upon product - which you are satisfied with and have confirmed that the main functionality works properly.

You clean up some of the CSS on your own and prepare to show it to a client, and as you're practicing your walk-through, you notice an error message that appears when you login from an obscure secondary page.

UH-OH!

As you check a few other login fields throughout the site you realize that the only working login area is the one you were shown when your coders walked you through the "finished" product.

Frantically, you call up (or email) your coders and would be happy to do the work of adding login functionality to all of the login areas of the site: at their normal billed rates (or at inflated "rush rates" if you're desperate for an immediate resolution).

Combing through other details of your site, you start noticing small fixes that need to be addressed throughout the site before it can be launched for public consumption: login pages redirect back to the homepage instead of to the member's account page, broken links have not been fixed, data fields are populating with incorrect information, and some of the spacing around your logo could use an adjustment.

All of these minute bugs and tweaks separate the "amateur" from the "professional" website, and polishing your site until it as flawless as possible will have a direct impact on the relationship you forge with your customers within the first critical seconds of their arrival on your website.

"The devil is in the details."

We've all heard this before, and as tedious as debugging and tweaking can be, the key to completing this laborious process is to break down each and every fixable issue into a specific work item.  At PeaceofCode, like many other project management systems, we call an individual set of work instructions a "ticket", and service work requests on a "per-ticket" basis.  On larger projects for new website or mobile application developments, a single ticket will consist of blueprints for the core functionality, which can later be expanded with additional functionality or integration with other components.

For debugging and tweaking a website, it may be difficult to get ahold of your original coders for this small detailed work - the reality may be that they simply don't make much money doing 1 to 2 hours of tweaking work; considering the time it takes to understand work instructions, perform the work, invoice you for the work, and then wait to be paid, they are more like to move onto building new projects for customers who like you - will pay to get their code only to realize it still has bugs and requires additional tweaking.

So you might think these coders are ripping you off. Actually, it's more likely that you either started with improper documentation which did not explicitly define the complete body of work or otherwise did not completely review the work before they handed it over (and you handed over the final payment). Consider as well that if you hired a full-time employee you would either have to pay them overtime or extend the development period to give them more time to accommodate the increased scope of work.

The simple truth is that you need to budget time in your website release cycle to address these small bugs, errors, and refinements that are inevitable when you reach the end of the develoment process. Some of these items can be addressed on-the-fly even after your website is launched, but you should avoid having to rush these fixes in the interest of trying to launch on schedule: it could turn out to be quite costly or even improperly done.

Finally, after a couple years of mind-splitting development and refinement, we're ready to release PeaceofCode.com ...

Well, almost, but close enough to start getting excited about it - here's why you should be too:

1. PeaceofCode provides a reliable resource for a wide range of website and mobile app development services.

2. PeaceofCode gives you a firm bid price for your scope of work and gets the job done without making you shop your idea to hundreds of bidders.

3. PeaceofCode can help you with blueprinting your concepts from start-to-finish, and our professional project managers work hand-in-hand with you to ensure the development work is completed accurately and on-time.

We're really looking forward to releasing this product, and have had strong reviews amongst our industry peers and customers who are excited to use our new service.

Stay tuned...

- PoC

[PeaceofCode.com: PeaceofCode is a Cloudware Service Provider that provides on-demand development support for major open-source Content Management Systems such as Joomla, Drupal, and Wordpress. Our proprietary ticket processing platform is designed to allow clients to outsource and pay for development work through a web-based interface that ensures work is completed faster, more reliably, and less expensively than existing outsourcing options.]

As part of the growing network of GoroStudios Developed sites, PeaceofCode provides owners and developers of websites using Content Management Systems with reliable quality development and maintenance support including:

• New website deployment using popular Content Management Systems such as Drupal, Joomla, and WordPress
• Website maintenance, debugging, and troubleshooting for Drupal, Joomla, and WordPress (including extensions)
• Custom website development and enhancements for Drupal, Joomla, and WordPress (including extensions)

Our streamlined ticket management system makes it easy to submit a Work Request Order; to quickly define the changes or additions to be made to your site.  The cost of the Work Request is determinied by the time estimated to complete the job, and confirmed by one of our in-house project managers.

This project manager will personally monitor your Work Request in order to ensure that the work done by our in-house development team is double checked and meets all established goals before it is returned to the client to review.

Only when our client's review and approve the work that has been completed, do we deduct the allocated funds from their account.

There is simply no better system for ensuring efficient, dependable development work for your Joomla, Drupal, WordPress, or other open-source Content Management System website.