Whether you're curious about Go or ready to make the switch, this series takes you through the journey from a .NET developer's perspective. Each post compares familiar C# concepts with their Go equivalents, helping you build on what you already know.

New here? The posts below are listed by date. The landing page orders them as chapters, with the phrasebook first.

All Posts in Order

  1. Goodbye .csproj, Hello go.mod

    Go modules and go.mod explained for .NET developers used to NuGet and csproj. No registry, no version ranges, and why...

  2. The Phrasebook: C# Concepts in Go Terms

    A C# to Go phrasebook. Familiar .NET concepts, keywords and operators mapped to their Go equivalents in one bookmarka...

  3. You Know .NET, Now Meet the Go Toolchain

    A .NET developer's first look at the Go toolchain. go build, go run, go test and go mod compared with the dotnet CLI...

  4. No Enums? No Problem (Sort Of)

    Go has no enums. How iota, typed constants and stringer stand in for C# enums, and where the substitute falls short.

  5. Generics: Late to the Party

    Go generics compared with C# generics. Type parameters, constraints and the deliberate limits that stop you building...

  6. The Million Dollar Mistake, Differently

    Go's nil compared with C# nullable reference types. Nil pointers, nil slices, nil maps, the nil interface trap and ho...

  7. Your Class Is Now a Struct (And That's Fine)

    Go has structs, not classes. How methods, constructors and encapsulation work without inheritance, for C# developers...

  8. Where Did My Properties Go?

    Go has no properties and no public or private keywords. How capitalisation controls visibility, and how to encapsulat...

  9. if err != nil: Your New Reality

    Go error handling for C# developers. Why if err != nil replaces exceptions, how to wrap and inspect errors, and when...

  10. Panic and Recover: The Emergency Exit

    Go's panic and recover look like exceptions but are not meant to be used like them. When they belong, and why Go deve...

  11. The switch Statement You Always Wanted

    Go's switch statement compared with C# switch and pattern matching. No fallthrough by default, tagless switches, type...

  12. Stack vs Heap: Go's Escape Analysis

    How Go decides between stack and heap at compile time. Escape analysis explained for C# developers used to value type...

  13. Pointers Without the Pain

    Pointers in Go for C# developers who have never needed them. Value versus pointer receivers, when to pass by pointer,...

  14. Slices Are Not Arrays (And Neither Is List<T>)

    Go slices are not arrays and not List<T>. Length, capacity, shared backing arrays and the append gotchas that catch e...

  15. Channels: The sync You Didn't Know You Wanted

    Go channels explained for C# developers who know BlockingCollection and message passing. Buffered, unbuffered, closin...

  16. Context Is King

    Go's context.Context compared with C# CancellationToken. Cancellation, deadlines and request-scoped values, and why e...

  17. Async/Await vs Goroutines: A Mindset Shift

    Goroutines explained for C# developers who think in async/await and Task. No coloured functions, no thread affinity,...

  18. select: Multiplexing Like a Pro

    Go's select statement for multiplexing channels. Timeouts, non-blocking operations and cancellation, compared with Ta...

  19. Mutexes and WaitGroups: When Channels Aren't the Answer

    Mutexes, RWMutex, WaitGroup, Once and atomic in Go's sync package, compared with lock and SemaphoreSlim in C#. When t...

  20. The Empty Interface and Type Assertions

    Go's any type explained for C# developers. How type assertions and type switches compare to object and casting, and w...

  21. Composition Over Inheritance (For Real This Time)

    Go has no inheritance at all. How struct embedding replaces C# class hierarchies, and why it stops being frightening...

  22. Implicit Interfaces: Scary Then Brilliant

    Go interfaces are satisfied implicitly, with no implements keyword. Why that feels like chaos to C# developers and wh...

  23. Benchmarks and Profiling Out of the Box

    Go has benchmarking and profiling built into the toolchain. A C# developer's guide to go test -bench and pprof, compa...

  24. Mocking in a Language Without Mockito

    Mocking in Go without Moq or NSubstitute. Hand-written fakes, small interfaces, and generated mocks with mockery and...

  25. Multi-Module Repos: Monorepo Thinking

    Multi-module Go repositories and go.work workspaces, for teams coming from .NET solutions with shared projects and ma...

  26. Organising a Real Project

    How to organise a real Go project. Packages, internal directories, cmd layouts and why .NET's solution and namespace...

  27. Testing Without a Framework

    Testing in Go with the built-in testing package instead of xUnit or NUnit. Table-driven tests, subtests, test helpers...

  28. Configuration Without IOptions<T>

    Configuration in Go without IOptions or IConfiguration. Environment variables, flags, file parsing and the libraries...

  29. Database Access: database/sql vs Entity Framework

    Go's database/sql versus Entity Framework. Writing SQL by hand, scanning rows into structs and living without change...

  30. Debugging: Delve vs Visual Studio's Comfort

    Debugging Go with Delve after years of Visual Studio. What works, what is missing, and how to set up breakpoints and...

  31. Generate All the Things

    Code generation with go generate in place of C# reflection and source generators. Why Go developers write code that w...

  32. GORM and Friends: When You Do Want an ORM

    GORM for developers who miss Entity Framework. What the most popular Go ORM offers, why the community argues about it...

  33. HTTP Services: net/http vs ASP.NET Core

    Building HTTP services with Go's net/http instead of ASP.NET Core. Routing, middleware, handlers and JSON without a f...

  34. JSON: Struct Tags and the Marshal Dance

    JSON in Go with encoding/json and struct tags, compared with System.Text.Json and Newtonsoft. Omitempty, custom marsh...

  35. Linting and Formatting: gofmt Is Non-Negotiable

    gofmt, go vet and golangci-lint for developers used to .editorconfig debates. Why Go formatting is not up for discuss...

  36. Logging: slog and the Structured Logging Story

    Structured logging in Go with log/slog, compared with ILogger and Serilog. Handlers, attributes, context and when to...

  37. Shrinking Binaries and Build Tags

    Shrink Go binaries with ldflags and control what gets compiled with build tags. A guide for .NET developers used to s...

  38. Dockerfile for Go: Simpler Than You'd Think

    Multi-stage Dockerfiles for Go that produce images under 20MB. How static binaries and scratch base images compare wi...

  39. GitHub Actions for Go Projects

    A complete GitHub Actions workflow for Go projects. Build, test, lint, cross-compile and release, compared with the ....

  40. Health Checks and Readiness Probes

    Liveness and readiness probes in Go for Kubernetes. Health check endpoints that tell orchestrators something useful,...

  41. Kubernetes and Go: A Natural Fit

    Running Go services on Kubernetes. Graceful shutdown, resource limits, health checks and why Go and Kubernetes fit to...

  42. AWS Lambda and Go: Cold Starts That Don't Hurt

    Go on AWS Lambda cold starts in around 100ms. How that compares with .NET Lambda functions, and how to build and depl...

  43. Metrics, Traces, and Logs: The OpenTelemetry Way

    Instrumenting a Go service with OpenTelemetry. Metrics, traces and logs wired up end to end, compared with the .NET O...

  44. Single Binary Deploys: The Killer Feature

    Go compiles to a single static binary with no runtime to install. Why that changes deployment for .NET developers, an...

  45. Versioning Your Modules

    Versioning Go modules with semantic versioning and git tags. Major version suffixes, pseudo-versions and the differen...

  46. What I Actually Miss From C#

    The C# features I actually miss after months of writing Go full time. LINQ, proper enums, nullable reference types an...

  47. What I'll Never Go Back For

    The Go features a long-time C# developer would struggle to give up. Single binaries, fast builds, implicit interfaces...

  48. Six Months In: Was It Worth It?

    Six months of production Go after twenty years of C#. An honest retrospective on what was worth it, what hurt, and wh...

  49. Forty-Eight Posts on Moving From C# to Go, in the Right Order

    The complete C# to Go series, ordered as chapters for the first time. Who it is for, where to start, and three things...

  50. Range-Over-Func Iterators for People Who Miss LINQ

    Go 1.23 iterators and the slices and maps packages, set against LINQ. What you can write now, what still needs a loop...