DEV Community: Andi

Go (Golang) Basic (Bonus) Three Advanced Function Techniques

Andi — Sun, 28 Sep 2025 07:54:16 +0000

Leveling Up Your Function Game

Welcome to a bonus installment of our Go series! You've already mastered the fundamentals of creating functions, but Go has a few more powerful tricks up its sleeve.

In this article, we'll explore three advanced techniques that can make your code more flexible and elegant:

Variadic Functions: Functions that can accept any number of arguments.
Anonymous Functions: Functions without a name.
Recursive Functions: Functions that call themselves.

Let's dive in!

1. Variadic Functions (Accepting Many Arguments)

Have you ever used fmt.Println() and noticed you can pass as many arguments as you want?
fmt.Println("a", "b", "c") works, and so does fmt.Println("just one").

This is possible because of variadic functions. A variadic function can accept a variable number of arguments for its last parameter.

Analogy: A shopping cart. You can put one item, ten items, or a hundred items into it. The cart (function) can handle it.

How to Create a Variadic Function

You create one by adding ... before the type of the final parameter. Inside the function, that parameter is treated as a slice of its type.

Code Example: Sum All Numbers

Let's create a function that can sum any amount of numbers.

package main

import "fmt"

// The '...int' tells Go that 'numbers' can be zero or more ints.
// Inside the function, 'numbers' is a slice: []int
func sumAll(numbers ...int) int {
    total := 0
    // We can loop over it like any other slice
    for _, number := range numbers {
        total += number
    }
    return total
}

func main() {
    // We can call it with multiple arguments
    total1 := sumAll(10, 10, 10)
    fmt.Println("Total 1:", total1) // Prints: 30

    // Or with a different number of arguments
    total2 := sumAll(5, 5, 5, 5, 5)
    fmt.Println("Total 2:", total2) // Prints: 25

    // We can also pass a slice, but we must "spread" it with '...'
    mySlice := []int{20, 20, 20}
    total3 := sumAll(mySlice...)
    fmt.Println("Total 3:", total3) // Prints: 60
}

2. Anonymous Functions (Functions Without a Name)

Just as the name suggests, an anonymous function is a function that is declared without a name. So why would you want this? They are extremely useful for short, one-off tasks where defining a full, named function would be overkill.

Analogy: A disposable, single-use tool. You use it for one specific job and then throw it away without needing to store it in your toolbox.

How to Use Anonymous Functions

You can assign an anonymous function to a variable, or pass it directly as an argument to another function.

Code Example

package main

import "fmt"

func main() {
    // 1. Assigning an anonymous function to a variable
    // This function has no name, but we can call it using the 'greet' variable
    greet := func() {
        fmt.Println("Hello from an anonymous function!")
    }

    greet() // Call it like a regular function

    // 2. A more practical use: a self-executing anonymous function
    // Notice the () at the end, which executes the function immediately
    func(message string) {
        fmt.Println(message)
    }("This is a one-time message!")
}

3. Recursive Functions (Functions That Call Themselves)

A recursive function is a function that calls itself to solve a problem. This is a powerful technique for problems that can be broken down into smaller, self-similar sub-problems.

Every recursive function must have two parts:

A Base Case: A condition that stops the recursion. Without this, you'll have an infinite loop!
A Recursive Step: The part where the function calls itself, usually with a modified argument that brings it closer to the base case.

Analogy: Russian nesting dolls. Each doll contains a smaller, identical version of itself, until you reach the final, solid doll (the base case).

Code Example: Factorial

Calculating a factorial (like 5! = 5 * 4 * 3 * 2 * 1) is a classic recursion problem.

package main

import "fmt"

// Calculates n!
func factorial(n int) int {
    // 1. The Base Case: If n is 0 or 1, we stop.
    if n <= 1 {
        return 1
    }

    // 2. The Recursive Step: n * factorial of (n-1)
    return n * factorial(n-1)
}

func main() {
    // The call stack will look like:
    // 5 * factorial(4)
    // 5 * (4 * factorial(3))
    // 5 * (4 * (3 * factorial(2)))
    // 5 * (4 * (3 * (2 * factorial(1))))
    // 5 * (4 * (3 * (2 * 1)))
    result := factorial(5)
    fmt.Println("5! is:", result) // Prints: 120
}

Conclusion

And there you have it! Three advanced function techniques that add a whole new level of flexibility and power to your Go programming.

Variadic Functions let you handle an unknown number of inputs.
Anonymous Functions are perfect for quick, inline logic.
Recursive Functions provide an elegant solution for problems that can be broken down into smaller pieces.

While you might not use these every single day, knowing they exist in your toolbox will make you a more capable and effective Gopher.

Thanks for reading this bonus article!

Go (Golang) Basic - Structuring Project with Packages

Andi — Sun, 28 Sep 2025 07:49:13 +0000

From a Single File to a Real Project

Welcome to the final part of our "Complete Guide to Go Basics" series! So far, all of our code has lived in a single file: main.go. This is fine for small programs, but as your projects grow, you'll need a way to organize your code into logical, reusable pieces.

In Go, the solution is Packages.

Analogy: Think of packages like folders on your computer. You don't put all your documents, photos, and music into one giant folder. You organize them into separate, dedicated folders. Packages do the same for your code.

1. What is a Package?

A package is simply a directory or folder containing one or more Go files that all belong together. Every Go file must declare which package it belongs to at the very top of the file (e.g., package main).

Let's create our own package. Imagine we want to build a simple calculator utility.

Step 1: Create the Package Directory

Inside your project folder (e.g., my-go-project), create a new sub-folder named calculator.

Your project structure should now look like this:

my-go-project/
├── go.mod
├── main.go
└── calculator/  \<-- Our new package folder

Step 2: Create a File in the Package

Inside the calculator folder, create a new file named add.go.

Step 3: Write the Package Code

Open calculator/add.go and add the following code. Notice the first line!

// This file belongs to the 'calculator' package
package calculator

// Add is a function that takes two integers and returns their sum.
// We'll discuss why 'A' is capitalized in a moment.
func Add(a int, b int) int {
    return a + b
}

Key Rule: All .go files inside the calculator directory must start with package calculator.

2. Importing and Using Your Package

Now that we have our calculator package, how do we use the Add function from our main.go file? We use the import keyword.

Open your main.go file and modify it to look like this:

package main

import (
    "fmt"
    "my-first-go-project/calculator" // Import our custom package
)

func main() {
    // Call the Add function from the calculator package
    sum := calculator.Add(5, 3)

    fmt.Println("The sum is:", sum) // Prints: The sum is: 8
}

How it works:

We import our package using its full path: <module_name>/<package_name>. The module name is the one you defined in your go.mod file.
To use the function, we prefix it with the package name: calculator.Add().

3. Go's Simple Visibility Rule: The Capital Letter

You might have noticed that we named our function Add with a capital A. This was intentional and is one of the most elegant features of Go.

In Go, there is no public or private keyword. Visibility is determined by a simple rule:

If a name (function, struct, variable, etc.) starts with a capital letter, it is Public (Exported). This means it can be accessed from other packages.
If a name starts with a lowercase letter, it is Private (unexported). This means it can only be accessed by code within the same package.

Analogy: A restaurant.

Public (Capital Letter): The Menu given to customers. Anyone can see it and order from it.
Private (lowercase letter): The secret recipe in the kitchen. Only the chefs (code in the same package) can access it.

Let's prove this. Add a new subtract function with a lowercase 's' to your calculator/add.go file:

// in calculator/add.go

package calculator

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

// 's' is lowercase, so this function is private
func subtract(a int, b int) int {
    return a - b
}

Now, try to call subtract from main.go:

// in main.go
package main

import (
    "fmt"
    "my-first-go-project/calculator"
)

func main() {
    sum := calculator.Add(5, 3)
    fmt.Println("The sum is:", sum)

    // This line will cause a compilation error!
    // diff := calculator.subtract(5, 3) 
}

If you try to run this, Go will give you an error saying cannot refer to unexported name calculator.subtract. This is Go's way of protecting your private code.

Conclusion: You've Built a Strong Foundation!

Congratulations! You have officially reached the end of our "Complete Guide to Go Basics" series. You've journeyed from a simple "Hello, World!" to understanding some of Go's most powerful and unique features.

Let's recap what you've mastered:

The Basics: Variables, data types, and collections like slices and maps.
Control Flow: Making decisions with if/switch and repeating tasks with for.
Code Structure: Organizing logic into functions, creating custom types with structs, and attaching behavior with methods.
Advanced Concepts: Using pointers for efficiency, handling errors gracefully, and now, structuring your project with packages.

You now have a very solid foundation. The Go world is vast, and your next steps could be exploring:

Goroutines and Channels: Go's famous approach to concurrency.
The Standard Library: Discovering Go's rich set of built-in packages.
Building a Project: Creating your first web API or command-line tool.

Thank you for following along with this series. I hope it has been a helpful and enjoyable journey. Happy coding!

Go (Golang) Basic - Error

Andi — Sun, 28 Sep 2025 07:43:54 +0000

What Happens When Things Go Wrong?

We've learned to write functions, create structs, and use pointers. Our code works perfectly... in a perfect world. But in the real world, things go wrong: a file might not exist, a network connection might fail, or a user might provide invalid input.

Many languages handle these situations with "exceptions" using try-catch blocks. Go takes a fundamentally different and more explicit approach.

In Go, errors are values. An error is not a special event that stops your program; it's just another value that a function can return, like a string or an int. This philosophy forces you to consciously handle potential failures, leading to more robust and predictable code.

1. The `error` Type: Go's Built-in Contract

At its core, Go's error is a built-in interface. It's a very simple contract: any type that wants to be considered an error must have a single method called Error() that returns a string.

type error interface {
    Error() string
}

You don't usually need to create your own error types from scratch, but understanding this helps you see why the system is so flexible.

2. The Idiomatic Go Pattern: `if err != nil`

Because errors are just values, the standard way to handle them is to check if an error was returned from a function. This leads to the most common pattern you will see in any Go codebase: if err != nil.

A function that can fail will typically return two values: (the result, an error).

Analogy: A service technician's report. When the job is done, you get two things: the fixed appliance (the result) and a report slip (the error).

If the job was successful, the report slip is blank (nil).
If something went wrong, the report slip has a description of the problem (not nil).

The Pattern in Action

// A conceptual example
result, err := someFunctionThatCanFail()
if err != nil {
    // An error occurred! Handle it here.
    // For now, we can just print it and stop.
    fmt.Println("An error happened:", err)
    return 
}

// If the code reaches this point, it means 'err' was nil.
// It is now safe to use the 'result'.
fmt.Println("Success! The result is:", result)

3. Creating and Returning Errors

Now that we know how to check for errors, how do we create our own? Go's built-in errors package makes this very simple.

Let's build a practical example: a safe division function that returns an error if you try to divide by zero.

Code Example

package main

import (
    "errors"
    "fmt"
)

// This function returns two values: a float64 AND an error
func divide(a float64, b float64) (float64, error) {
    // If the divisor is zero, it's a predictable failure
    if b == 0 {
        // We return a zero value for the number and a new error message
        return 0, errors.New("cannot divide by zero")
    }

    // If everything is okay, we return the result and 'nil' for the error
    // 'nil' is Go's way of saying "nothing" or "no error"
    return a / b, nil
}

func main() {
    // --- Successful case ---
    result, err := divide(10.0, 2.0)
    if err != nil {
        // This block is skipped because 'err' is nil
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result 1:", result)
    }

    // --- Failure case ---
    result2, err2 := divide(10.0, 0)
    if err2 != nil {
        // This block runs because an error was returned
        fmt.Println("Error:", err2)
    } else {
        fmt.Println("Result 2:", result2)
    }
}

This pattern of returning (result, nil) on success and (zero-value, error) on failure is fundamental to writing clean and robust Go code.

4. `error` vs. `panic`: A Crucial Distinction

Beginners often wonder when to return an error and when to use panic. The difference is a matter of expectation.

Analogy: Think of your program as a car journey.

error: This is like a "Check Engine" light. It's an expected problem. You can see the warning, decide to pull over, and handle it. The journey can potentially continue.
panic: This is like the engine suddenly exploding. This is a catastrophic, unexpected failure that indicates something is deeply wrong with the car (a bug in your code). The journey stops immediately.

Use this as your guide:

Use error for expected failures that are a normal part of your program's operation (e.g., invalid user input, file not found, network timeout).
Use panic very rarely, and only for truly exceptional situations that indicate a programmer error or a state that should be impossible to reach.

Conclusion

Go's approach to error handling is one of its most defining features. By treating errors as regular values, it encourages you to build resilient and predictable applications.

You've now learned:

The philosophy that "errors are values".
The standard if err != nil pattern for checking errors.
How to create and return your own errors.
The critical difference between a manageable error and a fatal panic.

In the final part of our foundational series, we'll learn how to structure larger projects by organizing our code into Packages. See you there!

Go (Golang) Basic - Interfaces

Andi — Sun, 28 Sep 2025 07:41:00 +0000

What Comes After Custom Types?

In the last few parts, we've learned how to create our own data types with structs and attach behavior to them with methods. This is great for creating organized, self-contained components.

But what if we want to write a function that can work with different types, as long as they share a common behavior? For example, a function that can process anything that can be "saved" to a file, whether it's a User struct, a Product struct, or an Invoice struct.

This is where Interfaces come in. An interface is one of Go's most powerful features for writing flexible and abstract code.

1. What is an Interface? (The Contract)

An interface in Go is a type that defines a set of method signatures. It's not a piece of data; it's a contract. It says, "Any type that wants to be considered a member of my group must have these specific methods."

Analogy: An electrical wall socket (stopkontak). The socket is the interface. It has a contract: "Anything that wants to get power from me must have a two-pronged plug that fits my shape." The socket doesn't care if you plug in a phone charger, a fan, or a TV. As long as the device's plug matches the contract, it works.

Defining an Interface

Let's define a simple interface for anything that can make a sound.

package main

import "fmt"

// This is our contract.
// Any type that wants to be a "SoundMaker" MUST have a method
// called MakeSound() that returns a string.
type SoundMaker interface {
    MakeSound() string
}

2. Implementing an Interface (Implicitly)

Here's a key difference between Go and other languages like Java or C#: you don't explicitly say that your type implements an interface.

A type in Go implicitly satisfies an interface if it defines all the methods specified in that interface. No implements keyword needed.

Let's create two different types that will satisfy our SoundMaker contract.

// (Continuing from the code above)

// --- First Type: Dog ---
type Dog struct {
    Name string
}

// Dog now satisfies the SoundMaker interface because it has the MakeSound() method.
func (d Dog) MakeSound() string {
    return "Woof!"
}

// --- Second Type: Cat ---
type Cat struct {
    Name string
}

// Cat also satisfies the SoundMaker interface.
func (c Cat) MakeSound() string {
    return "Meow!"
}

func main() {
    // We'll see how to use these in the next step.
}

Even though Dog and Cat are completely different structs, Go considers both of them to be SoundMakers because they both fulfill the contract.

3. Using the Interface (The Payoff)

Now for the magic. We can create a function that accepts our SoundMaker interface as a parameter. This function doesn't know or care whether it's receiving a Dog or a Cat. It only knows that whatever it receives, it's guaranteed to have a MakeSound() method.

The Flexible Function

Let's create a function that makes any SoundMaker speak.

// (Continuing from the code above)

// This function can accept ANY type that satisfies the SoundMaker interface.
func letThemSpeak(s SoundMaker) {
    fmt.Println("The sound is:", s.MakeSound())
}

func main() {
    // Create an instance of Dog and Cat
    myDog := Dog{Name: "Buddy"}
    myCat := Cat{Name: "Whiskers"}

    // We can pass both myDog and myCat to the same function!
    letThemSpeak(myDog) // Prints: The sound is: Woof!
    letThemSpeak(myCat) // Prints: The sound is: Meow!
}

This is incredibly powerful. It allows us to write generic functions that are decoupled from specific data types, making our code much more reusable and easier to maintain.

Putting It All Together: A Full Example

Here is the complete, runnable program that demonstrates everything we've discussed.

package main

import "fmt"

// 1. The contract (the interface)
type SoundMaker interface {
    MakeSound() string
}

// 2. The first type that satisfies the contract
type Dog struct {
    Name string
}

func (d Dog) MakeSound() string {
    return "Woof!"
}

// 3. The second type that also satisfies the contract
type Cat struct {
    Name string
}

func (c Cat) MakeSound() string {
    return "Meow!"
}

// 4. The flexible function that works with any SoundMaker
func letThemSpeak(s SoundMaker) {
    fmt.Println("The sound is:", s.MakeSound())
}

func main() {
    // Create instances of our concrete types
    myDog := Dog{Name: "Buddy"}
    myCat := Cat{Name: "Whiskers"}

    // Call the same function with different types
    letThemSpeak(myDog)
    letThemSpeak(myCat)
}

Conclusion

Interfaces are a core concept in Go for writing clean, abstract, and testable code. By defining contracts (interfaces) instead of depending on concrete types (structs), you can build systems that are much more flexible and scalable.

You've now learned how to:

Define an interface as a set of method signatures.
Implicitly satisfy an interface by implementing its methods on a struct.
Write generic functions that operate on interfaces, not specific types.

In the next part, we'll cover another of Go's most defining features: its elegant approach to Error Handling. See you there!

Go (Golang) Basic - Pointers

Andi — Sun, 28 Sep 2025 07:37:39 +0000

One of Go's Most Feared (and Powerful) Concepts

Welcome back! In our journey so far, we've learned how to create our own data types with structs and attach behavior with methods. Now, we're going to tackle a topic that can seem intimidating at first but is absolutely essential for writing effective Go code: Pointers.

Don't worry. We'll break it down with a simple analogy that makes it easy to understand. The core idea is to understand the difference between giving someone a copy of your data versus giving them access to the original.

1. Go's Default Behavior: Pass-by-Value (The Photocopy)

By default, whenever you pass data to a function in Go (including structs), Go makes a copy of that data. The function then works on the copy, leaving the original untouched.

Analogy: You have an important document. If you give a photocopy to a colleague and they scribble all over it, your original document remains clean and unchanged.

A Code Example That Doesn't Work as Expected

Let's try to write a method that updates a user's email.

package main

import "fmt"

type User struct {
    Name  string
    Email string
}

// This method receives a COPY of the User
func (u User) updateEmail(newEmail string) {
    u.Email = newEmail
    fmt.Println("Inside method, email is:", u.Email)
}

func main() {
    // Create a user
    user := User{Name: "Budi", Email: "budi.lama@email.com"}
    fmt.Println("Before method call, email is:", user.Email)

    // We call the method to update the email
    user.updateEmail("budi.baru@email.com")

    // Let's check the original user's email again
    fmt.Println("After method call, email is:", user.Email)
}

When you run this, you'll see this output:

Before method call, email is: budi.lama@email.com
Inside method, email is: budi.baru@email.com
After method call, email is: budi.lama@email.com

Notice that the original user's email did not change! This is because the updateEmail method worked on a photocopy, not the original.

So, how do we modify the original? With pointers.

2. The Solution: Pass-by-Reference with Pointers

To solve our problem, we need to stop sending a photocopy and instead send the address of the original document. In Go, this "address" is called a pointer.

A pointer doesn't hold the data itself, but it holds the memory location where the data lives. When a function receives a pointer, it knows where to find the original data and can modify it directly.

We use two special symbols for this:

* (The Star/Asterisk): When used in a type declaration like *User, it means "a pointer to a User".
& (The Ampersand): When used in front of a variable like &user, it means "get the memory address of this user".

3. The Most Important Use Case: Pointer Receivers

The most common and important place you'll use pointers is on method receivers. By adding a * to the receiver, you tell Go that this method should work on the original struct instance, not a copy.

The Corrected Code Example

Let's fix our previous example by adding one character: a *.

package main

import "fmt"

type User struct {
    Name  string
    Email string
}

// This method now receives a POINTER to the User (*User)
func (u *User) updateEmail(newEmail string) {
    u.Email = newEmail // This now modifies the original user's email
}

func main() {
    // Create a user
    user := User{Name: "Budi", Email: "budi.lama@email.com"}
    fmt.Println("Before method call, email is:", user.Email)

    // When you call a method with a pointer receiver on a variable,
    // Go automatically handles sending the address for you (it's like implicitly doing `(&user).updateEmail(...)`)
    user.updateEmail("budi.baru@email.com")

    // Let's check the original user's email again
    fmt.Println("After method call, email is:", user.Email)
}

Now, the output is exactly what we want:

Before method call, email is: budi.lama@email.com
After method call, email is: budi.baru@email.com

Success! The original user struct was modified because the method received a pointer to it.

Why use pointer receivers?

To Modify Data: As we just saw, it's the only way for a method to change the original struct's values.
For Performance: It avoids copying large structs every time a method is called, making your program faster and more memory-efficient.

Conclusion

Pointers might seem complex, but their main purpose is simple: to give functions and methods direct access to modify original data.

Here's a golden rule for you as a beginner:

When you write methods for a struct, always use a pointer receiver (func (s *MyStruct) ...).

This is the standard practice in Go and will save you from many common bugs and performance issues.

In the next part, we'll explore another powerful concept for writing flexible code: Interfaces. See you there!

Go (Golang) Basic - Structs and Methods

Andi — Sun, 28 Sep 2025 07:29:23 +0000

Beyond Strings and Integers

So far, we've worked with Go's built-in data types like string, int, and bool. These are great, but what if you want to represent something more complex, like a user, a product, or a car? A user isn't just a string; they have a name, an email, an age, and so on.

To handle this, Go allows us to define our own custom data types using Structs. We can then attach functions to these structs, which are called Methods.

1. What is a Struct? (The Blueprint)

A struct (short for structure) is a collection of fields that defines a new data type. It's like creating a blueprint for your data.

Analogy: A blank biodata form. The form has predefined fields like "Name," "Address," and "Age," but it doesn't contain any actual information yet. It's just the template.

Defining a Struct

We use the type and struct keywords to define a new struct. Let's create one for a User.

package main

import "fmt"

// This is our blueprint for a User.
// The fields (Name, Email, Age) start with a capital letter
// to make them public (we'll cover this later).
type User struct {
    Name  string
    Email string
    Age   int
}

func main() {
    // We'll create a user here in the next step
}

2. Creating Data from a Struct (The Instance)

Once we have the blueprint, we can create actual data from it. An individual piece of data created from a struct is called an instance or an object.

We create an instance and access its fields using the dot . notation.

// (Continuing from the code above)

func main() {
    // Creating an instance of our User struct
    user1 := User{
        Name:  "Budi",
        Email: "budi@email.com",
        Age:   30,
    }

    // Creating another instance
    user2 := User{
        Name:  "Siti",
        Email: "siti@email.com",
        Age:   25,
    }

    // Accessing the fields
    fmt.Println("User 1's Name:", user1.Name)
    fmt.Println("User 2's Email:", user2.Email)
}

This is far more organized than managing three separate variables (userName, userEmail, userAge) for each user!

3. Methods: Giving Your Structs Behavior

Now that we have a blueprint for our data (struct), we can define actions or behaviors that this data can perform. In Go, a function that is attached to a specific struct is called a Method.

Analogy: If a Car struct holds data like Color and Speed, its methods would be actions like StartEngine() or Accelerate().

Defining and Using a Method

A method is defined almost exactly like a function, but with one special addition: the receiver. The receiver is what links the function to the struct.

package main

import "fmt"

type User struct {
    Name  string
    Email string
    Age   int
}

// This is a METHOD because it has a receiver: '(u User)'
// The receiver links this function to the User struct.
// Inside this method, 'u' refers to the specific instance of the user.
func (u User) greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", u.Name, u.Age)
}

func main() {
    // Creating an instance of our User struct
    user1 := User{
        Name:  "Budi",
        Email: "budi@email.com",
        Age:   30,
    }

    // We call the method using the dot notation from the instance
    user1.greet() // Prints: Hello, my name is Budi and I am 30 years old.
}

How it works:

We defined the greet() method with a receiver (u User). This tells Go that greet() belongs to the User struct.
Inside the method, we can access the fields of that specific user instance through the receiver variable (u).
We call the method from the instance variable (user1.greet()).

Putting It All Together: A Full Example

Let's combine everything into one complete, runnable program.

package main

import "fmt"

// The blueprint for our data
type User struct {
    Name  string
    Email string
    Age   int
}

// The behavior attached to the User struct
func (u User) greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", u.Name, u.Age)
}

func main() {
    // Create two instances of User
    user1 := User{
        Name:  "Budi",
        Email: "budi@email.com",
        Age:   30,
    }

    user2 := User{
        Name:  "Siti",
        Email: "siti@email.com",
        Age:   25,
    }

    // Call the method from each instance
    user1.greet()
    user2.greet()
}

Conclusion

You've just taken a massive leap in writing organized Go code! You now know how to:

Group related data together into a clean blueprint using Structs.
Attach specific behaviors to that data using Methods.

This pattern is fundamental to building larger, more complex applications. It allows you to create self-contained components that are easy to understand and reuse.

In the next part, we'll dive into one of Go's most powerful (and sometimes tricky) concepts: Pointers. We'll learn how they allow us to modify our structs and write more efficient code. See you there!

Go (Golang) Basic - Functions

Andi — Sun, 28 Sep 2025 07:26:11 +0000

From a Long Script to Organized Blocks

As our programs grow, putting all our logic inside the main function can become messy and hard to manage. If we need to perform the same task multiple times, we'd have to copy and paste our code, which is a recipe for disaster.

The solution is to organize our code into reusable, named blocks. In Go, as in most programming languages, these blocks are called Functions.

Analogy: A coffee machine. Instead of manually grinding beans, tamping, and pulling a shot every time, you just press the "Espresso" button. That button is a function. It bundles a series of steps into one simple action.

1. Defining and Calling a Simple Function

A function is a block of code that performs a specific task. Let's create our first function.

package main

import "fmt"

// 1. We define our function here
func sayHello() {
    fmt.Println("Hello from a function!")
}

func main() {
    fmt.Println("Starting the program...")

    // 2. We call the function by its name
    sayHello()

    fmt.Println("Program finished.")
}

How it works:

We define func sayHello() to encapsulate the printing logic.
Inside main, we call sayHello() by its name, followed by parentheses (). The program jumps to the function, runs the code inside it, and then returns to main.

2. Functions with Parameters (Providing Input)

What if we want our function to be more flexible? For example, what if we want to greet a specific person? We can pass data into a function through parameters.

Parameters are variables that a function accepts as input.

package main

import "fmt"

// This function accepts one parameter called 'name' of type 'string'
func greet(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    greet("Budi") // "Budi" is the argument we pass to the 'name' parameter
    greet("Siti")
}

Now our greet function is much more reusable!

3. Functions with Return Values (Getting Output)

Functions are not just for doing things; they can also give back a result after they've finished their work. This is called a return value.

Analogy: A calculator. You provide input (numbers and an operation), and it returns the answer to you.

How to Return a Single Value

You specify the type of data the function will return right after its parameters.

package main

import "fmt"

// This function accepts a 'string' and will return a 'string'
func createGreeting(name string) string {
    greeting := "Hello from a function, " + name
    return greeting // The 'return' keyword sends the value back
}

func main() {
    // We capture the returned value in a variable
    message := createGreeting("Charlie")
    fmt.Println(message) // Prints: Hello from a function, Charlie
}

4. The Go Superpower: Multiple Returns

Here's a feature that makes Go stand out: a function can return more than one value. This is extremely common in Go, especially for functions that might fail.

The standard pattern is to return (the result, an error).

How to Return Multiple Values

Let's create a safe division function that returns the result and a potential error if we try to divide by zero.

package main

import (
    "errors"
    "fmt"
)

// This function returns two values: a float64 AND an error
func divide(a float64, b float64) (float64, error) {
    // If the divisor is zero, it's an error
    if b == 0 {
        // We return a zero value for the number and a new error message
        return 0, errors.New("cannot divide by zero")
    }

    // If everything is okay, we return the result and 'nil' for the error
    // 'nil' is Go's way of saying "nothing" or "no error"
    return a / b, nil
}

func main() {
    // --- Successful case ---
    result, err := divide(10.0, 2.0)
    if err != nil {
        // This block is skipped because 'err' is nil
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result 1:", result)
    }

    // --- Failure case ---
    result2, err2 := divide(10.0, 0)
    if err2 != nil {
        // This block runs because an error was returned
        fmt.Println("Error:", err2)
    } else {
        fmt.Println("Result 2:", result2)
    }
}

Conclusion

Functions are the cornerstone of writing well-structured and maintainable code. You've now learned how to:

Define and call simple functions.
Pass data into them using parameters.
Get results back using single and multiple return values.

By breaking your logic into functions, you're making your code cleaner, easier to debug, and much more powerful.

In the next part, we'll learn how to create our own custom data types using Structs and attach functions directly to them using Methods. See you there!

Go (Golang) Basic - 'for' Loop

Andi — Sun, 28 Sep 2025 07:23:25 +0000

Doing Things Over and Over Again

In our last part, we taught our code how to make decisions using if and switch. Now, let's teach it how to perform tasks repeatedly without us having to copy and paste our code. This process is called looping.

Many programming languages have several types of loops (while, do-while, for, forEach). Go simplifies this dramatically.

In Go, there is only one loop: the for loop. But it's incredibly versatile and can handle every looping scenario you need. Let's explore its three main forms.

1. The Classic `for` Loop

This is the most traditional form of a for loop, and you'll recognize it if you've used languages like C++, Java, or JavaScript. It's perfect when you know exactly how many times you want to repeat an action.

It consists of three parts, separated by semicolons:

The init statement: i := 0 (Initializes a counter. Runs once at the very beginning).
The condition expression: i < 5 (Checked before every loop. If true, the loop continues).
The post statement: i++ (Runs at the end of every loop iteration, usually to increment the counter).

Analogy: An assembly line worker who has been told to assemble exactly 5 boxes.

Code Example

package main

import "fmt"

func main() {
    // This loop will run 5 times (for i = 0, 1, 2, 3, 4)
    for i := 0; i < 5; i++ {
        fmt.Println("Assembling box number:", i)
    }
}

2. The `for` Loop as a `while` Loop

What if you don't know how many times to loop, but you know the condition to stop? In other languages, you'd use a while loop. Go handles this with a simplified for loop.

You just provide the condition, and the loop will run as long as that condition is true.

Analogy: Running on a treadmill. You don't know how many steps you'll take, but you'll keep running until you've burned 100 calories. The condition is caloriesBurned < 100.

Code Example

package main

import "fmt"

func main() {
    // This loop acts like a 'while' loop
    // It will run as long as 'number' is less than or equal to 5
    number := 1

    for number <= 5 {
        fmt.Println("The number is:", number)
        number++ // Important: Update the variable to avoid an infinite loop!
    }
}

3. The `for range` Loop: Iterating Over Collections

This is the most idiomatic and powerful way to loop over collections like slices and maps. It's Go's version of a forEach loop.

Analogy: Going through your grocery bag and looking at each item one by one.

Code Example with a Slice

When used with a slice, for range gives you the index and the value of each element.

package main

import "fmt"

func main() {
    fruits := []string{"Apple", "Banana", "Cherry"}

    for index, fruit := range fruits {
        fmt.Printf("Fruit at index %d is %s\n", index, fruit)
    }

    // If you only need the value, you can ignore the index with an underscore (_)
    fmt.Println("\nJust the fruit names:")
    for _, fruit := range fruits {
        fmt.Println(fruit)
    }
}

Code Example with a Map

When used with a map, it gives you the key and the value of each pair.

package main

import "fmt"

func main() {
    userProfile := map[string]string{
        "name": "Budi",
        "city": "Jakarta",
    }

    for key, value := range userProfile {
        fmt.Printf("%s: %s\n", key, value)
    }
}

Conclusion

Even with just one loop keyword, Go provides all the power you need to handle any repetitive task. You've now learned the three essential patterns:

The classic for loop for a fixed number of iterations.
The conditional for loop that acts like a while loop.
The for range loop for iterating over collections.

Mastering loops is a huge step in becoming a proficient programmer. In our next part, we'll learn how to organize our code into clean, reusable blocks called Functions. See you there!

Go (Golang) Basic - 'if' and 'switch'

Andi — Sun, 28 Sep 2025 07:17:09 +0000

Making Your Code "Think"

So far, our code has been executing line by line, from top to bottom. But what if we want it to make decisions? What if we want it to do one thing if a user is logged in, and something else if they aren't?

This is where conditional logic comes in. It's the "brain" of our program, allowing it to react differently to different situations. In Go, we have two primary tools for this: the if statement and the switch statement.

1. The `if` Statement: The Classic Decision Maker

The if statement is the most fundamental way to make a decision. Its logic is simple: "IF a certain condition is true, then do this."

We can extend it with else if for more conditions, and else for a default action if no conditions are met.

Analogy: A fork in the road. You check the sign (if condition), and based on that, you choose a path.

How to Use `if-else`

Let's build a simple program that gives a grade based on a score.

package main

import "fmt"

func main() {
    score := 85

    // The program checks these conditions from top to bottom
    if score > 90 {
        fmt.Println("Grade: A (Excellent!)")
    } else if score > 80 {
        fmt.Println("Grade: B (Good)")
    } else if score > 70 {
        fmt.Println("Grade: C (Average)")
    } else {
        fmt.Println("Grade: D (Needs Improvement)")
    }
}

How it works:

Since score is 85, the first condition (> 90) is false.
It moves to the next one. score > 80 is true!
The code inside that block runs, printing "Grade: B (Good)".
The rest of the if-else chain is then skipped.

2. The `switch` Statement: The Tidy Alternative

Sometimes, you have a long chain of if-else if statements that all check the same variable. This can look a bit messy. For these situations, Go gives us the switch statement, which is often cleaner and easier to read.

Analogy: A vending machine menu. You check one thing (the button the user pressed) and match it against a list of possible options.

How to Use `switch`

Let's rewrite a decision-making process for the days of the week.

package main

import "fmt"

func main() {
    day := "Saturday"

    switch day {
    case "Monday":
        fmt.Println("Time to start the week!")
    case "Friday":
        fmt.Println("The weekend is almost here!")
    case "Saturday", "Sunday": // You can group multiple cases
        fmt.Println("It's the weekend!")
    default:
        // This runs if no other case matches
        fmt.Println("It's a regular day.")
    }
}

How it works:

Go takes the day variable ("Saturday").
It checks each case one by one.
It finds a match in case "Saturday", "Sunday":.
The code inside that block runs, and the switch statement ends.
The default block is the equivalent of the final else in an if chain.

`if` vs. `switch`: When to Use Which?

Here's a simple rule of thumb:

Use if-else when you have complex conditions, check ranges (like score > 90), or need to evaluate multiple different variables.
Use switch when you are checking a single variable against a list of specific, exact values.

Conclusion

You've now learned how to give your Go programs a "brain"! Using if and switch, you can control the flow of your code, allowing it to make decisions and react dynamically. This is a massive step up from simply running code from top to bottom.

In the next part of our series, we'll learn how to make our programs perform tasks repeatedly without rewriting code, by mastering Go's only loop: the powerful for loop. See you there!

Go (Golang) Basic - Data Collections: Array, Slice, and Map

Andi — Sun, 28 Sep 2025 07:09:59 +0000

Storing More Than One Piece of Data

So far, we've learned how to store single pieces of information in variables. But what happens when you need to manage a list of items, like a grocery list, or a collection of user settings? Storing each one in a separate variable would be a nightmare!

This is where data collections come in. Go provides powerful, built-in types for managing groups of data. In this part, we'll focus on the two you'll use 99% of the time: Slices and Maps.

1. The Slice: Your Go-To Dynamic List

A slice is the most common collection type you'll use in Go. Think of it as a dynamic, flexible list that can grow or shrink as needed.

Analogy: A shopping list. You can start with a few items and add more as you think of them. The order of the items matters.

Creating and Using a Slice

Let's see it in action.

package main

import "fmt"

func main() {
    // Creating a slice of strings with some initial data
    fruits := []string{"Apple", "Banana", "Cherry"}
    fmt.Println("Initial fruits:", fruits)

    // Adding a new item to the slice using append()
    fruits = append(fruits, "Orange")
    fmt.Println("After adding Orange:", fruits)

    // Accessing an element by its index (starts from 0)
    fmt.Println("The first fruit is:", fruits[0])
}

Key points about Slices:

The syntax []string means "a slice of strings".
append() is the built-in function to add elements to a slice.
You access elements using an index, starting from 0.

2. The Map: A Key-Value Collection

A map is a collection of key-value pairs. It's incredibly useful when you want to look up a value based on a unique identifier (the key).

Analogy: A phone's contact list. You use a unique key (the person's name) to look up their value (their phone number). The order of contacts doesn't really matter.

Creating and Using a Map

Maps are perfect for things like configuration or user profiles.

package main

import "fmt"

func main() {
    // Creating a map where the key is a string and the value is a string
    userProfile := map[string]string{
        "name":    "Budi",
        "email":   "budi@email.com",
        "country": "Indonesia",
    }
    fmt.Println("User profile:", userProfile)

    // Accessing a value by its key
    fmt.Println("User's name is:", userProfile["name"])

    // Adding or updating a value
    userProfile["city"] = "Jakarta"
    fmt.Println("After adding city:", userProfile)

    // Deleting a key-value pair
    delete(userProfile, "country")
    fmt.Println("After deleting country:", userProfile)
}

Key points about Maps:

The syntax map[string]string means "a map with string keys and string values".
The order of elements in a map is not guaranteed.
You use the key to add, retrieve, or delete data.

Tentu, ini bagian kedua dan terakhir dari draf artikel Bagian 5 yang sudah direvisi.

Draf Artikel Bagian 5 (Revisi, 2/2)

3. The Map: A Key-Value Collection

While slices are great for ordered lists, sometimes you need to look up data based on a unique identifier, not its position. For this, we use a map. A map is a collection of key-value pairs.

Analogy: A phone's contact list. You use a unique key (the person's name) to look up their value (their phone number). The order of contacts doesn't really matter.

Creating and Using a Map

Maps are perfect for things like configuration, user profiles, or any data where you need fast lookups.

package main

import "fmt"

func main() {
    // Creating a map where the key is a string and the value is a string
    userProfile := map[string]string{
        "name":    "Budi",
        "email":   "budi@email.com",
        "country": "Indonesia",
    }
    fmt.Println("User profile:", userProfile)

    // Accessing a value by its key
    fmt.Println("User's name is:", userProfile["name"])

    // Adding or updating a value is done the same way
    userProfile["city"] = "Jakarta"
    fmt.Println("After adding city:", userProfile)

    // Deleting a key-value pair using delete()
    delete(userProfile, "country")
    fmt.Println("After deleting country:", userProfile)
}

Key points about Maps:

The syntax map[string]string means "a map with string keys and string values".
The order of elements in a map is not guaranteed.
You use the key ([]) to add, retrieve, or delete() data.

Array vs. Slice vs. Map: Which One to Use?

Here's a quick guide:

Use an Array when you know exactly how many items you'll have, and that number will never change (very rare).
Use a Slice for almost everything else that is a list of items. It's the default choice for lists in Go.
Use a Map when you need to store data that should be accessed by a unique identifier, not by its position in a list.

Conclusion

You've now learned how to manage groups of data in Go! You understand the difference between a rigid Array, a flexible Slice, and a lookup-based Map. These three data structures are the foundation for building any complex application.

In the next part, we'll learn how to make our code "think" and make decisions using conditional logic with if and switch. See you there!

Go (Golang) Basic - Data Types and Variables

Andi — Sun, 28 Sep 2025 06:57:32 +0000

The Building Blocks of a Program

To build any useful program, we need a way to store and manage information—a user's name, a score in a game, or the price of a product. In programming, we do this using variables and data types.

They are the most fundamental building blocks for handling data. Let's dive into how Go approaches this.

What Are Data Types? (Why Go is "Strict")

Before we can store a piece of data, we must tell Go what kind of data it is. Go is a statically-typed language, which means it's very strict about this rule.

Think of it like having labeled storage boxes: one for "Books", one for "Clothes", and one for "Toys". You can't put a toy in the book box. This strictness helps prevent many common bugs right from the start.

Here are the four most essential data types in Go:

string: Used for text. Any sequence of characters enclosed in double quotes (").
- Example: "Hello, Budi", "123 Main St."
int: Used for integers (whole numbers), both positive and negative.
- Example: 10, -50, 2025
float64: Used for floating-point numbers (decimals).
- Example: 3.14, 99.5
bool: Used for boolean logic (true or false).
- Example: true, false

Variables: The Containers for Your Data

A variable is simply a named container for our data. Once you create (declare) a variable, you can change its value later. There are two common ways to declare a variable in Go:

1. The Formal Way (`var`)

This way is very explicit about the variable's type.

// var <variableName> <dataType> = <value>
var age int = 30

Go can also infer the type if you leave it out:

var city = "Jakarta" // Go knows this is a string

2. The Short Way (`:=`)

This is the most common and preferred way to declare and initialize a variable inside a function. It's clean and concise. This is the most common and preferred way to declare and initialize a variable inside a function.

// <variableName> := <value>
name := "Siti"
isActive := true

Once a variable is declared, you can update its value using a simple equals sign (=):

name = "Siti Nurbaya" // Updating the value

Constants: Values That Never Change

Sometimes, you have a value that you know will never, ever change throughout your program's life. Think of mathematical constants like Pi, or a specific configuration setting. For these, Go gives us constants.

A constant is declared using the const keyword. Once set, its value is locked and cannot be changed.

const pi = 3.14
const defaultPort = 8080

// This would cause an error! You cannot change a constant.
// pi = 3.15

Putting It All Together: A Code Example

Let's see all these concepts in action in a single program. Create a main.go file and try out this code:

package main

import "fmt"

func main() {
    // --- STRINGS ---
    // Using the short declaration (:=)
    productName := "Go Programming E-book"
    fmt.Println(productName)

    // --- INTEGERS ---
    // Using the formal declaration (var)
    var quantity int = 10
    var price = 50000 // Go infers this is an int
    fmt.Println(quantity)
    fmt.Println(price)

    // --- FLOATS ---
    var score float64 = 85.5
    fmt.Println(score)

    // --- BOOLEANS ---
    isPublished := true
    fmt.Println("Is the product published?", isPublished)

    // --- CONSTANTS ---
    const author = "Go Community"
    fmt.Println("Author:", author)

    // --- UPDATING A VARIABLE ---
    fmt.Println("Current quantity:", quantity)
    quantity = 15 // Update the value
    fmt.Println("Updated quantity:", quantity)
}

Conclusion

You've now mastered the absolute fundamentals of handling data in Go. You know how to store text, numbers, and logical values using variables, and how to protect important values using constants.

These are the essential building blocks we'll use in every program from now on. In the next part of the series, we'll take a big step forward and learn how to store collections of data using two of Go's most powerful features: Slices and Maps. See you there!

Go (Golang) Basic - Your First 'Hello, World!'

Andi — Sun, 28 Sep 2025 04:01:16 +0000

Let's Write Some Code!

With your Go development environment now set up, it's time for the moment we've been waiting for: writing our first lines of code.

In the world of programming, the "Hello, World!" program is a time-honored tradition. It's a simple program that prints a message to the screen, serving two main purposes:

Confirming that our setup works correctly.
Introducing us to the most basic syntax of a language.

Let's get started.

Step 1: Create Your Go File

Inside the project folder you created (e.g., my-go-project), create a new file and name it main.go.

All your Go code will live inside files with the .go extension.

Step 2: Write the Code

Open your new main.go file in your editor (VS Code or GoLand) and type the following code exactly as it is shown:

package main

import "fmt"

// This is the main function, the entry point of our program
func main() {
    fmt.Println("Hello, World from Go!")
}

Step 3: Breaking Down the Code

It's a short program, but every line has an important role. Let's break it down so you understand what's happening.

package main: This line declares that our file belongs to the main package. In Go, an executable program (one you can run directly) must have a main package.
import "fmt": We are "importing" a built-in Go package named fmt (short for format). This package provides us with functions for formatting and printing text, much like console.log in JavaScript.
func main(): This defines the main function. This function is special. It's the special entry point of our application. When we run the program, Go looks for func main() and executes the code inside it first. When we run the program, the code inside the curly braces {} of func main() is the first code that gets executed.
fmt.Println("Hello, World from Go!"): Here we are calling the Println (Print Line) function from the fmt package we imported. This function prints the text "Hello, World from Go!" to our terminal, and then adds a new line at the end.

Step 4: Running Your Program

Now for the magic. Return to your terminal, make sure you are still inside your project directory, and run the following command:

go run main.go

If everything was typed correctly, you will see this output on your screen:

Hello, World from Go!

Conclusion

Congratulations! You have just written, understood, and run your very first Go program. This is a fundamental and exciting milestone in learning any new language.

DEV Community: Andi

Go (Golang) Basic (Bonus) Three Advanced Function Techniques

Leveling Up Your Function Game

1. Variadic Functions (Accepting Many Arguments)

How to Create a Variadic Function

Code Example: Sum All Numbers

2. Anonymous Functions (Functions Without a Name)

How to Use Anonymous Functions

Code Example

3. Recursive Functions (Functions That Call Themselves)

Code Example: Factorial

Conclusion

Go (Golang) Basic - Structuring Project with Packages

From a Single File to a Real Project

1. What is a Package?

Step 1: Create the Package Directory

Step 2: Create a File in the Package

Step 3: Write the Package Code

2. Importing and Using Your Package

3. Go's Simple Visibility Rule: The Capital Letter

Conclusion: You've Built a Strong Foundation!

Go (Golang) Basic - Error

What Happens When Things Go Wrong?

1. The error Type: Go's Built-in Contract

2. The Idiomatic Go Pattern: if err != nil

The Pattern in Action

3. Creating and Returning Errors

Code Example

4. error vs. panic: A Crucial Distinction

Conclusion

Go (Golang) Basic - Interfaces

What Comes After Custom Types?

1. What is an Interface? (The Contract)

Defining an Interface

2. Implementing an Interface (Implicitly)

3. Using the Interface (The Payoff)

The Flexible Function

Putting It All Together: A Full Example

Conclusion

Go (Golang) Basic - Pointers

One of Go's Most Feared (and Powerful) Concepts

1. Go's Default Behavior: Pass-by-Value (The Photocopy)

A Code Example That Doesn't Work as Expected

2. The Solution: Pass-by-Reference with Pointers

3. The Most Important Use Case: Pointer Receivers

The Corrected Code Example

Conclusion

Go (Golang) Basic - Structs and Methods

Beyond Strings and Integers

1. What is a Struct? (The Blueprint)

Defining a Struct

2. Creating Data from a Struct (The Instance)

3. Methods: Giving Your Structs Behavior

Defining and Using a Method

Putting It All Together: A Full Example

Conclusion

Go (Golang) Basic - Functions

From a Long Script to Organized Blocks

1. Defining and Calling a Simple Function

2. Functions with Parameters (Providing Input)

3. Functions with Return Values (Getting Output)

How to Return a Single Value

4. The Go Superpower: Multiple Returns

How to Return Multiple Values

Conclusion

Go (Golang) Basic - 'for' Loop

Doing Things Over and Over Again

1. The Classic for Loop

Code Example

2. The for Loop as a while Loop

Code Example

3. The for range Loop: Iterating Over Collections

Code Example with a Slice

Code Example with a Map

Conclusion

Go (Golang) Basic - 'if' and 'switch'

Making Your Code "Think"

1. The if Statement: The Classic Decision Maker

How to Use if-else

2. The switch Statement: The Tidy Alternative

1. The `error` Type: Go's Built-in Contract

2. The Idiomatic Go Pattern: `if err != nil`

4. `error` vs. `panic`: A Crucial Distinction

1. The Classic `for` Loop

2. The `for` Loop as a `while` Loop

3. The `for range` Loop: Iterating Over Collections

1. The `if` Statement: The Classic Decision Maker

How to Use `if-else`

2. The `switch` Statement: The Tidy Alternative

How to Use `switch`

`if` vs. `switch`: When to Use Which?

1. The Formal Way (`var`)

2. The Short Way (`:=`)