Go? Where am I Going?

When I first heard about Go (or Golang), I thought it was just another programming language trying to compete with the giants like Java and Python. Little did I know that this journey would completely change my perspective on backend development and concurrent programming. From mid-June to the end of July 2025, I embarked on an intensive learning journey through GeeksforGeeks limited free course guided by Ashwin Kulkarni, and what I discovered was a language that's not just powerful, but elegantly simple.

This is the story of my Go journey - from curiosity to competency, from "Go? Where?" to "Go! Let's build something amazing!"

Introduction to Go: The Language That Changed Everything

Go, also known as Golang, isn't just another programming language - it's a paradigm shift in how we think about software development. Created with simplicity, efficiency, and scalability in mind, Go has become the backbone of modern cloud infrastructure and enterprise applications.

What makes Go special? It's the perfect balance between the performance of compiled languages like C++ and the ease of use of interpreted languages like Python. But more than that, it's designed for the modern world - a world where applications need to handle thousands of concurrent users, where microservices architecture is the norm, and where developer productivity is paramount.

// The classic "Hello, World!" in Gopackage mainimport "fmt"func main() {fmt.Println("Hello, World! Welcome to Go!")}

Simple, clean, and to the point - that's Go in a nutshell.

The Genesis: Why Go Was Created and Who Built It

Go was born out of frustration - the good kind of frustration that leads to innovation. In 2007, three brilliant engineers at Google - Robert Griesemer, Rob Pike, and Ken Thompson - were tired of the complexity and slow compilation times of existing languages used for large-scale software development.

The Creators

Ken Thompson - Co-creator of Unix and the B programming language. A legend in computer science who brought decades of systems programming experience to Go.

Rob Pike - Co-creator of UTF-8 and Plan 9 operating system. His vision for simplicity and clarity shaped Go's design philosophy.

Robert Griesemer - Worked on Google's V8 JavaScript engine and Java HotSpot virtual machine. He brought expertise in language implementation and optimization.

The Problem They Solved

Google was facing challenges with their existing codebase:

• Slow build times (sometimes taking hours)
• Complex dependency management
• Difficulty in writing concurrent programs
• Need for a language that scales with team size

Go was their answer - a language designed for the 21st century, built by engineers who understood both the theoretical foundations and practical needs of large-scale software development.

More about Go: Vid

Why Enterprises Love Go: The Competitive Advantages

After diving deep into Go during my learning journey, I discovered why companies like Google, Uber, Netflix, and Docker have adopted Go as their go-to language for backend services. Here are the key advantages that make Go a powerhouse in enterprise environments:

1. Blazing Fast Compilation

Go compiles to native machine code incredibly fast. What takes minutes in other languages takes seconds in Go. This means faster development cycles and quicker deployments.

2. Built-in Concurrency: Goroutines and Channels

This is where Go truly shines. While other languages struggle with concurrent programming, Go makes it feel natural and intuitive.

// Goroutines: Lightweight threads that are managed by Go runtimepackage mainimport ("fmt""time")func worker(id int, jobs <-chan int, results chan<- int) {for j := range jobs {fmt.Printf("Worker %d processing job %d\n", id, j) time.Sleep(time.Second) // Simulate workresults <- j * 2 // Send result}}func main() {jobs := make(chan int, 100) results := make(chan int, 100)// Start 3 workersfor w := 1; w <= 3; w++ {go worker(w, jobs, results)}// Send 5 jobsfor j := 1; j <= 5; j++ {jobs <- j}close(jobs)// Collect resultsfor a := 1; a <= 5; a++ {<-results}}

3. Memory Efficiency

Go's garbage collector is designed for low-latency applications. It can handle millions of goroutines with minimal memory overhead - each goroutine starts with just 2KB of stack space!

// Demonstrating Go's efficiency with concurrent operationspackage mainimport ("fmt""sync")func main() {var wg sync.WaitGroup// Launch 100,000 goroutines - try this in other languages!for i := 0; i < 100000; i++ {wg.Add(1)go func(id int) {defer wg.Done()// Each goroutine does some workresult := id * idif id%10000 == 0 {fmt.Printf("Goroutine %d: %d\n", id, result)}}(i)}wg.Wait() fmt.Println("All 100,000 goroutines completed!")}

4. Simple Deployment

Go compiles to a single binary with no external dependencies. This makes deployment incredibly simple - just copy the binary and run it. No need to worry about runtime environments, package managers, or dependency conflicts.

5. Strong Standard Library

Go's standard library is comprehensive and well-designed. From HTTP servers to JSON parsing, from cryptography to file handling - most common tasks can be accomplished without external dependencies.

Learning Go Through Practice: My Two-Month Journey

From mid-June to the end of July 2024, I immersed myself in Go through GeeksforGeeks' limited free course. The learning approach was hands-on and project-driven, which made all the difference in truly understanding the language.

The Learning Structure

The course was structured to build knowledge progressively:

• Week 1-2: Go fundamentals and syntax
• Week 3-4: Concurrency patterns and goroutines
• Week 5-6: Building practical applications
• Week 7-8: Advanced topics and project completion

Two Projects That Changed My Perspective

The course culminated in two practical REST API projects that showcased Go's real-world applications. Along with REST API development, I also learned GraphQL implementation, testing both approaches using Insomnia and Postman for comprehensive API testing and validation.

Project 1: BasicCRUD - Car Inventory Management System

My first project was a comprehensive car inventory management system built with Go, PostgreSQL, and Fiber framework. This project taught me the fundamentals of building robust REST APIs with proper database integration.

GitHub Repository: https://github.com/F4tal1t/BasicCRUD

// Key features implemented in BasicCRUDtype Car struct {ID    uint    `json:"id" gorm:"primaryKey"` Name  string `json:"name" validate:"required"` Model string `json:"model" validate:"required"` Brand string `json:"brand" validate:"required"` Year  int    `json:"year" validate:"required,min=1900"` Price float64 `json:"price" validate:"required,min=0"`}

Key Features Implemented:

• Complete CRUD operations (Create, Read, Update, Delete)
• PostgreSQL database integration with GORM
• Swagger documentation for API endpoints
• Environment-based configuration for security
• Concurrent request handling with mutex protection
• Comprehensive error handling and input validation

Project 2: SoAt - Social Media Web Service

The second project was significantly more complex - a social media platform backend with user management, friendships, and posts. This project showcased Go's capabilities in building scalable, enterprise-grade applications.

GitHub Repository: https://github.com/f4tal1t/SoAt

// Docker Compose setup for microservices architectureversion: '3.8'services:soat:build: .ports: - "3000:3000"depends_on: - postgres - redis

Advanced Features Implemented:

• Layered architecture (Controllers, Services, Models)
• JWT authentication with role-based access control
• PostgreSQL for relational data + Redis for caching
• Docker containerization with Docker Compose
• User management, friendships, and posts functionality
• Admin user management utilities

Both projects were thoroughly tested using Insomnia and Postman for REST API validation, and I also implemented GraphQL endpoints to understand the differences between REST and GraphQL approaches in API design.

Conclusion: From Beginner to Go Enthusiast

My two-month journey with Go started as simple curiosity about a "new" programming language (turns out, it has been around for over a decade). Somewhere between my first “hello world” and experimenting with concurrency, I found myself genuinely enjoying how Go balances simplicity with real power.

Go taught me that simplicity is not about having fewer features, but about having the right ones that work naturally together. Its clean syntax, readable structure, and powerful concurrency model made it easy to focus on solving problems, while I also explored architecture patterns like Singleton and Factory, plus backend design practices for building scalable systems that can handle growth without crumbling.

I happened to earn two certificates along the way, but the bigger takeaway was the hands-on experience. From creating BasicCRUD to building SoAt, a social media backend with authentication, caching, and Docker, I got to see how Go works just as well for small utilities as it does for complex, maintainable systems.

From implementing simple CRUD operations to managing more advanced application layers, these projects showed me how Go can keep things clean and practical even as the codebase grows in complexity.

As I continue my development journey, I know Go will stay in my toolkit. Whether I am building microservices, crafting CLI tools, or developing high-performance backend systems, Go has proven itself as a language that lets me focus on building rather than battling the tools.

So, "Go? Where am I going?" The answer is clear: toward building better, more efficient, and more maintainable software. And Go is the perfect companion for that journey.

PS: Reflections on the Go Learning Experience

Looking back at my Go learning journey, I'm struck by how the language's philosophy influenced not just my coding style, but my approach to problem-solving. Go's emphasis on simplicity and clarity has made me a more thoughtful programmer.

The GeeksforGeeks course structure was particularly effective because it balanced theoretical concepts with practical application. The limited-time free access created a sense of urgency that kept me focused and motivated throughout the two-month period.

For anyone considering learning Go, my advice is simple: don't just read about it, build with it. The language's true power becomes apparent when you start solving real problems, especially those involving concurrency and system-level programming.

Go has definitely earned its place as one of my favorite programming languages, and I'm excited to explore more advanced topics like Go modules, testing patterns, and performance optimization in future projects.