Go - lesson 5 | HackIndia Skills

Key point

One idea

A goroutine runs a function at the same time as the rest of your program. A channel lets that goroutine send a typed value back safely.

Use this for work that can happen in the background, like logging, sending a notification, checking a slow dependency, or preparing a report.

Where it fits

Your service does not need complex concurrency to look serious. One clear use is enough for this track.

For a college project, you can record a visit count, run a fake email receipt, or calculate a summary in the background after an HTTP request.

Your to-do

Use the pattern

Do each one yourself, then tap it to tick it off. The ticks are only a checklist for you: they are not marked or scored.

Create a channel with make and the value type you expect.
Start a goroutine with go before a function call.
Send a value into the channel from the goroutine.
Receive from the channel where you need the result.
Keep the code small enough that a recruiter can read it in one minute.

0 of 5 done

Example

Small worker example

This example calculates a total in a goroutine and sends it back on a channel. It uses only the standard library.

A channel made with make(chan int) is unbuffered. The send waits until another goroutine receives the value.

package main

import "fmt"

type Order struct {
	ID     string
	Amount int
}

func totalAsync(orders []Order) <-chan int {
	result := make(chan int)

	go func() {
		total := 0
		for _, order := range orders {
			total += order.Amount
		}
		result <- total
	}()

	return result
}

func main() {
	orders := []Order{
		{ID: "upi-101", Amount: 199},
		{ID: "upi-102", Amount: 249},
	}

	totalCh := totalAsync(orders)
	fmt.Println("doing other work")

	total := <-totalCh
	fmt.Println("total rupees:", total)
}

Tip

Use direction

Return a receive-only channel when callers should only read from it. That is why the example returns <-chan int.

This makes your intent clear and prevents accidental sends from the wrong place.

Common mistake

Avoid goroutine leaks

Do not start a goroutine that sends to a channel if nobody will receive from it. It can wait forever.

Also do not add goroutines just to look advanced. If normal code is clearer, use normal code.