COP3504C Lab 05: Debugging and Git Tutorial for Software Engineering

Introduction to Debugging and Version Control

In the world of software engineering, two skills stand out as absolute essentials: debugging and version control. Whether you're building the next viral app or analyzing data for a school project, knowing how to efficiently find and fix bugs—and how to collaborate with others without losing your mind—can make or break your success. This tutorial is designed to help you complete COP3504C Lab 05, where you'll use PyCharm's debugger and practice Git workflows. By the end, you'll be able to set breakpoints, inspect variables, handle merge conflicts, and push code like a pro.

Why Debugging Matters: A Real-World Analogy

Imagine you're playing the latest battle royale game, and your character suddenly freezes mid-match. You'd check your internet connection, update your drivers, or restart the game. Debugging is the same process—but for code. In software, a bug can be as subtle as a misplaced semicolon or as complex as a race condition. Tools like PyCharm's debugger let you pause execution, inspect variables, and step through code line by line, just like a detective examining clues. This lab will teach you to use breakpoints, the watch window, and the stack trace to solve problems efficiently.

Part 1: Debugging in PyCharm

Setting Breakpoints

Breakpoints are markers you place in your code to pause execution at a specific line. In PyCharm, click the gutter next to a line number to add a breakpoint. For example, if your previous lab solution had a function that calculates averages, place a breakpoint inside that function to inspect its inputs.

def calculate_average(numbers):
    total = sum(numbers)  # Breakpoint here
    return total / len(numbers)

When you run the debugger (click the bug icon or press Shift+F9), the program will stop at the breakpoint. You can then examine variables in the Variables pane.

Using the Watch Window

The watch window lets you evaluate expressions that aren't directly visible. For instance, if you want to see the result of len(numbers) without modifying code, add it to the watch list. Right-click in the watch window and type the expression. This is especially useful when debugging complex conditions, like checking if a list is empty before division.

Exploring the Stack Trace

When an exception occurs, the stack trace shows the sequence of function calls that led to the error. In the debugger, you can view the stack trace in the Frames tab. Click on each frame to see the state of variables at that point. This helps you trace back to the root cause of a crash, similar to rewinding a video to find where a glitch started.

Practical Debugging Exercise

Open your previous solution (e.g., analyzer.py) in PyCharm. Set a breakpoint at the beginning of the main function. Run the debugger and step through the code using Step Over (F8) to execute line by line. Use Step Into (F7) to enter function calls. Note how the variables change. If you encounter an error, the stack trace will highlight the exact line. Practice until you feel comfortable navigating the debugger.

Part 2: Version Control with Git and GitHub

Version control is like a time machine for your code. It allows you to track changes, revert to previous versions, and collaborate without overwriting each other's work. Git is the most popular system, and GitHub is a cloud hosting service. In this lab, you'll set up a repository, convert your Java solution to C++, and resolve a merge conflict.

Setting Up Git and GitHub

First, install Git from git-scm.com. Create a GitHub account using your school email to get the GitHub Student Developer Pack at education.github.com. This gives you free private repositories and other tools.

Complete the interactive Git tutorial at try.github.io to learn basic commands like git add, git commit, and git push.

Creating a Repository and Cloning

On GitHub, create a new empty repository named cop3504c-lab05. Add a README.md file with a description. Then, clone it to your local machine:

git clone https://github.com/yourusername/cop3504c-lab05.git
cd cop3504c-lab05

Converting Java Solution to C++

Your previous lab solution was in Python (or Java). For this lab, you need to convert it to C++. If you had an analyzer.py that reads data and computes statistics, write an analyzer.cpp that does the same. Use std::chrono::system_clock::now() to measure execution time. Here's a snippet to get started:

#include <iostream>
#include <chrono>

int main() {
    auto start = std::chrono::system_clock::now();
    // Your analysis code here
    auto end = std::chrono::system_clock::now();
    std::chrono::duration<double> elapsed = end - start;
    std::cout << "Elapsed time: " << elapsed.count() << "s\n";
    return 0;
}

Adding, Committing, and Pushing

Add your new file and commit:

git add analyzer.cpp
 git commit -m "Convert analyzer to C++"

Now push to GitHub. If you're working with a partner, the first push will succeed. The second push (from your partner) will fail with a merge conflict because the remote has new changes.

Resolving Merge Conflicts

A merge conflict occurs when two people modify the same file. GitHub will mark the conflicting sections. Open the file in an editor; you'll see markers like <<<<<<< HEAD, =======, and >>>>>>> branch-name. Edit the file to keep the correct code, then remove the markers. For example, if both partners added a different function, you might merge them together. After resolving, add and commit the merged file:

git add analyzer.cpp
 git commit -m "Resolve merge conflict"
 git push

If you use a merge tool like Meld, it provides a visual interface to compare changes. Configure SourceTree to use Meld as the external diff tool.

Forking and Making the Repository Private

After both partners have pulled the resolved changes, the student who doesn't own the repository should fork it on GitHub. Then, each student should go to the repository settings and change visibility to Private. Add your lab instructor as a collaborator so they can view your work.

Best Practices for Debugging and Git

Use descriptive commit messages: Instead of "fix bug", write "Fix off-by-one error in loop condition".
Commit often: Small, frequent commits make it easier to track changes and revert if needed.
Test before pushing: Run your code locally to catch errors before sharing.
Learn command-line Git: While GUI tools are helpful, understanding the command line gives you more control.

Conclusion

Mastering debugging and version control will save you countless hours and make you a valuable team member. In this lab, you've practiced using PyCharm's debugger to identify issues and Git to collaborate seamlessly. These skills are directly applicable to real-world projects, whether you're contributing to open-source software or building a startup. Keep practicing, and soon debugging and Git will become second nature.