- Why Sluggish Applications Cannot Be an Option
- Life without a Code Profiling Tool
- Why You Should Own a Code Profiler
- Stop Guessing: Use Real Data
- Keep an Audit Trail of Code Changes and Performance Improvements
- Efficient Testing as Part of an Effective Quality-assurance Effort
- Make Better Design Choices
- Reduce Hardware Costs
- Why ANTS Profiler is the Market Leader
This document highlights a few of the reasons why you – or your development team – should invest in a code profiling tool. First, we demonstrate how critical your development work is and how it affects your organization as a whole. We then expose why you need to avoid manual trial and error processes, and why having a profiling tool in your development toolkit is so vital. The last section offers an insight into why ANTS Profiler is the market-leading code profiler.
Why Sluggish Applications Cannot Be an Option
For most organizations, bloatware – i.e. sluggish or unresponsive software – is not an option. Web pages that take too long to load, an unresponsive shopping cart or, worse still, an application that hangs, will cause customers to lose confidence in your software, and can even stop them purchasing from your company.
There is nothing more frustrating than having to wait needlessly for a web application to finish processing. Simon Galbraith, Joint CEO at Red Gate Software, demonstrates in a Simple-Talk article [^] how users begin to abandon websites if they have to wait more than 5 seconds for a page to download.
Simon Galbraith's findings are supported by a Jupiter Research report [^] from 2006 which found that 33% of consumers shopping via a broadband connection will wait no more than 4 seconds for a Web page to render. This suggests that your HTML must be served to the client in less than 1 second, even when your server is under heavy load, as you need to allow time for their browser to download additional images and perform the processing necessary to display the page.
The same research also points out that over 33% of shoppers who were dissatisfied with a retail site's performance (website too slow, site crash, error message received, etc.) abandoned the site.
Further to this, a study of 12,000 online consumers reported by ZDNet (2002) revealed that 48% of those interviewed had given up trying to purchase products when web pages took too long to download.
These principles also apply to desktop applications, whether they are used by end-users internally or externally. End-users are quick to complain if the programs they use on a daily basis are too sluggish for their liking. They will demand constant technical support and general productivity will go down. Then, just when you have plenty of other things on your plate, you'll be asked to fix the problem.
The results are conclusive: end-users do not like sluggish software – and you won't like it either, once you see how much it's costing your company.
In essence, every professional developer, whether developing web applications or desktop applications, needs his or her code to run quickly and efficiently. The big question, however, is: "How do you ensure that your code is quick and efficient?"
Life without a Code Profiling Tool
Finding performance bottlenecks is not an easy task without a code profiler. You can use trial and error, sometimes spending hours, days, and even weeks blindly chasing performance issues. So much for productivity!
Additionally, you could waste even more time tuning code that is not the cause of any problem. It is rare for a bottleneck to be in the obvious place, and what is the point in spending time optimizing code that is never called?
Why You Should Own a Code Profiler
A code profiler is an essential tool to have in your development toolkit. It helps to dramatically reduce the amount of time taken to find problem code, by quickly identifying the exact cause of a performance bottleneck, so that you can focus on your code optimization.
Stop Guessing: Use Real Data
A code profiling tool takes the guesswork out of optimizing code. It can provide quantitative data -- such as code timings and hit counts -- allowing you to stop guessing and zero in on key issues. Instead of spending time locating the bottlenecks, you can now use your time effectively and obliterate bottlenecks while those around you are still hunting for them.
A code profiler analyzes your code in minutes, and the results allow you to:
- Know how your code performs
You may have just joined a company, or you may not have worked on a particular application, and you are being asked to look into somebody else's code, perhaps your predecessor's. Examining someone else's code when you are not familiar with it is a difficult job. A code profiler that can analyze the code for you before you get stuck in it will allow you to gain a better understanding of the application structure and how the code runs. In cases where you do develop the application yourself, understanding how your code behaves, where each piece of code is being called from, whether it goes into unnecessary loops, and so on, gives you immense knowledge and power. It means that you can fix any issues before shipping, rather than waiting for your customers to report problems. Doing this allows you to release resilient applications and code that you can be proud of.
- Locate performance bottlenecks quickly
Reducing the amount of time it takes to find bottlenecks means you can get on with the work of fixing inefficient algorithms, eliminating the bottlenecks, and achieving the results you want, faster.
- Optimize your code – only where it is necessary
Queuing theory tells us that the maximum throughput in a system is limited by the component with the lowest throughput. So, to improve the system's performance, you only need to improve the performance of the component with the lowest throughput.
It's so much easier to make an algorithm run more efficiently when you know exactly where to focus your performance-boosting work.
Keep an Audit Trail of Code Changes and Performance Improvements
Aside from the essential arguments listed above, code profiling throughout the development cycle allows you to keep an audit trail of performance improvements made over time. As your application changes and grows in size and quality, managers generally like to have a means of monitoring the code at intervals throughout the development cycle. They want to know that performance trends are moving in the right direction and that applications aren't becoming unnecessarily complex and unstructured. The only way to keep track of this is to profile your code after each critical milestone.
Efficient Testing as Part of an Effective Quality-assurance Effort
Any significantly-sized piece of software contains bottlenecks, just as it will contain bugs. It's inevitable; it's part of the job. What's avoidable, however, is wasting unnecessary time looking for, and fixing, bottlenecks and bugs. Furthermore, the earlier you find and fix a bottleneck or a bug, the cheaper it is to fix. An industry rule of thumb is that a bug that costs $100 to fix before shipping can cost $1,000 to fix after shipping.
Looking for a bug and fixing it two weeks after it was introduced is going to be much easier than finding and fixing a bug that was introduced two months ago. For one thing, the "surface area" of changes in that period is going to be smaller, and the code will be fresher in your mind.
This is why using a code profiler after each milestone is vital. It will save you hours, days, and sometimes weeks when you are pressed for time later down the line. You will sometimes have to rewrite large amounts of code, or code which you thought was stable, after discovering that parts of it do not perform as well as expected. Then, of course, once the code has been rewritten and tested, something else might break and need fixing.
Testing for bottlenecks and bugs late in the development process leaves you very little time to fix issues and, where it is deemed too risky to drastically optimize code at a late stage, it greatly increases the likelihood of a poorly-performing application being released. This would reflect badly on you, your team, and your department. Yet it is so easy to minimize risks simply by profiling your .NET code regularly during the development phase, after each critical milestone. The time, money, and stress it saves you down the line are always worth it.
Using a code profiler for quality assurance during your development phase will allow you to measure the quality of your software and make sure that you reach a given performance standard. It allows QA Managers and Software Managers to streamline test plans and allocate most of the time and resources to the most critical part of the code (saving on excessive time spent on areas of the program where the risk of defects is low).
Make Better Design Choices
If used early on during the development phase, a profiling tool can also help you make design choices based on the profiling results. You can compare the performance of different approaches and make sure your application is scalable early on in the project, avoiding costly problems later on.
Reduce Hardware Costs
If you can make your application run faster, you can accommodate more requests per server, and therefore utilize less hardware. By using a code profiler throughout the development process, and optimizing performance, you will also be better able to assess hardware requirements and, potentially, reduce hardware costs.
Why ANTS Profiler is the Market Leader
Whether you are developing in C#, VB.NET, or managed C++, you will be looking for optimum performance from your code. ANTS Profiler identifies performance bottlenecks in applications written in any of the languages available on the .NET Framework. During performance profiling, ANTS Profiler records the frequency and time it takes for each line of code to be executed, as you are using your application. ANTS Profiler provides you with detailed quantitative data, including line-level timings, and hit counts. These detailed results allow you to quickly identify performance bottlenecks and optimize your .NET application accordingly.
Source code view: ANTS Profiler provides you with detailed profiling results, including line-level timing, so you can drill down to the specific lines of code responsible for performance inefficiencies.
ANTS Profiler's main strengths:
- Ease of use
ANTS Profiler is designed so that you can profile your application and get results within minutes, without having to read a manual. Simply enter your settings and click the Start Profiling button. It's straightforward and there's no scripting involved.
You can start analyzing the data while it is still profiling, and you can view the profiling results in any way you like: a call tree, a call graph, or a grid.
- Detailed, clear results
You will get detailed yet easy-to-understand results, enabling you to quickly identify your performance bottleneck or memory leak.
- Good value
To keep things simple, the tool is not overloaded with unnecessary features. You do, however, get all the key features to help you get on with your job, but without the heavy price tag.
The call tree is dynamically updated to match the selection on the timeline.
- Zero in on problem code with the timeline
The timeline allows you to select a region of activity and view the data just for that region. In this way, you won’t be swamped with information when you are only interested in a particular spike in resource usage, or a specific event.
- Line-level timings
ANTS Profiler offers clear, detailed profiling results, with line-level timing, so you can quickly identify the specific lines of code which are affecting the performance of your application.
- Call tree
The call tree underneath the timeline displays the profiling results almost instantaneously after selecting a region on the timeline, and takes you straight to the heart of a performance issue.
- Call graph
You can create a call graph focused on any method of your choice, and visualize all the callers and callees for that method, and their contribution to its execution time.
Additional features available in the Pro version only:
- Method-level performance profiling (faster mode)
Additional and faster performance profiling modes are available in the Pro version. They record method-level timings (instead of both method and line-level data) and, therefore, introduce less overhead during profiling.
- Memory profiling
The memory profiler lets you take multiple snapshots at different times while your application is running, so you can compare application memory states. This feature is ideal if you need to investigate your application's memory usage, and locate memory leaks.
For more details about the key features of ANTS Profiler, please visit this page.
Developers working on complex applications often find themselves spending days, or even weeks, tracking bottlenecks down to their roots. A developer typically costs a company around $1,000 per day (with salary, employer's contributions, and so on). Considering that you can buy ANTS Profiler Pro for just $495 per license, you only need your developer to use the profiler once or twice per project to see a return on your investment.