Want to see Parasoft in action? Sign up for our Monthly Demos! See Demos & Events >>
X
Want to see Parasoft in action? Sign up for our Monthly Demos! See Demos & Events >>
Reading Time: 7 minutesIn today’s digital economy, companies have to deliver software faster to the market to keep pace with consumer demand. To achieve this without sacrificing quality and security, organizations have to be able to effectively test software code changes thoroughly and quickly. But achieving this thorough testing can be a bottleneck, bringing stress and risk to software teams, delaying delivery, and having a direct impact on the business.
One of the biggest contributing factors to software project delays are bugs discovered late in the development process, which occurs because the business puts pressure on development teams to maintain schedules, having a direct side effect on testing and product quality. To help address this issue, development teams leverage unit testing and static code analysis to expose defects earlier in the cycle; however, these practices come with drawbacks of their own, related to time and cost, that can cause a delay in achieving quality at speed.
To address those delays in delivery and help teams more reliably achieve quality and security at speed, enterprises can leverage Parasoft Jtest to make Java development testing more efficient. Whether doing new code development or maintaining a legacy application, Parasoft Jtest can generate, augment, clone, and mutate unit tests, while also optimizing the execution of those tests, to facilitate substantial improvements in the amount of time and cost associated with unit testing. The “side” benefit? A meaningful suite of maintainable unit tests.
In addition, Parasoft Jtest can scan source files to improve application security and quality during the development process. Overall, this helps to accelerate delivery and increase software quality by capturing defects earlier in the software development process.
To illustrate how to increase ROI in the unit test creation phase, let’s say a major financial institution is implementing a cloud migration strategy with new Java applications being developed. The development team consists of 20 developers that cost $100,000 per developer on average, so the total development cost is $2 million annually. The new application will release quarterly, so the development cost per release is $500,000. Based on our research, the average development team spends a conservative 30% of their time writing unit tests manually, which suggests, for a given release, writing unit tests costs the business about $150,000.
(1/4)($2M)(.30) = $150,000
(Quarterly Release)(Yearly Developer Cost)(Percentage of Time Spent Writing Unit Tests) = Cost Writing Unit Tests
With Parasoft unit testing, users have reported that writing unit tests can be done in half the time. In addition to eliminating many of the time-consuming manual tasks associated with unit testing, Jtest does this by using AI to automatically generate unit tests as soon as the code is written to increase code coverage. So, instead of spending 30% of development’s time on writing unit tests, it can take just 15%, focusing more of their time on the business logic portion of the test.
(1/4)($2M)(.30)(.50) = $75,000
(Quarterly Release)(Yearly Developer Cost)(Percentage of Time Spent Writing Unit Tests)(Percentage Time Reduction with Jtest) = Cost Writing Unit Tests with Jtest
This brings the cost of writing unit tests down from $150,000 to $75,000, resulting in a cost savings of $75,000 per release and a yearly savings of $300,000.
$150,000 – $75,000 = $75,000
Original Cost of Unit Testing – Cost of Unit Testing w/Jtest = Cost Savings with Jtest
($75,000)(4) = $300,000
(Cost Savings)(Number of Releases per Year) = Total Savings Annually with Jtest
Reducing the development cost helps bring profitability to the business. In addition to cost savings, valuable time is being saved as well. If the company employs 2-week sprints for development, which consist of 10 working days, then 30% or 3 days is allocated to unit testing. For a given release (3 months), there are 6 total sprints (ex: 5 for development and 1 for final testing). Using these numbers, 15 days of the release are used for unit testing by the team.
(5)(10)(.30) = 15 days
(# of Development Sprints)(# of Days in a Sprint)(Percentage of Time Spent Writing Unit Tests) = # of Days Spent Unit Testing for the Release
Jtest cuts this time in half to 1.5 days of unit testing per sprint or 7.5 days of the release are used for unit testing by the team.
(5)(10)(.30)(.50) = 7.5 days
(# of Development Sprints)(# of Days in a Sprint)(Percentage of Time Spent Writing Unit Tests)(Percentage Tme Reduction with Jtest) = # of Days Spent Unit Testing for the Release with Jtest
Saving the business 7.5 days is extremely valuable when you are in a time crunch to beat your competitor to the market.
15 – 7.5 = 7.5 days
Original Time Spent Unit Testing – Time Spent Unit Testing w/Jtest = Time Savings with Jtest
It’s worth noting that in this example, a conservative 30% is used for the time allocated to writing unit tests manually, but often this number is much higher, going up to 50% depending on the organization’s unit testing practice. These organizations will see even higher time and cost savings with Parasoft Jtest.
Now let’s say the same organization is building out their new application and as they do so, they are generating more and more unit tests, going from solitary (isolated) unit tests that take seconds to run, to sociable (integration-level) unit tests that take significantly longer to run. Their full unit test suite execution time grows to 2 hours, and their overall development build time suffers because 2 hours is a lot of time for a software development team to wait before they can get feedback on their code changes. The organization follows an agile methodology, so they build multiple times a day to provide frequent feedback to their software teams, but due to the 2 hour unit test execution time, they can only execute 3 builds a day, corresponding to 6 hours of overall unit test execution time daily, which can result in inefficiency in the development process.
To tighten the release cycle, the team can optimize unit test execution with Parasoft Jtest. Jtest reduces the time it takes to execute unit tests with AI-enabled test automation, executing an optimized set of unit tests based on the code that has changed, rather than running the full suite of tests. This optimization happens within the developer’s IDE before code is checked in, as well as during the CI builds, while the full test suite continues to execute nightly. By optimizing which tests get run, the overall build time gets dramatically shortened, and enables quicker feedback to software teams. And the organization can get more builds per day, which optimizes the team’s productivity during the active part of the day, resulting in a faster delivery time. Both time and cost savings can be seen, when leveraging Jtest’s testing technique.
Let’s continue to use the same organization for this scenario and as they are testing, they are discovering several late cycle defects. Using the cost-per-defect metric from the “Composing Effective Software Security Assurance Workflows” by the Software Engineering Institute at Carnegie Mellon University, defects found in early-cycle cost on average 1-hour to find and fix, as opposed to those found in late-cycle, which tend to cost 7 times more, 7-hours. Based on the $100,000 average salary, it will cost ~$48 to find and fix a defect early versus ~$336 for finding and fixing a late-cycle defect. The company identifies 20 late-cycle defects, which totals $6,720 and 140 development hours (~18 working days) to resolve. With this data, it is clear to see the impact that late-cycle defects have on time and cost of a release.
($48)(7)(20) = $6,720
(Developer Cost per Hour)(# of Hours to Find and Fix a Late-cycle Defect)(# of Late-cycle Defects) = Total Defect Remediation Cost
[(7)(20)] / 8 = ~18 working days
[(# of Hours to Find and Fix a Late-cycle Defect)(# of Late-cycle Defects)]/ (# of Hours in a Typical Workday) = Total Defect Remediation Time
To reduce the amount of defects that show up late-cycle, Parasoft Jtest enables teams with automated static code analysis and security testing, providing 1000+ rules which identify potential vulnerabilities and issues in the code at development time (early-cycle). If Jtest conservatively detects 25% of the late-cycle defects earlier, resulting in 5 early-cycle defects and leaving 15 late-cycle, then this costs $5,280 and 110 development hours (~14 working days) to find and fix both early and late cycle defects. This lowers the time and cost of defect remediation for the release by roughly 25%.
($48)(1)(5) = $240
(Developer Cost per Hour)(# of Hours to Find and Fix an Early-cycle Defect)(# of Early-cycle defects) = Early-cycle Defect Remediation Cost
($48)(7)(15) = $5,040
(Developer Cost per Hour)(# of Hours to Find and Fix a Late-cycle Defect)(# of Late-cycle Defects) = Late-cycle Defect Remediation Cost
$240 + $5,040 = $5,280
Early-cycle Remediation Cost + Late-cycle Remediation Cost = Total Defect Remediation Cost with Jtest
($6,720 – $5,040)/$6,720 = ~25% Cost Savings with Jtest
(Original Remediation Cost – Remediation Cost w/Jtest)/Original Remediation Cost = Percentage Cost Savings with Jtest
[(1)(5)] / 8 = ~1 day
(# of Hours to Find and Fix an Early-cycle Defect)(# of Early-cycle Defects)/ (# of Hours in a Typical Workday) = Early-cycle Defect Remediation Time
[(7)(15)] / 8 = ~13 days
(# of Hours to Find and Fix a Late-cycle Defect)(# of Late-cycle Defects)/ (# of Hours in a Typical Workday) = Late-cycle Defect Remediation Time
1 + 13 = 14 days
Early-cycle Remediation Time + Late-cycle Remediation Time = Total Defect Remediation Time
(18 – 14)/18 = ~22% Time Savings with Jtest
(Original Remediation Time – Remediation Time w/Jtest)/Original Remediation Time = Percentage Time Savings with Jtest
To further shift-left the identification of issues, Jtest enables the user to execute “on the fly” or continuous analysis while development is being done, within their IDE. This allows the developer to remediate issues while they are already actively working with the code when the defect is introduced. This further reduces time and cost associated with defect remediation and greatly increases quality at speed.
Parasoft Jtest is a key enabler of delivering quality at speed. Developers are more able to reduce late-cycle defects, with better unit tests and automated static code analysis, allowing them to focus more time on new feature development for the business, and those developers can also benefit from immediate feedback, being able to rapidly identify whether their code changes are breaking functionality in the application and addressing it quickly. Parasoft Jtest enables development teams to be agile and deliver faster without sacrificing quality, making the business succeed.
Kapil is a Product Manager at Parasoft, focusing on Parasoft Jtest. Kapil held several technical positions ranging from software engineer to development lead, before moving into product management.