Go slices have a sneaky memory trap.
A tiny slice can keep a massive underlying array alive.
You might only need 10 bytes, but accidentally retain a 100MB backing array.
Memory efficiency isn't always about how much data you can see. #golang
Go has a special talent for humbling developers.
An interface holding a typed nil pointer is NOT nil.
The interface still carries the dynamic type, so err != nil can be true even when the underlying pointer is nil.
Subtle. Dangerous. Beautiful.
C# structs are copied by value.
That sounds simple until your struct becomes large or gets passed around frequently.
Understanding when to use readonly struct, in and ref can make a real difference in performance-sensitive code. #csharp#NET
Go's garbage collector uses a concurrent, tri-color mark-and-sweep approach with write barriers.
I find it fascinating that memory management can happen largely behind the scenes while application code remains relatively simple. #golang#Gophers#Coding
A Go detail worth remembering: arguments to a deferred function are evaluated when the defer statement executes, not when the function returns.
Small language details like this can completely change how you reason about execution order. #golang#Gophers
Go's scheduler is fascinating.
Goroutines aren't simply mapped one-to-one onto OS threads.
The G-M-P model coordinates goroutines, machine threads and processors.
There's a lot of engineering hiding behind the simplicity of go myFunction(). #golang#Gophers
Go slices are more interesting than they look.
A slice is essentially a descriptor containing a pointer, length and capacity.
Two slices can share the same underlying array without you realizing it. That's where some interesting bugs begin. #golang#Gophers
One fascinating thing about Go is escape analysis.
A variable declared inside a function doesn't necessarily live on the stack. If it escapes its scope, the compiler may allocate it on the heap.
The compiler makes decisions you don't always see. #golang#Gophers
Building an API is easy compared to thinking about everything that can go wrong.
Timeouts, duplicate requests, race conditions, database failures and unexpected traffic.
The real backend engineering starts when you think beyond the happy path.
The more I explore C# async/await, the more I appreciate how readable asynchronous code can be.
But understanding what's happening underneath is just as important as knowing how to use the keywords.
Go's error handling teaches you something important:
Errors aren't exceptional surprises. They're part of your program's normal flow.
It might look repetitive, but being explicit about failure has its own beauty. #golang#Gophers
The more I work with Go, the more I appreciate its simplicity.
Simple syntax. Explicit errors. Interfaces. Goroutines. Channels.
But simple doesn't mean easy to master.
With great power comes great responsibility. Go demands engineering discipline. #golang#Gophers
Tracking utility payments down to the last shilling! 💧 Here's Receipt No. 32 for August 2026 water charges generated automatically via Willcoll. #PropTech#RealEstate#Golang#BuildInPublic
Automated professional receipts generated instantly through Willcoll!
Here's Receipt No. 31 issued for August 2026 rent at The Runda's Arcade. Clean documentation makes tenant management seamless. #PropTech#RealEstate#Golang#BuildInPublic
From PDF generation directly to real-world deployment! 🏢 Here's a look at the All-in-One Payments Schedule PDF generated by Willcoll for The Runda's Arcade (August 2026). Automated schedules and reporting make property management seamless. #PropTech#RealEstate#BuildInPublic