Borland Logo MicroFocus Logo

DevPartner®

DevPartner tools

  • BoundsChecker for native error and leak detection, best of breed for C++ troubleshooting
  • True Time, True Coverage, and True Memory analyzers for performance, coverage, and managed memory
  • Code Review static code inspectors for finding bugs in .NET and Java code

New in DevPartner Studio Editions

  • Support for Visual Studio 13 2013, including VC++ 13 2013 and .Net 4.5 runtime compatibility. Full support for Windows 8 and 8.1.
  • Thread-local and thread-global session controls for performance and coverage of transactions.
  • Realtime feedback monitor and instant-on memory resource viewer for BoundsChecker.

Compare

The DevPartner® product line consists of developer tools that aid in code troubleshooting and inspection. Developers, testers, and build managers can use one or more tools in their daily code, test, and verification work. Depending on what you need to achieve, different tools are available:

  • Dynamic runtime tools - Focus on memory, performance, coverage, and error detection in running applications and unit test harnesses.
  • Static tools - Focus on code quality, bug detection, identifying complexity, and design metrics

Different tools bundled in suites

Our tools are combined into suites according to what you really need to do and primary languages. This allows developer, testers, and build managers to leverage the right tools for their specific role throughout code construction and validation efforts. Starting off with the base functionality in Boundschecker, you can add functionality to offer even more powerful capabilities:

 EditionFunctionality
DevPartner Studio Professional EditionDevPartner Studio Professional EditionEverything you need to build great C++ & .NET applications from DevPartner
DevPartner VC++ Edition-BoundsChecker SuiteDevPartner VC++ Edition-BoundsChecker SuiteGeared towards native developers, but providing coverage and performance for testers.
BoundsCheckerBoundsCheckerGeared toward native C and C++ developers hunting memory and corruption problems.
PerformanceCheckerDevPartner PerformanceCheckerLet us help you by quickly and easily uncovering and resolving poor code performance with Micro Focus DevPartner® PerformanceChecker.
MemoryCheckerDevPartner MemoryCheckerQuickly and easily uncover how memory objects are allocated and locate where performance problems emerge due to memory misuse with Micro Focus DevPartner® MemoryChecker.
CoverageCheckerDevPartner CoverageCheckerQuickly and easily quantify runtime application test coverage with Micro Focus DevPartner® CoverageChecker
SystemCheckerDevPartner SystemCheckerTrap environment problems quickly and easily by comparing a working environment with a non-working environment with Micro Focus DevPartner® SystemChecker.
DevPartner Java Edition suiteDevPartner Java Edition suiteMirrors for Java the managed tools in DevPartner Studio Professional edition and works on many JVMs on Windows, Linux, and UNIX platforms.

 

The table below gives a detailed view of what each suite has to offer:

compare table

DevPartner for .Net

.NET memory analysis

Memory use in managed languages remains a tough source for bugs to hide in thanks to the garbage collector and developers’ reliance on it for all memory management chores. Even though objects may normally be disposed automatically, objects that linger, force extra garbage collections, or hoard objects semi-intentionally, can all affect 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.

.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. So teams can police their own local practices and achieve design goals relative to object orientation, maintainability and readability of code, and reduction of common bug patterns. What’s more, static analysis of web applications offers scrutiny of the first tier of security vulnerability in multi-tier deployments.

.NET performance analysis

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. It can, however, also tear up the code and loses practicality in whole applications. Performance Analysis gives you the stopwatch, 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 coverage analysis

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.

DevPartner for C++

BoundsChecker

bounscheckerBoundsChecker 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 provides many ways to uncover application flaws that if left unchecked could toss a critical application into fault.

C++ performance analysis

Performance AnalysisHave 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, however, also tear up the code and loses practicality in whole applications. Performance Analysis gives you back the 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.

C++ coverage analysis

Coverage AnalysisIt 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.

DevPartner for Java

Java memory analysis

Memory AnalysisMemory use in Java remains a tough source for bugs to hide in thanks to the garbage collector and developers’ reliance on it for all memory management chores. Even though objects may normally be disposed automatically, objects that linger, force extra garbage collections, or hoard objects semi-intentionally, can all affect system-wide application performance and scalability. DevPartner’s 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 packages, classes, and code is responsible for memory misuse.

Java code review

Code reviewThe Java bytecode compiler can do a fine job of determining whether your source syntax is legally permitted within the rules of the Java language. But can the compiler alone 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. Teams can police their own local practices and achieve design goals relative to object orientation, maintainability and readability of code, and reduction of common bug patterns. What’s more, reverse analysis of Java package structures can identify poor object oriented constructs using a model that spans your whole application—with only bytecode needed if no source is available—to address design problems that may haunt you for years as code is grown and maintained.

Java performance analysis

Performance AnalysisHave 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. It can, however, also tear up the code and loses practicality in whole applications. Performance Analysis gives you the stopwatch, 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.

Java coverage analysis

Coverage AnalysisIt 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.