Debugging is part of any development process, but unfortunately it’s never planned or expected. On top of that, it’s rarely approached in a structured way, and while many modern IDEs have powerful debugging tools – most developers are not aware of how they can be used to reduce the time and pain of debugging. The whole act of debugging is done as an ad-hoc, time consuming activity, which is considered less interesting then developing new features or investigating the latest and greatest technology. But while there are many articles and productivity tools aimed at writing better code – faster, it seems as though it’s impossible to find resources that teach you how to effectively debug your code. In this lecture, we will discuss how to approach a debugging session, and show the latest power debugging capabilities Visual Studio has to offer. These will help you save time and pain by first understanding the problem and then fixing the bug that caused it.

1. Debugging with Visual Studio Beyond ‘F5’
Dror Helper (@dhelper)

2. About.ME
Consultant & software architect @ Practical Software
Developing software since 2002
Clean Coder & Test-Driven Developer
Pluralsight author
Blogger: http://helpercode.com
Twitter: @dhelper

3. Why I hate debugging:
It’s never
planned
Usually
complicated
Extremely
frustrating
Tend to be
stressful
Always time consuming

4. Why debugging consumes so much
time?

5. There are 0b10 types of developers

6. A practical approach to debugging
1. Reproduce the problem
2. Get to where the issue happens
3. Analyze the system state
4. Create hypothesis
5. Fix the bug
6. Verify your solution
7. Celebrate

7. Reasons to use the debugger
Gather
information
Prove
hypothesis
Check solution

8. Reproduce the issue
Is it reproducible?
Is it reproducible on my machine?
What input caused the problem?
When was the last time it worked?
Answer those questions before continuing to the next step!

9. Get to where the issue is
How to waste time:
- Not knowing where we’re going
- Running through all the code
- Multiple reruns + long startup time

10. Immediate
window
Exception
thrown
Breakpoints
Who can help us get to the bug

11. Immediate window
debug and evaluate expressions
execute statements
print variable values

12. Stop on exceptions
We can tell Visual Studio to break whe
- An exception is thrown and not handled
- An exception is thrown
* Reduce noise using exception type

13. Breakpoints
Pause execution
So I can inspect my code
• Always
• Conditional
• Trace*
• Data (VS2019)

14. Data breakpoints
New in VS2019
.NET Core 3.0 only!
Value must be on the managed heap

15. Gathering information
Understand all the information
Don’t waste time traveling your code
Quickly find relevant information

16. Learn to use your keyboard
Reduce mental overhead
Debug naturally

17. Tracepoints
Special kind of breakpoint
Log information instead of stopping
Use text and existing variables

18. When to use Tracepoints
Huge data + iterations (LINQ)
Multi-Threading
Sync issues (up to a point)

19. Visual Studio’s tool windows
Simple – Stack, Watches, Exceptions, Breakpoints
Advanced – Tasks, Threads, Modules

20. Make Object Id
Distinguish between different instances
Track an object even if it’s out of scope

21. Debugging parallel code
Tracepoints for ad-hoc logging
Tasks/Threads to find Blocked/Deadlocks
Parallel Stacks to understand flow

22. Parallel Watch
22

23. Parallel Task & Parallel Stacks
View the logical call, the logical call stack and the task/thread state

24. Understanding your data
Use Make Object Id to follow specific instances
Search for objects and properties in Watch windows (VS019)
Format how your data is displayed
- ToString
- DebbugerDisplayAttribute

25. Edit & Continue during Fix – Build – Run cycles
Immediate window to avoid crash on exception
Edit values to for and prove hypothesis
Avoid restarting your debugger

26. Edit & Continue
Make sure Edit and Continue is enabled!
Check list of supported/unsupported changes
https://github.com/dotnet/roslyn/wiki/EnC-Supported-Edits
... Or just try and find out

27. What we’ve learnt
Reproduce Analyze Hypothesis Fix Verify
Better debugging
Using Visual Studio capabilities
A structured process of finding and eliminating bugs

28. Dror Helper | @ dhelper | http://helpercode.com
Thank you!