DEV Community: Chemeres Miriam

Learning Go From Scratch: My Journey as a Beginner Developer

Chemeres Miriam — Mon, 05 Oct 2026 05:39:50 +0000

My Journey into Go: What I Learned as a Beginner

Starting a new programming language can be both exciting and challenging. For me, learning Go (Golang) has been an interesting part of my journey as a software developer.

When I first started learning Go, I knew that it was popular for backend development, APIs, cloud services, and systems programming. But understanding the language through actual coding exercises was a completely different experience.

In this article, I want to share some of the things I have learned as a beginner in Go, the challenges I faced, and what I am looking forward to learning next.

Why I Started Learning Go

As a software development student and apprentice, I wanted to strengthen my backend development skills.

Go caught my attention because it is:

Simple and readable
Fast and efficient
Designed with concurrency in mind
Widely used for backend and cloud applications
Supported by a strong standard library

I also wanted to challenge myself with a language that approaches programming differently from languages I had previously used.

Starting With the Basics

Like any programming language, I started with the fundamentals.

Some of the first concepts I worked with were:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

From this simple program, I began learning about:

Packages
Functions
Variables
Data types
Loops
Conditional statements
Strings
Arrays and slices
Maps

Although these concepts may look simple, writing them repeatedly helped me understand how Go approaches programming.

Functions

One of the concepts I practiced a lot was writing functions.

For example:

package main

import "fmt"

func add(a int, b int) int {
    return a + b
}

func main() {
    result := add(5, 3)
    fmt.Println(result)
}

Go makes function definitions relatively straightforward.

I also learned that functions can return multiple values, which is a feature I found particularly interesting:

func divide(a, b int) (int, int) {
    return a / b, a % b
}

This becomes especially useful when handling errors and returning results from functions.

Working With Slices

Slices were another important concept for me.

A slice allows us to work with a flexible collection of values:

numbers := []int{10, 20, 30, 40}

numbers = append(numbers, 50)

fmt.Println(numbers)

Understanding slices helped me when working on algorithms and manipulating collections of data.

Learning Through Algorithms

One of the biggest parts of my Go learning experience has been solving algorithmic problems.

Instead of only writing simple programs, I had to think about:

How to break a problem into smaller parts
How to manipulate data
How to improve my logic
How to handle edge cases
How to debug unexpected results

This taught me an important lesson:

Programming is not just about knowing the syntax. It is about learning how to think through problems.

Sometimes the hardest part wasn't writing the Go code. The hardest part was understanding the problem and deciding how to approach it.

Debugging

Debugging has also become an important part of my learning process.

When my program doesn't work, I try to understand why instead of immediately changing random parts of the code.

For example, I learned to use simple techniques such as:

fmt.Println(variable)

to inspect values while my program is running.

I also became more comfortable reading compiler errors and using them as clues.

At first, error messages could be frustrating. Eventually, I started seeing them as part of the learning process.

Git and Go Projects

Learning Go also gave me more opportunities to practice Git and GitHub.

While working on projects, I learned about:

Creating branches
Making commits
Rebasing
Resolving conflicts
Pushing changes
Organizing project structures

For example:

git status
git add .
git commit -m "feat: implement sorting algorithm"
git push

Git became more than just a tool for saving code. It became part of my development workflow.

One of My Biggest Lessons

One thing I have learned from programming is that struggling with a problem doesn't mean you are bad at programming.

There were moments when I could look at a problem for a long time without knowing how to solve it.

Instead of giving up, I started breaking the problem down.

I would ask myself:

What exactly is the problem asking?
What input do I have?
What output do I need?
What steps can transform the input into the output?
Can I solve each step separately?

This approach has helped me become more confident.

What I Want to Learn Next

My Go journey is still beginning.

I want to continue learning:

Structs and interfaces
Error handling
Goroutines
Channels
HTTP servers
REST APIs
Databases
Authentication
Testing
Building production-ready backend applications

Eventually, I want to use Go to build complete backend systems and connect them to modern frontend applications.

Final Thoughts

Learning Go has taught me much more than just another programming language.

It has helped me improve my problem-solving skills, understand algorithms better, become more comfortable with debugging, and appreciate the importance of writing simple and maintainable code.

I'm still learning, and I definitely don't have everything figured out yet.

But that's what makes the journey exciting.

Every project, error, debugging session, and solved problem is another step forward.

If you're also learning Go as a beginner, keep going. Don't worry about understanding everything immediately. Write code, make mistakes, debug, ask questions, and keep building.

That's how we grow as developers. 🚀

go #golang #programming #softwaredevelopment #backend #learningtocode

Building GreenTech Solutions: Lessons from Zone01 Kisumu

Chemeres Miriam — Wed, 30 Sep 2026 12:11:09 +0000

Description: Exploring how full-stack developers, Go backends, and lightweight Docker containerization drive sustainable GreenTech innovation.
tags: go, docker, webdev, green

Climate change and environmental sustainability are no longer challenges that can be solved by policy alone. Today, full-stack software engineers, systems architects, and developers are at the frontlines, building data-driven tools that track, analyze, and minimize our impact on the environment.

Participating in the Green Economy Hackathon at Zone01 Kisumu highlighted a key truth: software development plays an essential role in driving sustainable innovation, from smart agriculture and energy tracking to writing low-footprint backend code.

What GreenTech Means for Modern Developers

Green Technology (GreenTech) in software development isn't just about building environmental apps—it's about how we design, architect, and optimize software systems to conserve resources.

Key areas where full-stack developers build real impact include:

Smart Agriculture & Resource Optimization: Building data platforms that analyze soil sensors, weather patterns, and automated irrigation to eliminate water waste.
Energy & Carbon Analytics: Creating real-time telemetry pipelines to monitor energy usage across industrial and community systems.
Efficient Algorithms & Low-Footprint Computing: Writing optimized code in compiled languages like Go to minimize CPU usage, lower server power consumption, and reduce data center carbon footprints.
Circular Economy Platforms: Building tracking tools and marketplaces for local waste management and recycling initiatives.

Green Software Engineering: Why Performance is Sustainability

An overlooked aspect of GreenTech is Green Software Engineering—the practice of writing code that requires less computational energy to run. Every redundant database query, unoptimized loop, and bloated container consumes raw electricity in data centers.

Building Performant Backends with Go
Choosing a compiled, highly concurrent language like Go for REST APIs and data processing directly cuts down CPU execution time and memory overhead compared to heavier, interpreted runtimes.

For instance, processing real-time telemetry from environmental sensors using Go’s concurrency model ensures high throughput with minimal resource expenditure:


go
package main

import (
    "fmt"
    "sync"
)

type SensorReading struct {
    DeviceID   string
    Moisture   float64
    NeedsWater bool
}

// Efficient batch processing of environmental telemetry with low memory overhead
func processReadings(readings <-chan SensorReading, wg *sync.WaitGroup) {
    defer wg.Done()
    for data := range readings {
        if data.NeedsWater {
            fmt.Printf("[ACTION] Dispatching automated irrigation for device: %s\n", data.DeviceID)
        }
    }
}

working on booting management tool to solve booting process problems

Chemeres Miriam — Wed, 29 Jul 2026 07:13:14 +0000

working on booting management tool

Chemeres Miriam — Wed, 29 Jul 2026 07:12:30 +0000