What are some common debugging techniques and when to use them? (2024)

Key takeaways from this article

• Choose the right tool:

  Different debugging issues require specific tools; for example, kernel logs for signature issues or memory dumps for hardware problems. Selecting the appropriate tool can make debugging more efficient.

• Embrace rubber ducking:

  This quirky technique involves explaining code to an inanimate object, which can clarify your thoughts and uncover overlooked errors. It's a solo activity that sometimes brings out "a-ha" moments.

This summary is powered by AI and these experts

• Austin Kim Linux kernel Engineer | Author | RISC-V…
• Geoffrey Shera COO, Co-Owner, at Motus Design Group…

• Milap Patel Node.js | React | JavaScript | PHP | WordPress | Front-end | SASS | Mongodb | Laravel | Drupal | MySQL

  • Report contribution
  Print statements are a simple yet powerful debugging technique in programming. Developers use print statements to output specific values or messages to the console during program execution. This helps them understand the flow of the program, inspect variable values, & identify potential issues. Print statements are especially useful when dealing with loops, conditionals, or complex logic. By strategically placing print statements at different points in the code, developers can track the program's state & identify where unexpected behavior occurs. While print statements are effective for small to medium-sized debugging tasks, more complex or persistent issues may require advanced debugging tools or techniques.

  Like

  2

• Aliaksandr Kavalchuk Firmware | Embedded Engineer

  • Report contribution
  Perhaps it would be more correct not to delete print statements, but to customize the application build accordingly so that in the debug configuration these print statements remain and are turned off only at the release build

  Like
• Chibueze G. Software Engineer: C# || Asp.Net || .Net MAUI || Bootstrap CSS

  • Report contribution
  Debugging is an essential part of programming, and it can be challenging for newbies to overcome debugging issues. Here are some tips that can help:Reproduce the problem: Try to reproduce the problem as much as possible. Ideally, reduce the input to the minimum required to reproduce the issue.Examine what goes wrong: Once you have reproduced the problem, examine what goes wrong and list theories for where the bug may be.Debug one theory at a time: Examine one theory at a time by debugging that specific area of the code. Repeat steps as necessary.Work with a colleague: For complex debugging problems, it’s often helpful to work with a colleague.

  Like
• Geoffrey Shera COO, Co-Owner, at Motus Design Group Ltd.

  • Report contribution
  Print statements are great, but need to be used with awareness on the impact of system performance and memory. Resource constrained embedded systems with real time dependencies can be adversely affected by adding too many print statements hiding real problems. Good practice is to to use feature specific debug macros that generate a debug output. These can be enabled through a CLI, or if program space is limited through project configuration build time.

  See Also

  8 debugging methods you need to know aboutSoftware debugging Part 3: First principle approachWhat are some of the common challenges and pitfalls of debugging complex programs?8 Powerful Debugging Techniques for Embedded Systems

  Like

• Milap Patel Node.js | React | JavaScript | PHP | WordPress | Front-end | SASS | Mongodb | Laravel | Drupal | MySQL

  • Report contribution
  Breakpoints & stepping are advanced debugging techniques that allow developers to pause the execution of their code at specific points & inspect the program state. Breakpoints are markers set at particular lines of code, & when the program reaches a breakpoint, it halts, giving the developer an opportunity to examine variables & evaluate expressions. Stepping, on the other hand, involves executing the code one line at a time, allowing developers to observe the program's behavior step by step. These techniques are beneficial when dealing with hard-to-reproduce bugs, as they provide a detailed view of the code's execution flow. Developers often use integrated development environments (IDEs) to leverage these debugging features effectively.

  Like

  1

• Geoffrey Shera COO, Co-Owner, at Motus Design Group Ltd.

  • Report contribution
  Breakpoints & code stepping (step over, step in) are essential tools and should be learned well. With embedded systems, the code and debugging is very close to the hardware, so it important to consider effects of independent hardware features on what the memory or variable state is telling you (which is why print statements and buffer logs can be useful!) Features such as such as DMAs, UARTs, and other peripherals may continue to operate independent of core breakpoint and change memory information even when the code has halted. Creating a "trap" that only hits a breakpoint on specific conditions can allow additional code to disable peripherals if needed for stepping through.

  Like

• Austin Kim Linux kernel Engineer | Author | RISC-V | Arm | 4x LinkedIn Top Voice 🏆

  (edited)

  • Report contribution
  There are a lot of debugging tools for software engineers to utilize. One thing to consider is that there are no perfect debugging tools that provide human-readable information. It is better to find the right debugging tool that indicates relevant signatures about the issues. Considering the debugging level is important. For example, in Linux development:1) We can figure out the signature using the kernel log.2) Sometimes, we need to look at the ftrace messages of the Linux kernel to monitor the system at the kernel level.3) If the issue is related to hardware problems such as bit-flip, digging into the memory dump is necessary.We need to find the appropriate debugging tool depending on the complexity and level of the software issues.

  Like

  8

• Milap Patel Node.js | React | JavaScript | PHP | WordPress | Front-end | SASS | Mongodb | Laravel | Drupal | MySQL

  • Report contribution
  Debugging tools are particularly valuable when dealing with complex applications, as they offer a systematic and efficient way to locate and fix bugs. Developers should turn to debugging tools when issues are challenging to pinpoint through manual inspection or when they need a more comprehensive understanding of the program's runtime behavior. Leveraging these tools enhances productivity and facilitates a more structured approach to debugging, making it easier to identify and resolve issues in a timely manner.

  Like

  2

• Milap Patel Node.js | React | JavaScript | PHP | WordPress | Front-end | SASS | Mongodb | Laravel | Drupal | MySQL

  • Report contribution
  Debugging tools are essential for identifying and resolving issues in software development. Integrated Development Environments (IDEs) provide powerful debugging features that include breakpoints, variable inspection, and step-by-step execution. Developers can use these tools to trace the program's execution, analyze variable values, and understand the flow of control.

  Like

  1

• Geoffrey Shera COO, Co-Owner, at Motus Design Group Ltd.

  • Report contribution
  Speaking to debugging on embedded system, most vendors provide IDE's and hardware debuggers for working with their products. However, many of these products can also be used with open source compliers, GNU debugger, and open OCD debugger or a mix of GNU and vendor specific. The fun side of embedded debugging is developers have additional tools such as hardware logic analyzers, protocol analyzers, and execution trace hardware such as Segger JTrace. Software real time analysis tools such as Segger System view, VisualGDB can be essential for observing the interaction between real time tasks. Encapsulation of development tools in a docker container is also becoming easier as these virtualization technologies mature.

  Like

• Milap Patel Node.js | React | JavaScript | PHP | WordPress | Front-end | SASS | Mongodb | Laravel | Drupal | MySQL

  • Report contribution
  Testing and logging are crucial debugging techniques that contribute to robust software development. Unit tests, integration tests, and other testing methodologies help identify errors early in the development process, preventing bugs from reaching production. By creating comprehensive test suites, developers can ensure that different components of their code work as intended. Logging involves strategically placing messages in the code to record its execution flow and the values of specific variables. When an issue arises, developers can review the logs to trace the problem's origin.

  Like

  2

• Milap Patel Node.js | React | JavaScript | PHP | WordPress | Front-end | SASS | Mongodb | Laravel | Drupal | MySQL

  • Report contribution
  Testing is best used throughout the development process, particularly during code changes, while logging is essential when investigating unexpected behavior or errors in a live or production environment. These techniques collectively enhance code quality, identify issues proactively, and streamline the debugging process.

  Like

  2

• Geoffrey Shera COO, Co-Owner, at Motus Design Group Ltd.

  • Report contribution
  Unit testing is invaluable for quality code. Investment in time up front pays dividends later on. Having a deliberate plan of how your unit testing can work as part of your build process and identify broken features early. Modern embedded platforms Zephyr include unit test frameworks. Learning to use other frameworks such as CppU test can also be useful in embedded development. While it can be challenging to do unit testing for embedded systems, tools such as Renode can provide simulation of hardware to have a CI mindset. Logging is not useful without analytics. When developing logging output bear in mind how the log information will be consumed. An automated tool can be used to parse and identify useful fault or performance metrics.

  Like

• Geoffrey Shera COO, Co-Owner, at Motus Design Group Ltd.

  • Report contribution
  Rubber ducking is a very useful exercise. A strong company culture is needed for effective rubber ducking. Developers need the safety to be vulnerable and be allowed to talk through a problem that is often only obvious once it is needed to be explained to another developer. When doing this exercise, bear in mind not everybody has the same skills, experience or thinks the same way, so be kind and everyone may learn and enjoy the experience.

  Like

  3