BoundsChecker is the heart of DevPartner's error detection capability. It finds the root cause of many sources of application instability, including memory leaks and overlays, heap and stack corruption, overruns, and API misuse. Offering two operational modes, one with and one without compile time instrumentation, BoundsChecker offers myriad ways to uncover application flaws that left unchecked could toss a critical application into fault.
Have you ever placed a bit of code in a for loop and seen how long it takes a hundred thousand times to run? That is a primitive but effective way to isolate and optimize specific routines. That technique can also tear up the code and loses practicality in whole applications. Performance Analysis gives you back that stopwatch, but with precision down to single invocations of routines and lines of source code. Based on a proprietary kernel-mode driver, the timing engine inside Performance Analysis sniffs out bottlenecks at the thread level, yet presents findings in context of lines, methods, classes, and components. With the ability to quantitatively show whether CPU or I/O bounds lie at the root cause of each bottleneck, optimization strategies become clearer.
.NET Memory Analysis
Memory use in managed languages remains a tough source for bugs to hide thanks to the garbage collector and developers’ reliance on it to handle all memory management chores. Even though normally objects may be disposed automatically, objects that linger, that force extra garbage collections, or hoard objects semi-intentionally, can all effect system wide application performance and scalability. DevPartner’s .NET Memory Analysis provides zero-click, one-click, and two-click interactive interfaces for studying memory use. Drill down to specific object references and allocation traces to gain comprehensive insight into which classes and which code is responsible for memory misuse.
It has been stated that adding code coverage analysis to an application development practice can be the single most important quality step that a team can adopt. Code coverage indeed provides quantifiable evidence for test case execution. It also provides insight into where tests can be added, and where gaps may yet lie. DevPartner Coverage Analysis handles many types of tests, providing summary and drilldown details for source level execution counts. It remains the simplest of runtime inspections to grasp and to operate, so should be the first step in attacking code quality objectives.
.NET Code Review
Compilers can do a fine job of determining whether your source syntax is legally permitted within the rules of that language grammar. But can they determine when the source syntax is good? That is the realm of Code Review, which is like performing a manual code review with a bunch of people inspecting lines of source, yet with the automation power of computer assistance. Static analysis can reveal code problems in structure, design, complexity, and naming, allowing teams to police their own local practices and achieve design goals relative to object orientation, maintainability and readability of code, and reduction of common bug patterns. Moreover, static analysis of web applications offers scrutiny of the first tier of security vulnerability in multi-tier deployments.