logo

Troubleshooting and Debugging ​

Overview ​

Debugging is an art and a science, and at InnoGE, every developer finds their groove to iron out the issues. This section outlines some preferred tools and practices while leaving room for individual developer preferences.

Common Tools for Debugging ​

  • Laravel Debugbar: A useful package to profile and diagnose various parts of your application. It can help you quickly spot performance bottlenecks, SQL queries, and more.
  • Ray: A desktop app to display debugging information in a more elegant way. Ideal for real-time debugging and better than var_dump!
  • Dump, Die, Debug: Often abbreviated to dd(), this method is a quick way to output data from your code for inspection.
  • Xdebug & Step-By-Step Debugging: Some developers prefer a more meticulous approach by using Xdebug to debug line-by-line. This is especially useful for complicated issues where it's beneficial to trace the program's execution step by step.

Problem-Solving Strategies ​

Divide and Conquer ​

This is a systematic way to pinpoint the origin of a bug by breaking down the code into smaller parts and testing each one in isolation. This strategy can save you a lot of time, especially when dealing with complex codebases.

Example ​

Imagine you're working on a complex data transformation in a Laravel application:

php
$users = User::where('active', true)->with('orders')->get();
$filteredUsers = $users->filter(function ($user) {
    return $user->orders->sum('total') > 1000;
});
$finalOutput = $filteredUsers->map(function($user){
    return [
        'name' => $user->name,
        'total' => $user->orders->sum('total'),
        'latestOrderDate' => $user->orders->last()->date
    ];
});

You're getting an error in this process, but you're not sure where.

Step 1: Test the first segment.

php
dd($users);

Inspect the dumped result to ensure you're getting the expected set of active users with their associated orders. If there's an issue here, you've found your culprit. Otherwise, move to the next segment.

Step 2: Check the filtering process.

php
dd($filteredUsers);

Verify that you have correctly filtered users who have a total order value greater than 1000. If not, the issue might be with the sum calculation or the data you're working with.

Step 3: Inspect the final data transformation.

php
dd($finalOutput);

Here, you'll be checking if every user has the expected 'name', 'total', and 'latestOrderDate' attributes. If there's an error like "Calling last() on null", it might mean one of the users doesn't have any orders, so there's no 'last' order.

By following these steps, you've dissected a multi-step process into three separate segments, testing each in isolation. This makes it much easier to locate and address potential problems.

This strategy involves adding print statements at various points in your code to display variable values, function calls, or other significant milestones. While seemingly rudimentary, this method can be incredibly effective at pinpointing issues by tracking the flow of data and the execution of code paths.

Example ​

Consider a Laravel API endpoint that updates a user's information based on incoming data:

php
public function updateUser(Request $request, $id) {
    $user = User::find($id);

    if (!$user) {
        return response()->json(['error' => 'User not found'], 404);
    }

    $user->name = $request->input('name');
    $user->email = $request->input('email');
    $user->save();

    return response()->json(['message' => 'User updated successfully']);
}

Suppose the user is not getting updated correctly, and you're not sure why.

Step 1: Ensure the user is being fetched correctly. ​

php
dd($user);

If you see the correct user being dumped, that's not the problem. If it's null, then the given $id might be incorrect, or the user might not exist in the database.

Step 2: Check the incoming request data. ​

php
dd($request->all());

This will show you all the incoming request data. If the 'name' or 'email' keys are missing, it indicates the front-end might not be sending the correct data.

Step 3: Observe the final user object before saving. ​

php
dd($user);

By inspecting this, you can ensure that the data has been assigned correctly to the user object before it's saved.

The "print" method has been historically popular due to its simplicity and broad applicability across various programming environments. The term "Rubber Duck Debugging" comes from the idea of explaining your code or problem to an inanimate object, like a rubber duck. The act of verbalizing the issue often helps in identifying the problem.

Print debugging, while not the most sophisticated, is quick to implement and can be effective in a wide range of scenarios.

Seeking Help ​

Sometimes two heads are better than one. If you're stumped:

  • Reach out in the project-specific Slack channel.
  • Use the #need-help Slack channel to get perspectives from different team members.

Tips ​

  • Remember, smart debugging is about quality, not quantity. Instead of randomly trying things, think through the problem, form a hypothesis, and test it out.
  • Don't be hesitant to ask for help if you're stuck. Often a fresh pair of eyes can see what you might have missed.