If you're looking for Golang solutions to popular DSA problems, I've been documenting them on my blog.
Whether you're preparing for coding interviews or brushing up on DSA, I hope you find it useful.
https://t.co/ZdIyjqsRmW
#golang#programming#codinginterview#dsa
I'm experimenting with local LLMs like Ollama in VS Code using Cline/Continue.
Is there a great article or tutorial on getting the most out of local LLMs for coding?
Looking for tips on models, context, prompts, agents, etc.
One small Binary Search trick that’s easy to miss 👇
Instead of:
mid = (low + high) / 2
Prefer:
mid = low + (high - low) / 2
Why?
low + high can overflow for large integers.
The second formula calculates the same midpoint without that risk.
Small detail. Important habit. 🧠
Practicing DSA with Golang?
Here are some Array problems worth solving 👇
Different patterns, difficulty levels, and interview-style problems — all with Go solutions.
More coming soon.
https://t.co/k4x1WDkqyF
Created these Distributed Systems Visualisers with the help of AI. If you enjoy learning by experimenting and visualising concepts, check them out!
Topics like:
• Consistent Hashing Ring
• Rate Limiting Algorithms
• Gossip Membership
• ...and more.
https://t.co/IoafqqVUdx
@JeffDean Exciting launch! Curious—what roles is Discovery Loop planning to hire for over the coming months, and what skills would you recommend engineers focus on to prepare? @grok , feel free to weigh in too.
For those who've read Designing Data-Intensive Applications by Martin Kleppmann:
Did you read the entire book, or only the sections you needed at the time?
On production systems, if you are making a change using AI (which you most likely are), review the code generated every single time.
It will decrease the probability of a bug getting shipped to production. And the quality of the code will be much better in the long run.
Don’t just blindly accept the code written by AI.
Recently, in one of my PRs, everything was great except one very small line of change that would have broken the system on Production.
One subtle thing every engineer should deeply understand:
How your programming language stores and traverses characters.
Because "character" does NOT always mean 1 byte.
In Golang:
str := "A🚀"
fmt.Println(len(str)) // 5
Why 5?
'A' = 1 byte
'🚀' = 4 bytes (UTF-8)
This is why blindly doing:
str[i]
can break Unicode strings in production.
Correct way:
for _, ch := range str
Go converts UTF-8 bytes into runes (Unicode code points) safely.
These small low-level details matter a lot in:
Text Processing
Distributed Systems
APIs
Databases
Search Engines
International products
The deeper you understand your language internals, the fewer invisible bugs you ship.
For more details:
https://t.co/ujyknTRJBc
One of the biggest productivity killers in engineering is context switching.
You are not just switching tasks.
You are switching:
mental models
codebases
business logic
debugging state
architectural decisions
That “quick interruption” can easily cost 20-30 minutes of deep focus.
Protect uninterrupted time aggressively.
WebSockets scaling insight:
L7 load balancers are great for:
Routing
Auth
Observability
Sticky sessions
But at massive scale, many systems prefer L4 because WebSockets become long-lived TCP connections after the HTTP upgrade.
Less overhead.
Better performance.
Millions of concurrent connections become easier to handle.
Spoke with a senior engineer today.
He said:
"You don’t need to master Math or Statistics to contribute in the AI era.
There are still countless business problems that can be solved by applying existing LLMs effectively."
Very true.
A common System Design mistake:
People think autoscaling app servers solves scaling.
It doesn’t.
Caches scale via clustering and consistent hashing.
Databases scale via read replicas, sharding, and federation.
Queues scale via partitions and consumer groups.
Each stateful layer needs its own scaling strategy.
During System Design Interviews, Common Back-Of-Envelope Calculation Mistakes:
- Forgetting peak multiplier and planning only for average QPS (Queries per second)
- Ignoring replication factor and backup storage in disk math
- Using HDD (Hard disk) seek latency assumptions for SSD/NVMe-backed stores
- Treating CDN (Content Delivery Network) hit ratio as 100% without stating edge cache assumptions
- Confusing bits and bytes in bandwidth (×8 conversion)
One Golang string detail that surprises many developers:
len("你好") // 6
len([]rune("你好")) // 2
Why?
len(s) returns byte length, NOT actual character count.
Since Go strings are UTF-8 encoded:
Chinese chars → multiple bytes
Emojis → multiple bytes
If you need real character count, use:
len([]rune(s))