Kevin

well I am working and studying masters

[Kevin @kevvvinn___]

Playing badminton for 16 years now and I still have no idea what am I shouting after winning a round

[Matt Shumer @mattshumer_]

Full guide here: https://t.co/0ALT2UHF90

[Brian Chew @brianchew]

dibo dibo dee

[Kevin @kevvvinn___]

@brianchew Wow I love gifts

[Vivian Balakrishnan @VivianBala]

Built a personal AI agent - why I did that and what it means. https://t.co/lo8SLUMD9s

[Vivian Balakrishnan @VivianBala]

Thanks @Gavriel_Cohen. You’re right. I never used an IDE. Claude Code made all edits. No @karpathy ‘vibe coding’. All I did was ‘tool assembly’ to create a utility that worked in my domain!

[Three.js @threejs]

Three.js r184 released ⛅️
https://t.co/av3RQMQOkC

[Cloudflare Developers @CloudflareDev]

Introducing the new /crawl endpoint - one API call and an entire site crawled.

No scripts. No browser management. Just the content in HTML, Markdown, or JSON.

[Kevin @kevvvinn___]

Things you learn on running man

[Abhishek Singh @0xlelouch_]

as a golang engineer, please learn:

---
foundation (beginner → competent)

the fundamentals that separate
“I can write Go” from
“I understand Go like an engineer.”

core language pillars
- Go compiler internals (escape analysis, inlining)
- value vs pointer semantics

- slices, arrays, maps → underlying representations

- interfaces (implicit), method sets
- generics (constraints, type inference)
- error handling patterns (https://t.co/cKPAQNRRmf, wrapping)
- goroutines & channels (CSP model basics)
- defer, recover, panic semantics
- Go memory model & happens-before rules
- modules, versioning, replace directives
- mental models
- why goroutines are cheap, not free
- copying vs referencing (slices vs arrays)

- why interfaces are dictionaries (itab)

- when the GC stops you, and why
- synchronous code that looks async
- Go is not JavaScript: avoid over-abstractions
essential tooling
- go build, go vet, go test -run, go work
- pprof (cpu, mem, goroutine), trace

- benchstat & go test -bench

- staticcheck, gofumpt, revive
- delves debugger
- gomodgraph for dependency sanity

architecture (intermediate → solid engineer)
- idiomatic Go patterns
- functional options pattern

- context propagation (timeouts, cancellation)

- clean architecture layering

- dependency injection (but the Go way)

- interface segregation (small, behavior-relevant)
- builder patterns without OOP bloat
- lightweight domain modeling without over-design
- concurrency engineering
- workers pools → fan-in / fan-out
- rate limiting (token bucket, leaky bucket)
- backpressure patterns

- channel ownership rules (who closes)

- mutexes vs channels (use the simplest thing)
- performance + memory
- avoid unnecessary allocations (escape analysis again)
- reuse buffers (sync.Pool, but carefully)
- avoid goroutine leaks

- reduce GC pressure (interning, pooling)

- understanding map growth, rehashing, load factor
- zero-copy patterns with slices & byte buffers
- networking
- net/http internals
- TCP, keep-alives, connection pooling
- gRPC (streams, deadlines, interceptors)

- websockets (raw vs gorilla)

- tracing request lifecycles with middleware

advanced (production-grade golang engineer)
this is where Go becomes a systems language,
not “just a simple backend language.”

- master concurrency
- building your own message bus

- actor models with goroutines

- distributed worker orchestrators

- lock-free patterns (atomic values, CAS)
- select-based multiplexing

- efficient goroutine supervision trees

systems-level Go
- writing high-performance servers (fasthttp, custom)
- memory arenas, slab allocators (Go 1.22+ experimental)
- building zero-copy parsers
- implementing your own LRU, ring buffers, skip lists
- SIMD via unsafe or intrinsics (advanced)

- encoding performance (JSON vs protobuf vs msgpack)

- meta-programming
- code generation (go:generate, stringer, protoc-gen-go, ent)
- go/types & AST tooling
- writing CLIs that generate boilerplate reliably
- reflection for dynamic systems—but sparingly
runtime internals

- goroutine scheduler (M:N model)

- garbage collector (tri-color, concurrent)
- stack growth & shrink mechanics
- syscall boundaries & cgo costs
- how kernel scheduling interacts with Go’s runtime

production (deploying Go in real systems)

- engineering discipline
- structured logging, log sampling
- observability (OpenTelemetry tracing + metrics)
- deterministic error boundaries
- autoscaling based on queue depth / latency

- chaos testing for goroutine leaks, thundering herd

- graceful shutdown (context hygiene)

- high-throughput backend design

- building APIs that sustain 100k RPS
- connection pooling in DB drivers
- batching writes + async pipelines
- event-driven architecture (NATS, Kafka, Redis streams)
- handling partial failures (circuit breakers, retries)

distributed systems

- CAP theorem with practical intuition

- idempotency & safe retries
- distributed locks (postgres advisory, redis, zk)
- leader election (raft basics)
- shard-aware design (consistent hashing)
- caching hierarchy (local → redis → CDN)

security

- validating untrusted input (never trust JSON)
- avoiding unsafe by default
- sandboxing (seccomp, gvisor)
- mTLS everywhere
- frameworks & ecosystem mastery

backend frameworks

- stdlib net/http mastery

- chi / fiber / echo / gin
- grpc-go (interceptors, streams)
- wire / fx for DI
- databases

- pgx (the correct postgres driver)

- mysql drivers, clickhouse go client

- sqlc for type-safe queries

- ent / bun / gorm (know tradeoffs)

platform
- dockerizing Go apps the right way
- multi-stage builds + static binaries

- kubernetes deployments

- service mesh (istio, linkerd)
- cloud events, lambdas

if you want to be elite:

- read Go runtime source

- write a toy database

- write a small http server from scratch
- build an in-memory cache with eviction
- write your own worker pool library
- benchmark everything
- review others’ PRs deeply

- maintain one OSS tool

If you master even 50% of this list,
you’re already operating at senior / staff levels.

And if you master 80%, you can build anything in Go.

[Neo Kim @systemdesignone]

If you want to become good at system design (in 2026), then learn these 15 case studies:

[Abdulkadir | Cybersecurity @cyber_razz]

Kubernetes in plain English

[santi @santtiagom_]

how to design a rate limiter

[Vijay Tupakula @vijaytupakula]

I'm clueless why @cluely needs $15M to build a meeting app that barely works... Unless they’re running a social media marketing company? in that case, the kids are crushing it. kudos to them!
Anyway, I built Clueless - a better, open-source, privacy-first alternative.

No tracking. No BS. No Drama

Repo just went live: https://t.co/QrnQx01NZq
⭐️ Star if it vibes. Details ↓

[Ashish Pratap Singh @ashishps_1]

LeetCode was HARD until I Learned these 15 Patterns:

1. Prefix Sum
2. Two Pointers
3. Sliding Window
4. Fast & Slow Pointers
5. LinkedList In-place Reversal
6. Monotonic Stack
7. Top ‘K’ Elements
8. Overlapping Intervals
9. Modified Binary Search
10. Binary Tree Traversal
11. Depth-First Search (DFS)
12. Breadth-First Search (BFS)
13. Matrix Traversal
14. Backtracking
15. Dynamic Programming Patterns

I've created a free resource to help you learn, practice and master these patterns plus many more.

👉 Check it out at https://t.co/FqIaiFlTvH

♻️ Repost to help others in your network

[justin @justinsunyt]

🚨 AWS is down 🚨

[Neo Kim @systemdesignone]

How to crack the system design interview

(Without getting lucky):

[sysxplore @sysxplore]

Bash Scripting Basics

[freeCodeCamp.org @freeCodeCamp]

Microservices make apps more scalable & maintainable by breaking them into smaller parts.

In this hands-on course, you'll learn to build your own microservices with Nest.js.

You’ll build a delivery app with MongoDB, Docker, and inter-service communication & learn about schema design, data validation, & more.

https://t.co/cUVk6mNtzN

[Alex Xu @alexxubyte]

How to Learn Backend Development?

[freeCodeCamp.org @freeCodeCamp]

The Go programming language is a great choice for coding the back end of your apps.

And in this course, you'll build a React front end powered by a Go backend.

You'll learn how to set up the project, build APIs, handle server-side logic, and lots more.

https://t.co/s43DNk9Zfr