We are fundamentally changing the nature of debugging. We know that bugs are inevitable, but believe that long
and painful debugging with endless log files and countless wasted hours is not. 

Cloud computing has transformed the face of modern computing. Now companies can save the cost of having own server by hosting the application of the clouds. With the advancement of cloud computing, the cost of software maintenance, deployment and hot fixing has really become cheaper than having sever on your premises. Although with the change in the computing scenario the challenges are also new. 

Production debugging is one of the challenges that companies are facing these days. Preventing these kinds of bugs from appearing is ideal. Ozcode is continually working in the direction of reducing the time taken to debug these kinds of bugs that arise during the production and other stages. The name ozcode may sound new to you, let me first give a brief introduction to the company. It is an Israeli startup that concentrates in providing debugging solutions. The company is funded by project investment company RDC and TPY of Israel. 

It is seen that almost fifty per cent of the time is wasted on debugging by a developer, the company plans to reduce the debugging time drastically. The company also visualizes the challenges developers faces to resolve the bugs in the production phase and the amount of cost the developing company has to face because of the bug in this stage. It is estimated that the exception initiated in the production phase is comparatively high than the bug found in the development or testing phase. The serious of the bug found in the production stage can be severe as it can cause damage of the product or even customer loss. 

Debugging during the production stage is very difficult and often leaves the developer to do the guesswork. But Ozcode’s cloud debugging is as friendly as local debugging. Ozcode has made investigating to a great degree simple for the engineers by pinpointing the correct moment of failure in the cloud computing. Ozcode likewise utilizes “pre-bugging” arrangement with the goal that the bug can be found and settled before they occur. 

The debugging extension of Ozcode can be experienced in Microsoft visual studio, Ozcode Azure Devop is its latest presentation that can be availed through Microsoft Azure cloud. 

Production debugging with Ozcode 

Production debugging begins at the production stage. This the phenomenon that appears when any failure or exception happens in the application. This can be detected with tools various tools available. These tools give the details of the exceptions that had occurred, which helps the developer to resolve the issue. 

Ozcode works a bit advance by integrating with these tools and taking a snapshot at the time of failure and displaying them in the debugger, which acts similar to an IDE. 

Debugger-as — a — service platform has some more added advantages as it allows time travel debugging, in which a developer can create “ what if” scenarios and can make live changes in the code while sitting in the browser, this thereby eliminates the trouble of taking the application to the local machine then debugging and then deploying it to the cloud. 

At the end of the day, we can state Ozcode has transformed the experience of debugging by giving it a feel of working in the local machine while working in their IDE. 

Perceptions from Azure Devops 

For the cause of production debugging, Azure Devop extension is needed for the installation of Ozcode. 

After Ozcode gets installed, it will integrate with the application it will gain insights into Azure subscription and will add debugging abilities for the production. 

• The developers will get full detailsof failure starting from the dateof occurrence, type of exception, occurrence number and the number of users who got affected by the failure. 
• It creates a debugging session for the failures.
• The debugging session that got created is then assigned tothe Azure board work items.

One more feature of Ozcode is in addition to production debugging it allows the managers to manage the failures effectively. 

Creation of a debugging session 

With Ozcode you can create a debugging session in several ways: 

• Visual studioextensionof OZcode. 
• From Application insight for failure.
• From dump files that were captured during production.

Sharing a debug session is similar to sharing a file on OneDrive or DropBox, it is very secure and can be safely shared within your organisation and even with your Azure Devop team and Devops solutions provider. 

After sharing the session, anyone can comment on the file the scenario is much like whatsapp group chat. The session allows you to comment on a particular variable value so that the person reading the chat understands what the root cause of the exception is. One more advantage of this debugging session is that you can make the variations to your code and see the results. The changes that you make can be saved as a code fix proposal, that can be viewed by other team members, and they can comment on it. 

Ozcode has made the debugging session as a combination of pull request and visual studio share for production debugging. 

Debugging with visual studio 

Ozcode debugger is mainly focused on providing a platform for production debugging and root cause analysis of an exception and is equally helpful for collaborative debugging. This is extremely useful for cloud computing scenario as it can save your teams time. It is extremely useful for dealing with regressive bugs. 

If your developers have Ozcode extension, then he can easily share the debugging session from visual studio. 

The debugging session can be shared with the people with whom you want to share within your organization, can be attached to the Azure Board work team and can also be used for collaboration and debugging. The debugging session has the advantage of revisit, which can be helpful for the developer if any regressive exception pops up, he can revisit the interactive session and can gain an instant understanding about the bug, its root cause and how it got fixed. 

Supporting languages 

Presently the ozcode cloud debugging is available for C# for dot net framework and dot net core. They are deciding for JavaScript and TypeScript presently. 

Redaction of information 

The challenges a developer may face while doing Production Debugging is securing the personally identifiable and sensitive information. But in the case of Ozcode debugger a developer cannot download the memory dump and any sensitive information stored in it. Instead, it displays the debugging history through a browser-based debugger window that supports redaction. The debugger was designed keeping all the constraints in mind. The project administrator of Azure Devop can control the information that needs to be redacted. 

Security 

Security holds the foremost importance, and security during the production debugging cannot be taken lightly. The production debugging with ozcode cloud debugging have given the topmost priority with an end to end safety. 

Conclusion: 

This new debugging tool will make production debugging faster and more productive than it was thought before. Some of the patented debugging technology that the customers of Ozcode will experience are discussed as under: 

• The developers can enjoy interactive debugging in the browser itself.
• Security is given the topmost priority while debugging
• The developer can practiceoriginal time-travel debugging.
• Developers can retrieve the failure codeor dump instantly from the source code. There is absolutely nothing toworry about the pdbs. 
• Collaborating with the team about the exception can happen by sharing, commenting, links tothe specific exception and proposal tochange the code. 
• It can alsogenerate code automatically tocreate a unit test for a production scenario. 
• For production debugging, redactionof PII is incorporated.

In short, we can say the features of Ozcode includes redaction of personally identifiable information, live coding & instant verification, dumps analysis, automatic testing of production user cases and is fully traceable. 

-OzCode is an innovative debugging extension for Visual Studio, developed by CodeValue, that provides a set of powerful debugging tools. CodeValue provides high quality added value services and software product development.

CodeValue’s experts are internationally acclaimed technology experts, known for their deep knowledge and experience. They are reputable professionals with many years of experience in various technologies, known within the software development community and recognized by leading software vendors. Among CodeValue experts, one can find a Microsoft MRD (Microsoft Regional Director), several MVPs (Microsoft Most Valuable Professional) and many other highly qualified individuals.

Our professionals are known for their constant learning aptitude and for being early adopters of new and advanced technologies.OzCode emerged from these unique skillsets and is proudly introduced here. OzCode is an innovative C# debugging extension for Visual Studio that was originally initiated by experienced programmers, wanting to accelerate and improve their day-to-day debugging work of programmers using Microsoft Visual Studio™.

Over its lifetime, OzCode matured to become a real booster of developer productivity and code quality.

Ozcode – Enterprise Edition Features :

LINQ Debugging – Ozcode elevates LINQ with debugging tools that allow you to gain visibility, clarity and insights into your debugging process. 

• Numeric Indicator – See how many items passed through the LINQ operator. Quickly notice when things go wrong & easily decide how to move forward. 
• LINQ DataTip – See the items a given operator has produced. Change your LINQ query and see the new results instantly to understand how it affects your code. 

• LINQ Analysis Window – Easily navigate the LINQ pipeline and visualize the flow of the LINQ query. 
• Predict Exceptions – Ozcode will warn you about a LINQ exception before it is even thrown in the middle of a convoluted LINQ query. 
• Both LINQ Syntaxes Supported – Full support for lambda-based API, or the SQL-like query expressions. 

Become exceptional at handling exceptions – With an advanced ability to understand exceptions and drill into inner exceptions and complicated callstacks, your coding skills become better than ever. 

• Exception trail – View all relevant exception information in a handy tool-window. Navigate through each inner-exception with a user-friendly breadcrumb control and a fully interactive StackTrace navigator. Launch a Google or stackoverflow search right from within Visual Studio. 

• Exception predict – Get alerts about exceptions that are about to happen. Pinpoint the expression that’s about to cause the exception. 

Never Use F10 Again :

• Time travel to the future – Allows you to predict how your code will execute, detect and fix bugs, travel across loop iterations and pinpoint the exact moment of failure without stepping over code. The heads-up display feature illuminates what the code execution is actually going to look like as you are stepping through the code. 

An eye-opener for your code – Ozcode’s Heads-Up Display offers powerful and simplified visualization so you can instantly figure out exactly what is happening in your code. 

• Red-Green Boolean Visualization – Gain amazing insight into every line of code as you step through it. Break down & understand complicated boolean logic, at a glance. 

• Explore Code History – See a historical view of your code’s execution. You will no longer have to restart debugging if you’ve Stepped Over too far. 

Discover quick and easy ways to find what you’re looking for – With all new span data tip tools 

• Reveal – Focus on the data that actually matters: star the properties you are interested in to customize an object appears in the debugger. 
• Search – Quickly and effortlessly search member names and values, regardless the size of the collection or complexity of the object graph. Immediately find that needle in a haystack! 
• Conditional Search – Search a collection, according to a custom predicate from logical expressions to whatever complicated logic you have in mind. 

• Custom expressions – Customize the way an object is shown in the debugger by adding a calculation upon that object, which will be displayed just like any other member of that type. 
• Export (Instant Unit Test) – Grab objects and save them as JSON, XML or C# code. Create Unit Tests from objects you see on a breakpoint to create a quick repro of the same exact scenario in a test! 
• Compare – Easily compare objects and collections in memory, like a diff viewer for the debugger! Compare local variables or take a snapshot to compare the same object across different points in time! 

The next generation of logging 

• Tracepoints – By adding tracepoints for dynamic logging on-the-fly at key points during the program’s execution. View traces in the editor’s trace viewer to understand where things went wrong. Easily diagnose complicated multi-threaded bugs by analyzing a linear log of execution, right from within Visual Studio. 

Tap the hidden power of breakpoints – Use conditional and when..set breakpoints to solve the most complicated bugs with unmatched ease and clarity 

• When Set… Break 

Conditional Breakpoints 

• Set up a Conditional Breakpoint based on a specific property value, and pre-fill the predicate for you. 

Lightening Fast Attach to Process 

• Process Attach – Pick from the list of most recent processes. Pin processes to assign a shortcut key to instantly attach to the same process without going through a slow dialog. Get work done faster. 

Take the ultimate shortcut with Contextual Quick Actions 

• Contextual Quick Actions – Versatile, intuitive and capable: the quick actions menu offers you the most relevant actions, depending on what you want to do. 

Find more, faster 

• Show all instances – With “Show all instances”, you can effortlessly find specific objects in memory. Easily find any objects that contain a specific value, and find out why they’re still there. 

• Time travel, stepping backward and forward through the code execution flow with radical observability to determine the root cause of the error for a rapid resolution  
• Do an effective root cause analysis without having to search through endless log files  
• Autonomously capture and record errors with all relevant information including variable and function values, network requests, database queries and more, in a single shareable link without attaching a debugger. No need to touch running code 

Major Features Of  OzCode:

• Head-Up Display : 
  • Explore History : The nicest thing about Simplify is that you can see a historical view of your code’s execution. Each time you Step Over (F10) a line of code, a new Simplify button  will appear, allowing you to look into the past! No longer will you have to restart debugging if you’ve Stepped Over too far!Simplify Time Travel Keyboard Shortcuts If you’re a keyboard person, we’ve made some useful shortcuts for you to time travel without lifting your palms: Hit to visualize the current line and then use to visualize the current line or  to navigate between the different lines of code.You can also hold down the key while debugging and then tap a digit to directly pick the statement to visualize.
  • Magic Glance : The Magic Glance, which can be toggled by clicking the Toolbar icon  (or by pressing the  shortcut), gives you amazing insight into your code by showing you a summary of each line of code you stepped through.
  • Live Coding : Predict brings a new meaning to the term “Living Coding” by giving you instant feedback on changes you make as you’re debugging, allowing you to fix silly little coding mistakes extremely quickly.

• Quick Actions : OzCode’s Quick Actions offer you the most relevant actions, depending on your current context. Want to add a breakpoint to every method in the class? Trace every entry to a particular method? Quickly run forward to a particular line of code? Hit Alt+Shift+D to open up the Quick Actions menu or click the Magic Wand, and do some magic!

• Search : When debugging objects and collections, you are often looking for a specific property or field, or a value held within a property or field. Unfortunately, this usually involves either a lot of clicking and scrolling, or writing custom debug-specific code. Finding items even in simple structures is not easy, not to mention doing so in a complex object graph. With our “Search” feature, this is no longer the case. Quickly and effortlessly search member names and values, no matter the size of the collection or complexity of the object graph!

• Filter Collections : Filtering a collection in code is relatively easy and there are plenty of ways to do it. But how do you filter while debugging? For example, you have a collection of Customer objects and you’d like to filter the ones that are older than 35 years. Visual Studio’s immediate window and watch windows don’t support lambdas.