What I Learned Building My First Go Project (go-reloaded)

During my first week at Zone01 Kisumu, I worked on a project called go-reloaded. It was my first real hands-on experience using Go, and it helped me understand not just the language, but also how to think like a developer.

In this article, I’ll share what I learned, the challenges I faced, and the key concepts that made everything click.

What the Project Was About

The goal of the project was to build a small Go program that works with command-line arguments and processes input using Go’s standard libraries.

This was my first time interacting deeply with:

• os package
• command-line arguments (os.Args)
• basic Go program structure

At first, it felt confusing, but step by step, things started to make sense.

What I Learned

1. How command-line arguments work in Go I learned that Go provides access to raw input from the terminal using: os.Args

This returns a slice of strings where:
os.Args[0] is the program name
os.Args[1:] are the actual inputs

1. Working with the os package The os package became one of the most important parts of the project.

I used it to:
Read input arguments
Handle program execution flow
Understand how programs interact with the system

This helped me realize that Go is very close to the system level compared to JavaScript.

1. Breaking problems into smaller steps One of the biggest lessons wasn’t about code—it was about thinking. Instead of trying to solve everything at once, I learned to:

Understand the problem first
Break it into smaller tasks
Solve each part step by step

This made debugging much easier.

Challenges I Faced

At the beginning, I struggled with:

Understanding how os.Args works
Knowing where to start in the code
Handling errors when inputs were missing

Sometimes I would get stuck just trying to figure out what the program was actually receiving.

But debugging helped me a lot. Printing values at each step made things clearer.

Key Takeaways

Go is very explicit compared to JavaScript
The os package is powerful for system-level interaction
Command-line arguments are simple but very useful
Problem-solving is more important than syntax
Debugging is part of learning, not a failure

Final Thoughts

This project was a big step in my learning journey. It helped me understand how Go works and how to approach programming problems more effectively.

I’m still learning, but each project is making things clearer.

Next, I’m looking forward to building more complex projects and improving my backend and DevOps skills.