ඇයි ඔබ Go (Golang) ඉගෙන ගත යුත්තේ?

 Google එකේ ඉන්ජිනියර්ලා තුන්දෙනෙක් , Robert Griesemer, Rob Pike සහ Ken Thompson , දවසක් C++ project එකක් compile වෙනකම් බලාගෙන ඉන්නවා. එක මිනිත්තු ගාණක්. ඒ බලාගෙන ඉන්න වෙලාවේ තමයි "අපිට මීට වඩා හොඳ භාෂාවක් හදන්න බැරිද?" කියන අදහස එන්නේ.

ඒ අදහසින් 2009 නොවැම්බර් 10 වැනිදා ලෝකෙට Go එළියට ආවා. දැන් අවුරුදු 16ක්. Kubernetes, Docker, Terraform, Prometheus වගේ අද cloud ලෝකය දරාගෙන ඉන්න මෘදුකාංග ලියලා තියෙන්නේ Go වලින්. ඒ කියන්නේ ඔබ අද භාවිත කරන ඕනෑම cloud සේවාවක් යටින්, කොහේ හරි Go code දුවනවා.

මේ ලිපියේ මම කරන්නේ දෙකක්. පළමුව, ඇයි Go ඉගෙන ගන්න ඕන කියන එකට අවංක උත්තරයක් — වාසි විතරක් නෙවෙයි, අවාසිත් එක්කම. දෙවනුව, හරියටම කොහොමද පටන් ගන්නේ කියන එකට පියවරෙන් පියවර මාර්ගෝපදේශයක්.

 

Go කියන්නේ මොකක්ද? 

Go කියන්නේ statically typed, compiled භාෂාවක්. ඒ කියන්නේ:

• ඔබේ code එක run කරන්න කලින් binary file එකකට compile වෙනවා (Python, JavaScript වගේ interpret වෙන්නේ නෑ)
• දත්ත වර්ග (types) compile time එකේදීම check වෙනවා - bug ගොඩක් production යන්න කලින්ම හසුවෙනවා
• Garbage collection තියෙනවා      -  C/C++ වගේ memory manually manage කරන්න ඕන නෑ

සරලව කිව්වොත්: C වල වේගය, Python වල පහසුව. හරියටම මැද.

ඇයි Go ඉගෙන ගන්න ඕන? හේතු 7ක්

1. භාෂාව හරිම පොඩියි (මේක තමයි ලොකුම දේ)

Go වල keywords තියෙන්නේ 25යි. හරියටම 25යි. Java වල 50කට වඩා තියෙනවා, C++ වල 90කට වඩා තියෙනවා.

මේකෙන් වෙන දේ මොකක්ද? ඔබට සතියක් දෙකක් ඇතුළත භාෂාවේ සම්පූර්ණ syntax එකම ඉගෙන ගන්න පුළුවන්. ඊට පස්සේ ඔබ වෙලාව යොදවන්නේ භාෂාව ඉගෙන ගන්න නෙවෙයි — ප්‍රශ්න විසඳන්න.

තව දෙයක්. Go වල එකම දේ කරන්න ක්‍රම පහක් නෑ. gofmt කියන tool එක code එක automatically format කරනවා, ඒ නිසා "tabs ද spaces ද" වගේ නිකරුනේ තර්ක නෑ. ලංකාවේ කණ්ඩායමක් ලියපු code එකයි, ජර්මනියේ කණ්ඩායමක් ලියපු code එකයි එකම විදිහට පේනවා. ඒක ලොකු දෙයක්.

2. Concurrency - Go වල සුපිරි බලය

මේක තමයි Go එකේ තියෙන ලොකුම වාසිය.

සාමාන්‍ය භාෂාවක එකවර දේවල් ගොඩක් කරන්න (concurrency) threads පාවිච්චි කරනවා. Thread එකකට memory ගොඩක් යනවා — සාමාන්‍යයෙන් 1MB විතර. ඒ නිසා thread දහසක් හදන එක බැරි වැඩක්.

Go වල තියෙන්නේ goroutines. එකක් පටන් ගන්න යන්නේ 2KB විතරයි. ඒ කියන්නේ ඔබට එකවර goroutines ලක්ෂ ගාණක් run කරන්න පුළුවන්. go කියන වචනය එකතු කරලා විතරයි:

go

go sendEmail(user)   // මේක background එකේ දුවනවා

ඒ තරම් සරලයි. Node.js වල callback hell එකක් නෑ, Java වල thread pool configuration නෑ. හුදෙක් go කියලා ලියනවා.

3. Compile වෙන්නේ තත්පර ගාණකින්, එළියට එන්නේ එක file එකක්

Go compiler එක භයානක වේගවත්. මධ්‍යම ප්‍රමාණයේ project එකක් තත්පර කිහිපයකින් build වෙනවා.

ඊට වඩා වැදගත් දේ: build කළාම එළියට එන්නේ එකම binary file එකක්. Dependencies නෑ, runtime install කරන්න ඕන නෑ, virtual environment නෑ.

ඒ file එක server එකට copy කරලා run කරන්න පුළුවන්. ඔබට Windows එකේ ඉඳන් Linux server එකට build කරන්නත් පුළුවන්:

bash

GOOS=linux GOARCH=amd64 go build -o myapp

Python වලින් deploy කරලා තියෙන කෙනෙක්ට මේකේ වටිනාකම හොඳටම තේරෙයි.

4. Cloud සහ DevOps ලෝකයේ නිල භාෂාව

මේ ලැයිස්තුව බලන්න. හැම එකක්ම Go වලින් ලියලා තියෙනවා:

• Kubernetes — ලෝකයේ container orchestration standard එක
• Docker — container revolution එකේ මුල
• Terraform — Infrastructure as Code වල රජා
• Prometheus — monitoring වල default තේරීම
• etcd, Grafana Loki, CockroachDB, InfluxDB — තව ගොඩක්

ඒ කියන්නේ ඔබ DevOps, Cloud, හෝ Platform Engineering පැත්තට යන්න හිතාගෙන ඉන්නවා නම්, Go කියන්නේ තෝරාගැනීමක් නෙවෙයි — අවශ්‍යතාවයක්.

5. පඩිය ගැන කතා කරමු

මේක සල්ලි ගැන විතරක් නෙවෙයි, ඒත් සල්ලිත් වැදගත්.

2026 මැද වන විට Glassdoor වල Golang developer කෙනෙක්ගේ සාමාන්‍ය වැටුප ඩොලර් 139,821ක් විතර. මැද කොටස ඩොලර් 107,892 සිට 183,160 දක්වා විහිදෙනවා. Stack Overflow සමීක්ෂණවල Go නිතරම වැඩිම වැටුප් ලැබෙන භාෂා තුනෙන් එකක් විදිහට තියෙනවා  

ඇයි? සැපයුම සහ ඉල්ලුම. Python හෝ JavaScript දන්න developersලා ලක්ෂ ගාණක් ඉන්නවා. Go දන්න අය ඒකෙන් දහයෙන් එකක් විතරයි. ඒ අතරේ cloud-native infrastructure වැඩ දිගටම වැඩි වෙනවා.

මෙතන තියෙන අවංක කරුණක් තියෙනවා. කවුරුවත් Go පළවෙනි භාෂාව විදිහට ඉගෙන ගන්නේ නෑ. ගොඩක් අය Java, C++, හෝ Python වලින් ඇවිත් තමයි Go ට එන්නේ , සාමාන්‍යයෙන් scale වෙන්න බැරි වුණු system එකක් හදන්න ගිහින්. ඒ නිසා Go ලියන අය කලින්ම හොඳ engineersලා. ඒකෙන් වෙන්නේ අනිත් භාෂාවල තියෙන "junior ගොඩ" Go වල නෑ. ඒක වැටුප් වැඩි වෙන්න එක හේතුවක්.

ඒත් මේක අවංකව කිව යුතුයි: Go ඉගෙන ගත්තා කියලා විතරක් වැටුප වැඩි වෙන්නේ නෑ. Go ඉගෙන ගෙන ඒකෙන් distributed systems තේරුම් ගන්න අය තමයි ඉහළට යන්නේ. සහතිකයක් වගේ Go ඉගෙන ගෙන යටින් තියෙන දේවල් නොදන්න අය mid-level එකේම නවතිනවා.

6. Standard library එක නියමයි

ගොඩක් භාෂාවල simple web server එකක් හදන්න framework එකක් install කරන්න ඕන. Go වල එහෙම නෑ:

go

package main

 

import (

    "fmt"

    "net/http"

)

 

func main() {

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

        fmt.Fprintf(w, "ආයුබෝවන්! ඔබ ඉල්ලුවේ: %s", r.URL.Path)

    })

    http.ListenAndServe(":8080", nil)

}

මේක සම්පූර්ණ, production එකේ දුවන්න පුළුවන් web server එකක්. npm install නෑ, pip install නෑ. HTTP, JSON, encryption, testing, templating — හැම දෙයක්ම standard library එකේ තියෙනවා.

7. ලියපු code එක අවුරුදු 10කට පස්සෙත් වැඩ කරනවා

Go team එකට Go 1 compatibility promise කියලා පොරොන්දුවක් තියෙනවා. Go 1.0 වලට ලියපු code එක අදටත් compile වෙනවා.

Python 2 සිට Python 3 ට යද්දී ලෝකෙටම වුණු දේ ඔබට මතක නම්, මේකේ වටිනාකම තේරෙයි.

2026 දී Go කොහොම තැනකද?

මේක ලියන මොහොතේ (2026 අගෝස්තු) Go 1.26 තමයි ස්ථාවර නිකුතුව. ඒක 2026 පෙබරවාරි 10 වැනිදා එළියට ආවා, සහ Go team එකම කිව්වේ ඒක ඔවුන් නිකුත් කරපු ලොකුම release එක කියලා.

Go 1.26 වල වැදගත් දේවල්:

• new() builtin එකට expression එකක් දෙන්න පුළුවන් — කලින් new(int) විතරයි පුළුවන් වුණේ. දැන් new(42) කිව්වම 42ට point කරන *int එකක් ලැබෙනවා. හැම Go codebase එකකම තිබුණු ඒ පොඩි ptr() helper function එක දැන් ඕන නෑ.
• අලුත් Green Tea garbage collector එක default විදිහට. නවීන multi-core CPU සඳහාම හදපු එකක්.
• cgo overhead එක ~30%කින් අඩුයි — C libraries එක්ක වැඩ කරන අයට ලොකු වාසියක්.
• Goroutine leak detector (තවම experimental) — කවදාවත් වැහෙන්නේ නැති channel එකක් උඩ block වෙලා ඉන්න goroutine එකක් හොයාගන්න පුළුවන්. Debug කරන්න පැය ගාණක් ඉතුරු කරන feature එකක්.
• go fix command එක සම්පූර්ණයෙන් අලුතෙන් ලියලා — දැන් "moderniser" analyzers ගොඩක් එක්ක එනවා, ඒවා ඔබේ පරණ code එක අලුත් විදිහට ලියන්න යෝජනා කරනවා.
• අලුත් crypto/hpke package එක, experimental simd/archsimd සහ runtime/secret packages.

Go 1.27 මේ අගෝස්තු මාසයේම එළියට එන්න නියමිතයි (මේ ලියන වෙලාවේ release notes තවම draft එකක්, ඒ නිසා දේවල් වෙනස් වෙන්න පුළුවන්). එහි ලොකුම දේවල්:

• Generic methods — method එකකට තමන්ගේම type parameters declare කරන්න පුළුවන්. මේකට අවුරුදු ගාණක් තිස්සේ ඉල්ලීම් තිබුණා.
• encoding/json package එක json/v2 මත අලුතෙන් ලියලා — වේගවත්, දැඩි (stricter) JSON හැසිරීමක්.
• Standard library එකට uuid package එකක් — තව දුරටත් third-party library එකක් ඕන නෑ.
• TLS සඳහා post-quantum signatures.

Hacker News වගේ තැන්වල මේක ගැන කතාබහක් තියෙනවා. සමහරු generic methods ගැන සතුටු වෙනවා, තව සමහරු "Go සරල භාෂාවක් විදිහට තිබුණු එක නැති වෙනවා" කියලා විරුද්ධයි. ඒ තර්කය තියෙන එකම භාෂාව ජීවමාන බවේ ලකුණක්.

---

 Go වල අවාසි

මේ කොටස ලියන්නේ නැති tutorial ගොඩක් තියෙනවා. ඒක සාධාරණ නෑ.

Error handling එක වචන වැඩියි. ඔබට මේක හැම තැනම දකින්න ලැබෙනවා:

go

result, err := doSomething()

if err != nil {

    return err

}

සමහරු මේකට ආදරෙයි (හැම error එකක්ම පැහැදිලියි). සමහරු මේකට වෛර කරනවා (code එකෙන් 30%ක් if err != nil). ඔබ කොයි පැත්තේද කියලා දැනගන්න පුළුවන් ලියලා බැලුවම විතරයි.

Machine Learning / Data Science සඳහා Go හොඳ නෑ. ඒ ලෝකය Python වලට අයිතියි. NumPy, PyTorch, pandas — ඒ ecosystem එකට Go ළඟ නෑ. ML කරන්න යනවා නම් Python ඉගෙන ගන්න.

Frontend හෝ Mobile සඳහා නෙවෙයි. WebAssembly support එකක් තියෙනවා, ඒත් ඒක තාම mainstream නෑ. GUI applications සඳහාත් හොඳ තේරීමක් නෙවෙයි.

Ecosystem එක JavaScript තරම් ලොකු නෑ. npm වල package මිලියන ගාණක් තියෙනවා. Go වල ඒ තරම් නෑ. ඒත් තියෙන ඒවා සාමාන්‍යයෙන් වඩා ගුණාත්මකයි.

සාරාංශය: Go කියන්නේ backend, APIs, microservices, CLI tools, DevOps tooling සහ cloud infrastructure සඳහා විශිෂ්ට තේරීමක්. ඒ පිට තියෙන දේවලට වෙන දෙයක් හොයන්න.

ආරම්භක මාර්ගෝපදේශය: පියවරෙන් පියවර

හරි, දැන් අත පිච්චෙන කොටසට යමු.

පියවර 1: Install කරගන්න

go.dev/dl එකට ගිහින් ඔබේ OS එකට ගැළපෙන installer එක download කරගන්න. Windows, macOS, Linux — තුනටම තියෙනවා.

Install වුණාට පස්සේ terminal එකේ මේක ගහලා බලන්න:

bash

go version

go version go1.26.5 windows/amd64 වගේ දෙයක් ආවොත් හරි.

පියවර 2: ඔබේ පළමු program එක

Folder එකක් හදලා, ඒක ඇතුළේ main.go කියලා file එකක් හදන්න:

go

package main

 

import "fmt"

 

func main() {

    fmt.Println("ආයුබෝවන්, Go!")

}

Run කරන්න:

bash

go run main.go

මොකද වුණේ කියලා බලමු:

• package main - මේක executable program එකක් කියලා කියනවා (library එකක් නෙවෙයි)
• import "fmt"- formatting/printing සඳහා standard library package එක
• func main() - program එක පටන් ගන්නේ මෙතනින්

පියවර 3: Module එකක් හදන්න (මේක වැදගත්)

සැබෑ project එකකදී ඔබ පටන් ගන්නේ මෙතනින්:

bash

mkdir mytool

cd mytool

go mod init github.com/ඔබේනම/mytool

මේකෙන් go.mod file එකක් හැදෙනවා. ඒක තමයි ඔබේ project එකේ dependencies manage කරන්නේ. Node.js වල package.json වගේ, ඒත් ගොඩක් සරලයි.

පියවර 4: මූලික syntax එක

go

package main

 

import (

    "errors"

    "fmt"

)

 

func main() {

    // විචල්‍ය — දිග ක්‍රමය

    var name string = "Kamal"

   

    // කෙටි ක්‍රමය (Go වල මේක තමයි සාමාන්‍යයෙන් පාවිච්චි කරන්නේ)

    age := 25

   

    // ස්ථිරාංක

    const country = "Sri Lanka"

   

    fmt.Println(name, age, country)

   

    // Slice එකක් (dynamic array එකක්)

    numbers := []int{1, 2, 3}

    numbers = append(numbers, 4)

   

    // Map එකක්

    scores := map[string]int{"Kamal": 85, "Nimal": 92}

   

    // Loop එකක් — Go වල තියෙන්නේ for විතරයි (while නෑ)

    for i, n := range numbers {

        fmt.Printf("index %d: %d\n", i, n)

    }

   

    for name, score := range scores {

        fmt.Printf("%s: %d\n", name, score)

    }

   

    // Function එකක් call කරලා error එක handle කරනවා

    result, err := divide(10, 0)

    if err != nil {

        fmt.Println("වැරැද්දක්:", err)

        return

    }

    fmt.Println("පිළිතුර:", result)

}

 

// Go වල function එකකට values කිහිපයක් return කරන්න පුළුවන්

func divide(a, b float64) (float64, error) {

    if b == 0 {

        return 0, errors.New("බින්දුවෙන් බෙදන්න බෑ")

    }

    return a / b, nil

}

මෙතන දකින්න ඕන ලොකුම දේ: Go වල exceptions නෑ. Error එකක් වෙන්න පුළුවන් function එකක් error එකකුත් return කරනවා, ඔබ ඒක check කරනවා. මුලදී ටිකක් කරදරයි, ඒත් මාස කිහිපයකට පස්සේ ඔබට තේරෙනවා , code එක බලද්දීම කොහෙන් මොනවා වැරදෙන්න පුළුවන්ද කියලා පේනවා.

පියවර 5: Structs සහ Interfaces

Go වල classes නෑ. තියෙන්නේ structs සහ interfaces.

go

package main

 

import "fmt"

 

// Struct එකක් — දත්ත එකට තියාගන්න

type Student struct {

    Name   string

    Age    int

    Grades []int

}

 

// Method එකක් — struct එකට අමුණපු function එකක්

func (s Student) Average() float64 {

    if len(s.Grades) == 0 {

        return 0

    }

    total := 0

    for _, g := range s.Grades {

        total += g

    }

    return float64(total) / float64(len(s.Grades))

}

 

// Interface එකක් — හැසිරීම විස්තර කරනවා

type Describable interface {

    Describe() string

}

 

func (s Student) Describe() string {

    return fmt.Sprintf("%s (වයස %d), සාමාන්‍යය: %.1f", s.Name, s.Age, s.Average())

}

 

func main() {

    s := Student{

        Name:   "Saduni",

        Age:    20,

        Grades: []int{85, 90, 78},

    }

   

    var d Describable = s

    fmt.Println(d.Describe())

}

මෙතන තියෙන ලස්සන දේ: Student struct එකේ කොහෙවත් "implements Describable" කියලා ලියලා නෑ. ඕන method එක තියෙනවා නම්, ඒක automatically interface එක satisfy කරනවා. මේකට කියන්නේ implicit interfaces කියලා, සහ මේක Go වල හොඳම design තීරණවලින් එකක්.

පියවර 6: Goroutines සහ Channels

මේක තමයි Go එකේ තරු ආකර්ෂණය.

go

package main

 

import (

    "fmt"

    "sync"

    "time"

)

 

func worker(id int, wg *sync.WaitGroup) {

    defer wg.Done()   // function එක ඉවර වෙද්දී මේක run වෙනවා

   

    fmt.Printf("Worker %d පටන් ගත්තා\n", id)

    time.Sleep(time.Second)

    fmt.Printf("Worker %d ඉවරයි\n", id)

}

 

func main() {

    var wg sync.WaitGroup

   

    for i := 1; i <= 5; i++ {

        wg.Add(1)

        go worker(i, &wg)   // 'go' කියන වචනය විතරයි!

    }

   

    wg.Wait()   // හැම එකක්ම ඉවර වෙනකම් බලාගෙන ඉන්නවා

    fmt.Println("හැම දෙයක්ම ඉවරයි")

}

Channels පාවිච්චි කරලා goroutines අතරේ දත්ත හුවමාරු කරගන්න පුළුවන්:

go

func main() {

    results := make(chan string)

   

    go func() {

        time.Sleep(time.Second)

        results <- "වැඩේ ඉවරයි"

    }()

   

    msg := <-results   // දත්ත එනකම් බලාගෙන ඉන්නවා

    fmt.Println(msg)

}

Go වල ප්‍රසිද්ධ කියමනක් තියෙනවා: "Don't communicate by sharing memory; share memory by communicating." මුලදී තේරෙන්නේ නෑ. මාස දෙකකට පස්සේ තේරෙනවා.

පියවර 7: Test ලියන්න

Testing standard library එකේම තියෙනවා. math.go කියලා file එකක් තියෙනවා නම්, test එක math_test.go:

go

package main

 

import "testing"

 

func TestDivide(t *testing.T) {

    result, err := divide(10, 2)

    if err != nil {

        t.Fatalf("බලාපොරොත්තු නොවූ error එකක්: %v", err)

    }

    if result != 5 {

        t.Errorf("5 බලාපොරොත්තු වුණා, ලැබුණේ %f", result)

    }

}

Run කරන්න:

bash

go test ./...

Framework එකක් install කරන්න ඕන නෑ. මුල ඉඳලාම test ලියන පුරුද්ද හදාගන්න — Go community එකේ ඒක සම්මතයක්.

පියවර 8: Build කරලා deploy කරන්න

bash

go build -o myapp

./myapp

ඉවරයි. ඒ myapp file එක ඕනෑම Linux server එකකට copy කරලා run කරන්න පුළුවන් — Go install කරන්නවත් ඕන නෑ.

මම මේක තිත්තටම පිළිපදින්න කියලා කියන්නේ නෑ.

සති 1–2: මූලික දේවල් Tour of Go සම්පූර්ණයෙන් කරන්න. මේක browser එකේම කරන්න පුළුවන්, install කරන්නවත් ඕන නෑ. ඊට පස්සේ Go by Example එකේ examples ඔබේම අතින් type කරලා run කරන්න. Copy-paste කරන්න එපා.

සති 3–4: තනිවම දෙයක් හදන්න Command-line tool එකක් හදන්න. Task manager එකක්, file organizer එකක්, හෝ API එකකින් දත්ත ගන්න tool එකක්. JSON parse කරන එකයි, file read/write කරන එකයි මේ අවස්ථාවේ ඉගෙන ගන්න.

සති 5–6: Web net/http පාවිච්චි කරලා REST API එකක් හදන්න. Database එකකට connect කරන්න (PostgreSQL එක්ක database/sql). Middleware, routing, error handling ඉගෙන ගන්න.

සති 7–8: ගැඹුරට Goroutines සහ channels හරියටම තේරුම් ගන්න. context package එක ඉගෙන ගන්න. ඔබේ code එකට test ලියන්න. Docker container එකකට දාලා deploy කරන්න.

මේ අතරේ Effective Go කියවන්න. ඒක ටිකක් පරණයි, ඒත් Go වල "හිතන විදිහ" ඉගෙන ගන්න හොඳම ලියවිල්ල.

 

ව්‍යාපෘති අදහස් (tutorial hell එකෙන් එළියට එන්න)

1. URL shortener එකක් — HTTP, database, routing ඔක්කොම එකට
2. CLI weather app එකක් — API calls, JSON, flags
3. Concurrent web scraper එකක් — goroutines වල බලය පේන තැන
4. Rate limiter එකක් — channels සහ time package එක
5. පොඩි key-value store එකක් — Redis වගේ දෙයක්, ඒත් ඔබේම

මතක තියාගන්න: tutorial 10ක් බලනවාට වඩා project එකක් ඉවර කරන එක වටිනවා.