Why Deleting Elements and Managing Goroutines in Go Is Harder Than It Looks

Go is not a simple programming language; while its syntax and many semantics are straightforward, writing practical code can be challenging.

Combining simple functions into useful code can be tricky; for example, Ruby makes array element removal trivial with list.delete_at(i) or list.delete(value), but Go requires more verbose approaches.

To delete an element at index i in Go you must use: list = append(list[:i], list[i+1:]...) To delete a value v you need a loop:

n := 0<br/>for _, l := range list {<br/>    if l != v {<br/>        list[n] = l<br/>        n++<br/>    }<br/>}<br/>list = list[:n]

Although the code looks complex, most programmers can understand it, yet it highlights Go's non‑trivial nature. The author often copies such snippets from SliceTricks to focus on solving real problems.

Performance differences also arise; copying to a new pre‑allocated slice versus a fresh slice yields measurable benchmark results:

(make([]string, 0, len(list))):<br/>InPlace               116ns/op   0 B/op   0 allocs/op<br/>NewArrayPreAlloc      525ns/op   896 B/op 1 allocs/op<br/>NewArray             1529ns/op  2040 B/op 8 allocs/op

While 1529 ns is fast enough for many cases, certain scenarios demand the optimal list.delete(value) implementation.

Managing goroutines can also be problematic; spawning millions of goroutines raises memory concerns and potential leaks.

Various patterns exist to limit goroutine counts, but none are simple. A basic example is shown below:

var (<br/>    jobs    = 20 // Run 20 jobs in total.<br/>    running = make(chan bool, 3) // Limit concurrent jobs to 3.<br/>    done    = make(chan bool) // Signal that all jobs are done.<br/>)<br/><br/>for i := 1; i <= jobs; i++ {<br/>    running <- true // Block if channel is full.<br/>    go func(i int) {<br/>        defer func() { <-running }()<br/>        if i == jobs { done <- true }<br/>        time.Sleep(1 * time.Second)<br/>        fmt.Println(i)<br/>    }(i)<br/>}<br/><br/><-done // Wait until all jobs are done.<br/>fmt.Println("done")

Comments are added to aid readability for those unfamiliar with Go, though the code does not guarantee ordered output.

Go's concurrency primitives are simple to use, yet combining them to solve real‑world problems is not.

Rich Hickey’s insight that simplicity and ease of writing are not the same reminds us that even short code does not guarantee an easy underlying concept.

Programming languages should reduce cognitive load; complex language features and the need to write extra code increase that load.

The lack of generics in Go makes certain slice operations harder, and while generics could simplify code, they also introduce additional language complexity.

Despite these challenges, the author still prefers Go, but does not consider it a language that can be mastered in five to ten minutes.

Learning a language involves more than syntax; it requires adopting its mindset. Many Python or C# developers attempt to port familiar patterns into Go, often resulting in suboptimal solutions such as embedding structs for inheritance or using panics as exceptions.

When first learning Go, it is natural to make mistakes, especially if coming from languages like Ruby.

For these reasons, the author dislikes tutorials that only cover basic syntax, as they fail to teach the deeper concepts needed to truly master Go.