Many companies with existing legacy code bases bump into a huge impediment when they want to get agile: lack of test automation. Without test automation it is hard to make changes in the system because things break without anybody noticing. Defects aren't discovered until the new release goes live; worse, they are discovered by the real users, an embarrassment that results in expensive hotfixing, or even a chain of hotfixes, as each hotfix introduces new, unanticipated defects. These risks make the team terribly afraid to change legacy code, and therefore relucant to improve the design of that code, which leads to a downward spiral in the quality of code as the system grows.

Visual Studio is fine for most debugging purposes. Just occasionally, it isn't practicable, or there are other quicker ways of doing it with a user-mode debugger. Edward argues that debugging in MSIL or assembly language is a strangely liberating experience and can be a lightweight route to discovering the cause of elusive bugs. He starts off with a simple introduction to SOS debugging.

So many factors can affect the performance of a Web page—the distance between server and client, the size of the elements on the page, how the browser loads these elements, available bandwidth. Finding those bottlenecks and identifying the culprits is no easy task. But identifying the causes can yield some significant improvements.
In this article, I'll show you how to spot and remedy some common causes of poor performance. I'll also introduce you to Visual Round Trip Analyzer (VRTA), a tool that can distinguish among the various factors that cause performance problems and present them as a graphical map. Then I'll show you how to perform your analysis using VRTA. But before we begin, find out how much you already know by taking the speed quiz called "How Do You Improve Page Loading?" that is included in this article.

This article explores things people can do from within their code to make their lives, and the lives of anyone else who has to administer or maintain their application, easier.

Blaming bad code (or bad code monkeys) won't help you find performance bottlenecks and improve the speed of your Java™ applications, and neither will guessing. Ted Neward directs your attention to tools for Java performance monitoring, starting with five tips for using Java 5's built-in profiler, JConsole, to collect and analyze performance data.

Now that you’ve identified technical debt in your code base, let’s turn our attention to some specific tactics that will help you pay back that debt.

This article attempts to transition the process of performance tuning into the realm of “science” by presenting a repeatable process that focuses on the end user experience by analyzing an application’s architecture in terms of “wait-points”, or portions of an application that can cause a request to wait. In short, Wait-Based Tuning allows performance engineers to quickly realize measurable performance gains by optimizing the end-user experience.

Google provides an interesting and easy-to-use open source alternative for developing unit tests to validate C/C++ based software. This article introduces readers to some of the more useful features of the Google C++ Testing Framework and is based on version 1.4 of the release

Software testing is an essential element of any software development effort. Developers must have some means of selecting tests to evaluate the completeness and quality of product produced. This article reviews Boundary Value Analysis (BVA), a functional testing methodology that can assist in the identification of an effective set of tests.

More development teams are putting testing front and center, and using TDD. Lisa Crispin covers how attitude and curiosity have shaped her career and kept her passion for testing software fresh.

For a large-scale system of systems (SoS), severe integration and run-time problems can arise due to inconsistencies, ambiguities, and gaps in how quality attributes (such as reliability) are addressed in the underlying systems. This is exacerbated in contexts where major system and software elements of the SoS are developed concurrently and oftentimes independently. Using a defense system scenario, this article outlines a uniform approach for capturing quality attribute requirements as augmentations to mission threads early in the development process and for analyzing SoS, system, and software architectures against these mission thread augmentations.

Acceptance test-driven development is what helps developers build high-quality software that fulfills the business’s needs as reliably as TDD helps ensure the software’s technical quality.

Usability testing based on paper prototypes and early versions of the software were added to the agile development process for the second application release resulting in a significant reduction of usability related rework. The paper prototype became a tangible representation of the project vision that was used in many ways that contributed to the resounding success of the project.

Using the major new Profiler features in NetBeans 6.0, and applying profiling techniques and best practices in a real-world tutorial

The defect containment measure is traditionally used to provide insight into project success (or lack thereof) at capturing defects early in the project life cycle, i.e., the time when defect repair costs are at their minimum. Although the measure does provide insight into the effectiveness of early defect capture techniques (such as peer reviews), defect containment in its most common form (percentage of defects captured) is a lagging indicator as its ultimate value cannot be known until a project is complete. At that point, it is too late for a project to take corrective action. Using raw defect containment data and deriving Quantitative Defect Management (QDM) measures early in the development life cycle provides opportunities for a project to identify issues in defect capture before costs spiral out of control, schedule delays ensue, and another Death March begins.

Test-driven development (TDD) is a great idea in practice, but some developers just can't get over the conceptual leap associated with that word test. In this article, Andrew Glover shows you a more natural way to integrate the momentum of TDD into your programming practice. Get started with behavior-driven development (BDD) (via JBehave) and see for yourself what happens when you focus on program behaviors, rather than outcomes.

There are times when it is not practical to hand-script automated tests for an existing system before one starts to modify it. In these circumstances, the use of “record & playback” testing may be a viable alternative to hand-writing all the tests. This paper describes experiences using this approach and summarizes key learnings applicable to other projects.

This paper presents an overview of AJAX, what a black box tester should know before he leaps into AJAX testing, and the security risks that AJAX applications open up. Also discussed are the market trends are for AJAX adoption and its prospective growth potential. Finally the author looks at some of the black box test ideas and recommendations that test two main security concerns in AJAX implementation: data validation and session management.

Asynchronous JavaScript + XML (Ajax) continues to raise user expectations for interactivity and performance, and developers are increasingly treating Ajax as a must-have component of their Web applications. As more code is moved client side and the network model changes, the community is responding by building more tools to address the unique performance challenges of Ajax. Examine toolsets that find and correct performance problems within your Ajax-enriched applications.

Certain vulnerabilities within Ajax applications can allow malicious hackers to reek havoc with your applications. Identity theft, unprotected access to sensitive information, browser crashes, defacement of Web applications, and Denial of Service attacks are just a few of the potential disasters Ajax applications can be prone to and which developers need to guard against when building Ajax capabilities into their applications. Regular developerWorks author Judith Myerson suggests some application-strengthening tools, including Firefox tools and add-ons, which you can use to improve or solve security problems within your Ajax applications.