DEV Community: Zone01 Kisumu

Round-Robin Scheduling: Generating fixtures for Zone01 Kisumu's Go Foosball League

Zone01 Kisumu — Fri, 21 Jun 2024 08:39:37 +0000

Introduction

This algorithm uses a round-robin approach, a standard method for generating fixtures in tournaments.

The Go Foosball League, presented at the #GophersKisumu Meetup on June 15th, 2024, solves the challenges faced by our community with manual management of fixtures. We were looking for a fair, efficient and automated solution that minimised human intervention. Here is how we created this fixture generating system.

The Problem
Our Go Foosball League was manually managed by a single person, leading to several issues:

Bias in Team Formation: Players often complained about unfair team pairings.
Scheduling Errors: Manual scheduling resulted in conflicts and errors.
Inefficiency: The process was time-consuming and prone to human error.

To address these challenges, we needed a solution to automate the management process, ensuring fairness and reducing the potential for errors.

The Solution
The Go Foosball League has the following core features:

Automated Team Formation: A randomization algorithm pairs strikers and defenders fairly.
Fixture Generation: Automatically creates balanced and unbiased match schedules.
Web Interface: A user-friendly web platform for players to view teams, fixtures, and other league details.

Technical Overview
The system is built with #Go, leveraging its efficiency and concurrency capabilities. Here's a high-level overview of the architecture:

Backend: Handles core logic for team formation and fixture generation.
HTTP Handlers: Manage functionalities like the home page, team list, and fixtures.
Database Integration: Planned for future development to store player stats and match results.
Web Frontend: Under development to provide an intuitive user interface.

Core Functionalities
Shuffling Players
The shuffle algorithm in our Go Foosball League randomizes the order of players to ensure that the team formations are fair and unbiased.

Step-by-Step Breakdown

Seeding the Random Number Generator:
The algorithm starts by seeding the random number generator with the current time in nanoseconds.
This ensures that each run of the algorithm produces a different random sequence.
Shuffling the Array:
The rand.Shuffle function is used to randomize the elements in the array.
The function swaps elements at random indices to achieve a shuffled order.
The shuffle algorithm is applied to the list of defenders to randomize their order.
Forming Teams:
Teams are formed by pairing each striker with a randomly selected defender.
The GenerateString function creates unique team names based on the paired players.

func Shuffle(arr []string) []string { 
rand.New(rand.NewSource(time.Now().UnixNano())) 
rand.Shuffle(len(arr), func(i, j int) { arr[i], arr[j] = arr[j], arr[i] }) 
return arr }

Fixture Generation
The Fixture function creates a balanced match schedule, ensuring all teams play against each other without duplication.

func Fixture(teams []types.Teams) [][]string {
    n := len(teams)
    if (n % 2 != 0) {
        teams = append(teams, types.Teams{Name: "", Striker: "", Defender: ""})
        n += 1
    }

    fixtures := [][]string{}
    for round := 1; round < n-1; round++ {
        match_list := []string{}
        for match := 0; match < n/2; match++ {
            home := (round + match) % (n - 1)
            away := (n - 1 - match + round) % (n - 1)
            if match == 0 {
                away = n - 1
            }
            if !(teams[away].Name == "" || teams[home].Name == "") {
                match_list = append(match_list, teams[home].Name + " vs " + teams[away].Name + " \n")
            }
        }
        fixtures = append(fixtures, match_list)
    }

    return fixtures
}

The Algorithm
The fixture generation algorithm in our Go Foosball League is designed to handle an even number of teams. If there’s an odd number of teams, the algorithm first adds a dummy team (a team with no players) to make the count even. The algorithm ensures every round has the same number of matches.

Step-by-Step Breakdown
Here’s a detailed breakdown of how the algorithm works:

Input Handling:
The algorithm accepts a list of teams.
If the number of teams is odd, it appends a dummy team to make the total even.
Round-Robin Scheduling:
The algorithm uses a round-robin approach, a standard method for generating fixtures in tournaments.
It ensures each team plays against every other team exactly once.
Fixture Creation:
For each round, it determines the matchups by rotating the positions of teams.
It pairs teams in a way that minimizes repetition and ensures fairness.
Rotation Logic:
In each round, the first team stays fixed, and the other teams rotate positions.
This rotation ensures that every team eventually plays against all other teams.
Avoiding Duplicate Matches:
The algorithm carefully tracks which teams have already played against each other.
It generates a new list of matches for each round without duplication.

Future Work
Future plans include:

Database Integration: For persistent storage of player stats and match results.
Enhanced Web Interface: Improve user experience and add more features.
Expand Functionality: Include table updating and detailed player statistics.

Check out the full code on my Github

By Bravian Nyatoro

The Ultimate Guide to Transforming Anxiety into Triumph with #Go

Zone01 Kisumu — Fri, 21 Jun 2024 08:37:54 +0000

Stellah Oiro

We've all been there. Staring at a screen, a stubborn bug taunting us from the depths of our Go code. The deadlines loom, the errors glare, and the familiar knot of frustration tightens in our stomachs.

Just the other day, I spent what felt like hours wrestling with a particularly nasty error message. The code was a mess of red underlines, and no matter how I approached it, a solution seemed impossible.

But here's the thing, every seasoned Go developer has felt that same mix of anxiety and determination. It's part of the process. The key is to channel that energy into growth.
Why Go? Because even with its challenges, Go is an incredibly rewarding language. Its simplicity hides a potent depth, perfect for building fast, reliable software in today's complex world. And with its fantastic concurrency support, it's got your back when things get truly tricky.

Ready to transform those coding struggles into victories? Let's dive into strategies for debugging, structured learning, and building your confidence one line of code at a time. Because you've got this.

Here a guide to help you on this journey

Embrace and Overcome Your Coding Anxiety: Strategies to identify and manage anxiety
Master Foundational Go Knowledge: Key concepts every Go programmer should know, with practical applications.
Perform Practical Coding Exercises: Hands-on exercises to build your confidence and skills.
Explore Advanced Go Techniques: Advanced tools and techniques to refine your programming prowess.
Work on Real-world Projects: Real-world projects to apply what you've learned and solidify your knowledge.

Embrace and Overcome Your Coding Anxiety

Ever felt your heart rate spike when a goroutine went rogue, or a cryptic error message left you utterly baffled? That's coding anxiety in action, and it's something almost every Go developer experiences. The journey of mastering any programming language involves overcoming challenges that can sometimes feel overwhelming. The good news is, awareness is the first step towards conquering that anxiety.

Here are some specific anxiety triggers that are common in Go, along with simple examples to illustrate them:
Complex Concurrency Models: Trying to manage multiple goroutines without causing deadlocks or race conditions.

func main() {
    go routine1() 
    go routine2()
    // Did we just create a race condition? Yikes!
}

Meticulous Error Handling: Handling errors effectively, especially in complex scenarios can be a source of stress.

if err := someFunction(); err != nil {
    // Is this enough, or are there more errors to catch?
}

Performance Optimization: The pressure to write the most efficient code possible.

Go

// Is for better than range in this loop? The performance stakes feel high!

Staying Up-to-Date: Keeping up with evolving Go best practices and new features.

Remember, these are common hurdles, and facing them is how you become a stronger Go developer.

Approach them with a growth mindset:
Embrace Challenges: They're part of the learning process, not roadblocks.

Problem-Solving Focus: Each error is a puzzle to solve, not a sign of failure.

Let's consider the dreaded memory leak. Even experienced devs grapple with these:

Go

func createLeak() {
    var pointer *int
    for {
        var number int
        pointer = &number 
    } 
    // Will this garbage collect? The pressure is on!
}

Don't let coding anxiety hold you back. Remember, there's a whole community of Go devs out there who've experienced similar struggles. Seek help on forums, join online groups, and celebrate every hurdle you overcome, you're becoming a better programmer with each line of code.

Master Foundational Go Knowledge

Mastering core concepts such as slices, maps, goroutines, and channels is essential for building robust and efficient Go applications. To truly grasp their power, let's see how you can apply these in real-world scenarios.
Practical Applications of Foundational Concepts
Slices: Dynamic Data Wrangling

Slices are like flexible containers for your data. Need to store a list of customer orders, or filter website visitors by country? Slices are your go-to tool.

func getUserIDs(users []User) []int {
    var ids []int
    for _, user := range users {
        ids = append(ids, user.ID)
    }
    return ids
}

Try This: Modify the function to return only IDs of users from a specific location (add a 'location' field to the User struct).
Maps: Finding Things Fast

Think of maps like super-organized dictionaries. Need to quickly check if a username is taken, or store a player's high score? Maps make lookups lightning-fast.

Go
preferences := map[string]string{
    "theme": "dark",
    "language": "English",
}
fmt.Println("Preferred theme:", preferences["theme"])

Try This: Add a new preference ("fontSize"), then loop through the map to print all the user's settings.
Goroutines: Multitasking Masters

Goroutines let your Go code do multiple things at once, like a web server handling hundreds of requests simultaneously.

func fetchURLs(urls []string) {
    for _, url := range urls {
        go func(u string) {
            fmt.Println("Fetching:", u) 
            // Replace placeholder with actual HTTP request.
        }(url)
    }
}

Try This: Use channels to send the results of each fetch back to the main function for further processing.
Channels: Goroutine Communication

Channels are the safe way goroutines talk to each other. Need to pass data between tasks, or signal when a job is done? Channels are your solution.

Go
// Example: Using a channel to collect results from multiple goroutines
func processTasks(tasks []Task) []Result {
results := make([]Result, len(tasks))
resultChan := make(chan Result)

for i, task := range tasks {
    go func(t Task, idx int) {
        // Process task and send result to channel
        resultChan <- process(t)
    }(task, i)
}

// Collect results
for i := 0; i < len(tasks); i++ {
    results[i] = <-resultChan
}
return results

}

Try This: Add a second channel for errors, so each goroutine can report problems as they happen.
Remember, these are just simple examples. As you learn more, you'll discover countless ways to combine these building blocks to create amazing Go applications.

Perform Practical Coding Exercises

Think of coding exercises like a workout for your Go skills. You don't start with the heaviest weights; you begin with something manageable and build from there. Let's try a simple one to get those coding muscles warmed up!
Example Exercise: Summing Up Some Numbers
Goal: Create a Go function that takes a bunch of numbers and spits out their total.
The Code:
Go

func sumArray(numbers []int) int {
    sum := 0 
    for _, number := range numbers {
        sum += number
    }
    return sum
}

How it Works (don't worry if this looks a bit techy now):
We call our function sumArray, and it expects a slice of numbers.
Inside, we have a sum counter, starting at zero.
The loop does the magic. It goes through each number, adding it to our sum.
Finally, the total sum is sent back.
Test It Out:
If we feed it a slice like [1, 2, 3, 4, 5], it should give us back a 15.
What You're Learning:
This might seem basic, but you're mastering how functions work, using loops, and getting comfy with slices, all essential Go stuff!
Level Up (Optional):
Can you change it so it only adds up even numbers?
Feeling fancy? Try solving this using recursion (a function calling itself, we'll get to that later).
The Key Takeaway
Exercises are the building blocks. Start small, understand each piece, and soon you'll be tackling those complex Go projects like a champ.

Explore Advanced Go Techniques

Okay, ready to level up your Go game? Once you've got the basics down, there's a whole world of powerful techniques that'll make your code faster, stronger, and way more impressive. Let's look at how this works in the real world:
Case Study: Speedy Text Transformer
The Problem: Imagine a company with mountains of text data. They need to analyze it, but first, it needs to be cleaned up and changed into a usable format. Doing this slowly was taking forever.
Go to the Rescue: A smart developer realized Go's concurrency features were the key. Think of it like this, instead of one worker handling the whole pile of text, you get a team of workers (goroutines) each tackling a chunk at the same time.
Example Code snippet(Focus on the Idea):
Go
func processText(texts []string) []string {
results := make([]string, len(texts))
jobs := make(chan string) // Jobs for the workers
done := make(chan bool) // Signal when all done

// Start some text-transformer workers:
for i := 0; i < 4; i++ {  
    go worker(jobs, results, done) 
}

// Send out the text-changing jobs:
for _, text := range texts {
    jobs <- text
}
close(jobs) //  No more jobs!

// Wait for the workers to finish:
for i := 0; i < len(texts); i++ {
    <-done 
}
return results

}

func worker(jobs <-chan string, results chan<- string, done chan<- bool) {
    for text := range jobs { 
        results <- changeText(text)  // Do the transformation
        done <- true                 // Signal "one job done!"
    }
}

The Win: The supercharged text-cruncher handled the data way faster than the old, one-thing-at-a-time way. Now the company gets insights quickly.
Why It's Cool (Beyond Speed):
Teamwork: Go makes it surprisingly easy to split work into these little cooperating 'goroutines.'
Handles the Future: Need to process even MORE data? Just add more "workers" in the code.
Keeps It Organized: Channels are like neat little conveyor belts, making sure everything flows smoothly.
Play With It: What if changeText also removed all vowels? Or turned everything backwards? Try it!
Key Takeaway: It takes practice, but these techniques are like power tools for your Go coding. They make your programs unstoppable
Work on Real-world Projects

You've done exercises, you understand the basics, but now it's time to build something REAL. Here's the good news: you can start with surprisingly simple Go projects that'll teach you a ton:
Your Own Mini Web Server

What it is: The foundation of any website! Make your computer serve up a basic webpage.
Why it's cool: You'll learn how the internet really works, and Go makes it pretty easy.
File Management Power Tool

What it is: Write a little command-line program to rename a bunch of files, delete old stuff – automate those annoying tasks!
Why it's cool: You control your computer at a deeper level, and learn how to work with files like a pro.
Build a Basic Chat App

What it is: Let people type messages and see them pop up, the start of something like Slack!
Why it's cool: You'll get into networking, which is how computers talk to each other. This is HUGE in Go.
Remember
Start Small: Even a 'hello world' webpage is a win at first!
Google is Your Friend: Searching "Go file renamer example" etc., will turn up tons of help.
It Gets Easier: Each project makes the next one less scary, that's the whole point.

Teamwork, Mentorship, and Tackling Go Challenges One Step at a Time

Throughout my journey with Go, I often run into high-anxiety moments, especially when wrestling with complex project demands. But I've discovered a strategy that works wonders. Breaking big projects down into smaller, achievable goals, makes each challenge more approachable. A simple approach which has drastically cut down my stress, sharpened my focus, and ramped up my productivity, making each coding session increasingly rewarding.

Celebrating these small victories is a game-changer, steadily building my confidence and showing me the power of systematic progress in mastering Go.

I'm currently putting this insight to the test during an intense Go training program at Zone Zero One Kisumu. The hard work and focus demanded here are unlike anything I’ve tackled before. But it isn't just about individual effort, the peer-to-peer learning is incredible. Being surrounded by others facing similar challenges, figuring things out together, that support system makes a huge difference. And the mentorship from the tech team is invaluable, their guidance helps me break through tough moments and gain deeper understanding.
As one of the first cohort members in this five-year program, the pressure is on, but so is the opportunity to dive deep and truly hone my skills. Adopting a structured strategy, along with the support of my peers and the mentorship of the tech team, I’m able to manage the stress associated with learning new programming skills. Taking projects piece by piece is not only transforming daunting challenges into achievable triumphs but is also setting me on a clear path toward becoming a proficient Go developer.

As I continue with this journey, I'm constantly learning from both the training and my experience. I see more and more how dedication, a methodical approach, and a strong support network can lead to real mastery. Here’s to more coding, learning, and growing. If I can do it, so can you.