Dockerfile.tar.gz

Crash

Hang

Mem-Leak

spa2

Python

Go-queue-repro

Python-logging

Go-hang

C-program

SPA-malloc-C

memory-monitoring

Python-otel

Go-with-mod-tidy

spa2-copy

SPA-dns

This course covers debugging and the different techniques that help developers efficiently trace bugs in programming. It also includes guidelines and tips for software developers who must debug applications in production environments. 

You’ll start with introductory concepts of bugs and their life cycle. Next, you’ll cover the basic debugging techniques such as tracing code paths, reproducing the issue, logging, and knowing what to chase. In the next section, you’ll learn debugging techniques for multithreaded applications and the art of finding bugs in crashes and hangs. By the end of the course, you’ll gain knowledge about scaling issues, troubleshooting environments, monitoring, and building debuggable systems.

After completing this course, you’ll have detailed knowledge of debugging and its different techniques. It will also help you enhance your debugging skills, which are applied throughout the life cycle of software development.

Mastering Debugging: Techniques for Efficient Code Diagnosis

A control flow graph is a visual representation of a program's control flow. 

A control flow graph represents the program's flow from design, implementation, and QA testing.

A control flow graph can be used to understand the code base.

Control flow graphs apply to object-oriented programs only.

**(Select all that apply.)** Which option is *true* about the control flow graph? 

(Select all that apply.) Which option is true about the control flow graph?

A debugger offers advanced capabilities that make traversing through code paths easy and effective.

All debuggers are general-purpose and can be used for any programming language or platform.

Using debuggers can improve product quality and ease of maintenance.

Which option is *true* about tracing code paths with a debugger?

Which option is true about tracing code paths with a debugger?

It is possible to add more logs and change the code to make debugging easy. It is also easy for the debugger to go after issues in a local setup, which reduces turnaround time.

It is easy to pinpoint the erroneous code paths for an internally reproduced issue.

Internally reproducing an issue makes debugging easy by lowering the cost of debugging. 

Regardless of the bug’s nature, its symptoms are readily visible, making it easy to get after it.

How does reproducing an issue make it easy to debug it?

How does reproducing an issue make it easy to debug it?

Logging at various levels based on the log statement's significance is not essential.

Logs are a self-commentary of what a program or process is doing.

 It is not essential to include when, who, how, and why a particular event is seen in the logs.

Sensitive information like usernames, passwords, etc., must not be included in the logs.

**(Select all that apply.)** Which option is *true* about logging? 

(Select all that apply.) Which option is true about logging?

Large objects can cause a lot of memory to serialize and occupy a lot of space in the logs.

The user-agent who initiated a request being processed. 

The thread ID of the thread that printed the log statement.

What is best to avoid being printed in the logs?

What is best to avoid being printed in the logs?

When writing log statements in the code, the programmer must only worry about the information they might need when debugging. Considering the storage space the logs might occupy is not the programmer's problem.

The time covered by logs is limited by the storage space they occupy.

Log levels are a way to create more space where logs are stored.

Logs are best stored in temporary storage space in a RAM disk etc., which don’t persist across reboots.

Which statement is true?

Which fields in the logs can be most handy when debugging multithreading issues?

Which fields in the logs can be most handy when debugging multithreading issues?

Check if Paypal APIs have any issues. Invoke all PayPal APIs involved in the internal payment APIs and check for errors.

Peruse the recently checked-in changes in the payment management system in the related code paths that talk to PayPal's APIs that might explain the symptoms.

Check for any network-related issues, as it could be that the requests made are not reaching PayPal's API endpoints.

Check if the legacy libraries that talk to PayPal are doing the right thing.

The payment management system was recently updated after which, PayPal payments are not going through. What would be a reasonable course of action?

The payment management system was recently updated after which, PayPal payments are not going through. What would be a reasonable course of action?

If the library was recently upgraded to the latest version.

It has been determined that the most recent changes to the code are not the reason for the bugs seen.

When it is not clear which subcomponent of the code is causing the issue.

A recent change was made that upgraded the external library along with new code that uses these libraries.

When is it right to suspect external libraries or code when debugging?

When is it right to suspect external libraries or code when debugging?

The hardware or external APIs needed to reproduce the issue might be exorbitant.

The environmental idiosyncrasies where the issue is seen can be tough to recreate elsewhere except in the customers.

The nature of the issue can be such that it is not always reproducible, e.g., race conditions.

The product's usage and load pattern encountered by a customer is usually the same, difficult to describe, or exactly reproduced in another time and environment.

**(Select all that apply.)** What are the reasons a bug may not always be reproducible?

(Select all that apply.) What are the reasons a bug may not always be reproducible?

Test yourself on the knowledge you learned about basic debugging.

Introduction to Debugging

Bugs Life Cycle

Basic Debugging

Multithreaded Debugging

Code Reading

Crashes and Hangs

Resource Leaks

Debugging Distributed Systems

Scaling Issues

Troubleshooting Environments

Principles for Proactive Product Maintainability

Conclusion

Quiz: Basic Debugging