Have you heard the news? New productivity tools have Just™ arrived, and it turns-out good things come in twos! JustTrace and JustDecompile have just been revealed and the betas are immediately available for download.

JustTrace is a performance and memory profiler which can profile .NET 2.0+ (both web and desktop) and Silverlight applications.
JustDecompile is a free tool which can decompile, and browse .NET assemblies.

Continue reading to find what sets these two new tools apart from other profiling and decompiling tools available today.

JustTrace

When we started developing JustTrace we had a strong vision of what to include in the first version and where we couldn’t make any compromises.

1. We knew that we must deliver three types of profilers from the start: Sampling, Performance, and Memory
2. We knew that JustTrace had to be easy to use from Visual Studio
3. We knew that we should set a new benchmark in profiler performance
 
Profiler Types
 
From the outset, JustTrace has been designed to provide three distinct profiling modes:
1. Sampling Profiler – Dumps the call stacks for all threads at regular intervals (more lightweight)
2. Performance Profiler – Collects CLR events when entering/leaving methods (more accurate)
3. Memory Profiler – Collects raw CLR memory usage data
 

 
Each profiling option provides different views of the profiled application. Sampling Profiling is the fastest option that has the least impact on the run-time performance of the app being profiled, but that speed comes at the expense of some accuracy. Performance Profiling, meanwhile, improves profiling accuracy by watching an application’s execution full-time, but that has a noticeable effect on the target app’s runtime performance. Finally, whereas Sampling and Performance focus on method timing, Memory Profiling provides a view of an apps memory usage.
 

Live Data

When profiling with the Sampling or Performance  profilers, JustTrace provides a "Live Data" view that is updated on-the-fly with the latest data collected from the profiled application. Here you can see real-time how your application is calling different methods. The data provided in the “Live Data” view makes it easy to determine the best time to capture a profiling snapshot.


 

Attach to Running Process

Memory leaks and performance issues are often only observed after an application has been running for some time. With JustTrace’s ability to Attach to a Running Process, you can quickly start profiling without being forced to start the process from scratch and trying to reproduce the steps that create the problem. It’s a huge time saver and useful way to quickly squash memory leaks.

With the beta release you can only attach the Sampling Profiler to running .NET 4.0 processes, but we plan to provide the same functionality for the Tracing and Memory profilers as well.


 

Visual Studio Integration 
 
We made it very easy to use JustTrace with Visual Studio.  Once installed and enabled, just press F5 (to run with debugging) or CTRL + F5 (to run without debugging) and you're automatically provided with a simple window to choose which JustTrace profiler to use.

 


And that's it, no additional settings are needed! The information collected by the profiler provided in a native Visual Studio tool window once the application starts. Profiling doesn’t get much easier than that!

 

 
Profiling Child Processes
 
An application can often involve multiple processes. JustTrace makes it easy to profile the main process as well as all potential child processes. Simply check a box when launching the Sampling Profiler and JustTrace will handle the rest.

 

 
Profiling Performance

 
Performance is one of the areas we decided we could not make any compromises. If you're tired of profilers which make the profiled application so slow that it's almost impossible to use, if you need to go and get a cup of coffee every time you get a profiler snapshot, or if saving the snapshot takes the same amount of time as installing the latest Windows updates, then you should definitely try JustTrace.

Performance will remain a key focus beyond the beta. The goal is to make the first official version of JustTrace the fastest profiler available for .NET developers, so you can spend more time understanding your profiler data and less time waiting for it.
 
RadControls in Action
 

In JustTrace we've taken full advantage of RadControls for WPF to provide tools that make it easy to sort and filter the profiler data. Quickly zero-in on the methods and types that matter to you.
 


What's next?
 
Today we are releasing the JustTrace Beta. We plan to release the first official version of JustTrace with the Q2 release this summer and along with polishing and fixing issues, we will add new features like comparing snapshots, drill down in a particular node, more views, integration with JustCode and more. As always your feedback on this new product is most welcome, so give the beta a try and let us know what we can do to make this the best profiling experience for .NET.

 

JustDecompile

The first thing to mention about JustDecompile is that it's free. It's free not as in "free lunch" but as in “it's really free, it will stay free and you won't see us on youtube explaining why we decided to make it a paid product.” This is true for the beta and for all versions shipping in the future.

Of course the fact that we've made a free product is not the only thing that makes us proud. With JustDecompile, we went back to the drawing board to think about how a modern assembly browser and decompiler should work. We’ve incorporated innovations found in JustCode, such as powerful code navigation, and create a new decompiling tool that we hope will become the new standard for every .NET developer toolbox. Here are some things you’ll find in this first beta:
 
Fast Code Navigation
 
Simple search boxes are great, but JustDecompile goes beyond the simple box to provide powerful tools for searching code members. Based on the code navigation in JustCode, JustDecompile provides dialogs that let you quickly navigate to symbols and types. Simply type the name of the object you’re looking for, or take advantage of the same CamelCase search available in JustCode, which allows you to type the camel case letters to find a type or namespace (for example, “SR S.I” would show results like StringReader in namespace Sytem.IO).


 
Side-by-Side Assemblies
 

Have you ever wanted to quickly disassemble and look at the code from different versions of the same assembly? Until now, this often required unloading one assembly, then reloading the next. With JustDecompile, you can easily load assemblies from different frameworks or assemblies with the same name side-by-side.

The JustDecompile navigation tree provides handy visual cues to help you distinguish assemblies targeting different frameworks. 


 
Easy Assembly Management
 
Getting the assemblies you want to browse loaded has always been more difficult than it should be! JustDecompile finally does it right. You can quickly load the core framework assemblies for .NET 2, .NET 4, and Silverlight with a single click. 


 

You can also create Assembly Lists, which are saved configurations of assemblies you have loaded with JustDecompile. Use Assembly Lists to quickly load or switch between preferred configurations when working on different project, or create an assembly list for your favorite tools vendor. And since JustDecompile lets you easily clear your assembly list with a single click, you’ll be able to unload and load lists with minimal effort.


 
Rich, WPF UI
 

JustDecompile features a WPF UI with a XAML-based Code Viewer that let’s use easily find usages and zoom-in and out on code.


 
Universal Find Usages
 
When JustDecompile analyzes code, it provides results in a unified and easy to browser Find Usages dialog (another piece of JustCode that has been integrated in to JustDecompile). Rather than taking multiple steps to find “used by” usages or “instantiated by” usages, JustDecompile shows it all in a single step.

To find usages, press the CTRL key and click with the left mouse button on a type or member in the code tree view or directly in the code viewer. You’ll get a list of all usages and a preview of the exact line of code where the usage takes place. You can also group the results by different criteria.

 

 
Decompiled Code Quality
 

For the first beta release, we've tried to cover most of the language features such as generics, auto properties, lambda expressions, yield return and yield break and so on, but it is a beta. We will be prioritizing any issues with decompiling during the beta, so if you find something that is decompiled incorrectly, let us know and we’ll fix it promptly.

What’s Next?
 
This is an early preview of JustDecompile, but we have many exciting plans for this free tool. It will join the rest of the Telerik developer toolbox and get regular, 3-release per year updates. JustDecompile is also capable of auto-updating, so we’ll be shipping updates as they’re ready to keep making the JustDecompile experience better. The first official release will be with the Telerik Q2 wave this summer.

For now JustDecompile only decompiles to C# code, but we will add VB.NET support in the near future and other languages (like IL) after that. We will also be focusing heavily on optimizing performance after this beta, so stay tuned for regular updates leading-up to the official release. For now, try-out the new functionality JustDecompile provides and let us know if you like this new and improved approach to assembly browsing!

 
Hope this information helps. Have a great and productive day!
 
Download JustTrace and JustDecompile Betas
 
JustTrace Official Feedback Forum
 
JustDecompile Official Feedback Forum


About the Author

Hristo Kosev

 

Comments