Corentin GS
LightNews LightNews
banner
corentings.dev
Corentin GS
@corentings.dev
33 followers 57 following 220 posts
Teaching Go for cloud-native microservices to backend beginners. Self-taught developer with 5 years of experience. Making the practical course I wish existed.
Posts Replies Media Videos
corentings.dev
2. Custom Error Types Pattern: Attach rich context via structs. Use case: Precise HTTP-status mapping, structured logs, Sentry tags.
July 14, 2025 at 9:18 AM
corentings.dev
1. Error-as-Value (Idiomatic Go) Pattern: Return error as a normal value. Why it matters: Prevents panics and keeps control flow explicit in micro-services. 1. Error-as-Value (Idiomatic Go) Pattern: Return error as a normal value. Why it matters: Prevents panics and keeps control flow explicit in micro-services. 1. Error-as-Value (Idiomatic Go) Pattern: Return error as a normal value. Why it matters: Prevents panics and keeps control flow explicit in micro-services. 1. Error-as-Value (Idiomatic Go) Pattern: Return error as a normal value. Why it matters: Prevents panics and keeps control flow explicit in micro-services.
July 14, 2025 at 9:18 AM
corentings.dev
Go error handling is often criticized for being “too verbose.”

Swipe the carousel to see why that criticism misses the point.

#Golang #Go
🛡️ 7 Go Error Handling Patterns Real-world examples to bulletproof your backend 🛡️ 7 Go Error Handling Patterns Real-world examples to bulletproof your backend 🛡️ 7 Go Error Handling Patterns Real-world examples to bulletproof your backend 🛡️ 7 Go Error Handling Patterns Real-world examples to bulletproof your backend
July 14, 2025 at 9:18 AM
corentings.dev
👨‍💻 Why focus on these languages? If you want to build a strong foundation as a software engineer, learning languages that teach core computer science concepts is crucial. 👨‍💻 Why focus on these languages? If you want to build a strong foundation as a software engineer, learning languages that teach core computer science concepts is crucial. 👨‍💻 Why focus on these languages? If you want to build a strong foundation as a software engineer, learning languages that teach core computer science concepts is crucial.
July 1, 2025 at 4:00 PM
corentings.dev
These languages won’t get you a dev job tomorrow.

But they’ll teach you how to think, adapt, and face any coding challenge.

Hardcore? Sure.
But you don’t become a Jedi without sacrifice.

#Programming #CodeNewbie #LearnToCode #SoftwareEngineering
🔑 3 Key Programming Languages for Beginners Who want to become Elite Software Engineers💡 And it’s easier than you think. 🔑 3 Key Programming Languages for Beginners Who want to become Elite Software Engineers💡 And it’s easier than you think. 🔑 3 Key Programming Languages for Beginners Who want to become Elite Software Engineers💡 And it’s easier than you think. 🔑 3 Key Programming Languages for Beginners Who want to become Elite Software Engineers💡 And it’s easier than you think.
July 1, 2025 at 4:00 PM
corentings.dev
How Go's context package transforms chaotic goroutine sprawl into orchestrated control flow. From resource leaks to graceful cascading cancellations—context is the unsung hero of distributed Go systems.
#golang #programming
Screenshot essay titled 'Context: Go's Elegant Weapon Against Concurrency Chaos', discussing the importance of the Go programming language's context package in managing concurrency. The essay describes how context helps coordinate goroutines by propagating cancellation signals, using an example of a microservice handling HTTP requests. It details a code snippet demonstrating the use of context with timeout and how goroutines cleanly handle cancellation. The text emphasizes context's composability and its role in preventing resource leaks in distributed systems. The overall message encourages the adoption of context in Go applications to create efficient and responsive systems.
June 4, 2025 at 8:00 AM
corentings.dev
Context leaks in Go are silent killers.
They don’t crash your app — they slowly drain it.
Unreleased goroutines = invisible technical debt.

Fix it before it breaks you.
#golang #backend
A screenshot essay titled 'Context Leaks: The Invisible Technical Debt Draining Your Go Systems.' The body discusses the dangers of context leaks in Go programming, which silently consume memory and degrade system performance without raising immediate alarms. It highlights the accumulated negative effects of unreleased goroutines and dangling contexts, comparing them to toxic waste. The importance of discipline in managing contexts and goroutines is emphasized, along with practical solutions like building structured cancellation trees and using profiling tools. The conclusion stresses that context leaks contribute to system fragility, ultimately costing trust in production environments.
June 2, 2025 at 7:00 PM
corentings.dev
Stop trying to write "perfect" code as a beginner.
My early Go app: 6 layers, 3 frameworks, total mess
My rewrite: Just stdlib, 10x faster
Your "failures" teach more than tutorials.
#coding #webdev #buildinpublic
Screenshot essay titled '3 Tiny (But Powerful) Mental Shifts To Master Backend Development' detailing the author's journey from being a college dropout in 'tutorial hell' in 2021 to successfully building a complex Go chess library and leading backend projects. The essay outlines three mental shifts: 1) Stop aiming for 'perfect' code from the start, emphasizing the learning gained from failed projects. 2) Embrace beginner's curiosity to try new frameworks, tackle challenging projects, and ask questions that foster understanding. 3) View failures as valuable data rather than defeats, learning from complexities to achieve simplicity in code. The text encourages recognizing the 'messy phase' as a vital part of the learning process.
May 27, 2025 at 10:00 AM
corentings.dev
True Go concurrency mastery starts with understanding the mental model. Not just writing code that runs in parallel... But knowing how and why it works the way it does. True Go concurrency mastery starts with understanding the mental model. Not just writing code that runs in parallel... But knowing how and why it works the way it does.
May 21, 2025 at 7:30 PM
corentings.dev
The basics are easy: • go func() • channels • select But mastery? That’s a different game entirely. The basics are easy: • go func() • channels • select But mastery? That’s a different game entirely. The basics are easy: • go func() • channels • select But mastery? That’s a different game entirely. The basics are easy: • go func() • channels • select But mastery? That’s a different game entirely.
May 21, 2025 at 7:30 PM
corentings.dev
Most Go devs know the syntax. Few master the model. This carousel breaks down what really matters. Save it. Share it. Level up your Go game.
Most Go developers don’t struggle with syntax. They struggle with concurrency. (And after 4 years in production, I’ve seen exactly why.) Most Go developers don’t struggle with syntax. They struggle with concurrency. (And after 4 years in production, I’ve seen exactly why.) Most Go developers don’t struggle with syntax. They struggle with concurrency. (And after 4 years in production, I’ve seen exactly why.) Most Go developers don’t struggle with syntax. They struggle with concurrency. (And after 4 years in production, I’ve seen exactly why.)
May 21, 2025 at 7:30 PM
corentings.dev
Want to master Go concurrency? Stop memorizing syntax.
After 4 years of production Go: The real secret isn't about knowing every feature - it's about knowing when NOT to use them.
A thread on building robust concurrent systems 🧵👇
#golang #programming
A screenshot essay titled '5 Key Steps to Mastering Advanced Concurrency in Go' that discusses the journey of mastering concurrency in Go programming. The author reflects on their four years of experience in building production systems, emphasizing that true mastery involves understanding the mental model of Go's concurrency rather than merely memorizing syntax or best practices. Key points include the importance of understanding goroutines and the Go scheduler, the role of channels as synchronization primitives, the effective use of context for system reliability, and the necessity of thoughtful practice through projects. The essay concludes with the insight that elegant concurrent code is about using the right features at the right time, highlighting the need for a deep understanding of fundamentals.
May 21, 2025 at 2:32 PM
corentings.dev
Most devs over-engineer because they start with tools, not problems.
Start with why, design with clarity, build with boring code.

That’s the Fundamentals-First way.
A screenshot essay titled 'Stop Letting Frameworks Design Your System'. The body discusses how most apps fail because they are constructed backwards, with developers prioritizing libraries and structures from external sources rather than addressing core problems. It emphasizes the importance of designing systems from first principles, advocating that a successful system should prioritize simplicity, speed, and reliability.
May 16, 2025 at 3:00 PM
corentings.dev
💥 Rewrote an old Go app I built as a junior.

Back then: 6 layers, 3 frameworks, benchmark-driven madness.

Now: Just stdlib, clear logic, no fluff.

✅ 10x faster
✅ Half the code
✅ Zero confusion

Lesson?
Simplicity scales. Start with fundamentals.
Screenshot essay titled 'The Fundamentals-First Architecture Model'. It discusses a simple approach to building durable software by focusing on fundamental principles instead of trendy frameworks. The essay outlines key strategies: 1) prioritizing core principles by understanding the problem before choosing tools; 2) making design decisions explicit to avoid letting the framework dictate the structure; 3) using simplicity as an advantage by keeping code straightforward. The author shares personal experience of rewriting an old app to demonstrate the benefits of this model, highlighting how following fundamental principles leads to clarity, reduced complexity, and adaptability in software development.
May 16, 2025 at 8:30 AM
corentings.dev
🚀 Want to make your Go apps faster and more scalable?

Use resource pooling.

✅ Lower latency
✅ Fewer allocations
✅ Better scalability

Stop wasting CPU cycles. Reuse what you can. Build smarter. 🧠💡 #golang #backend #performance
A screenshot essay titled "Why You Should Use Resource Pooling in Go" discussing the benefits of resource pooling for improving performance in Go applications. The text outlines three main benefits: 1) Lower Latency, explaining how resource pools reduce delays by reusing existing connections; 2) Fewer Allocations, emphasizing that resource pools minimize memory use and CPU workload by reducing the number of new resource creations; 3) Better Scalability, highlighting how pools help manage traffic spikes and ensure app stability. The essay concludes that utilizing resource pools makes Go applications faster, lighter, and easier to scale.
May 15, 2025 at 5:54 PM
corentings.dev
Trace First, Always Guessing is cheap. Profiling is truth. Use pprof, runtime/trace, flamegraphs Look at CPU time, allocations, blocking Slow paths often aren’t where you think 👉 Trace before you touch anything.
May 15, 2025 at 6:30 AM
corentings.dev
The Problem Your endpoint isn’t “slow.” Until it gets hit 10,000 times. That’s when the lag shows up. Here’s how I turned 500ms → 50ms. And what most Go devs forget. The Problem Your endpoint isn’t “slow.” Until it gets hit 10,000 times. That’s when the lag shows up. Here’s how I turned 500ms → 50ms. And what most Go devs forget. The Problem Your endpoint isn’t “slow.” Until it gets hit 10,000 times. That’s when the lag shows up. Here’s how I turned 500ms → 50ms. And what most Go devs forget. The Problem Your endpoint isn’t “slow.” Until it gets hit 10,000 times. That’s when the lag shows up. Here’s how I turned 500ms → 50ms. And what most Go devs forget.
May 15, 2025 at 6:30 AM
corentings.dev
Most “slow” endpoints don’t look broken.
Until they hit production.

I had one running at 500ms.
Not terrible… until it tanked everything under real traffic.

Here’s exactly how I cut it to 50ms — and what most Go developers miss along the way.

Swipe through 👇
From 500ms to 50ms A Real Fix for Sluggish Endpoints (for Go developers who want real speed, not theory) From 500ms to 50ms A Real Fix for Sluggish Endpoints (for Go developers who want real speed, not theory) From 500ms to 50ms A Real Fix for Sluggish Endpoints (for Go developers who want real speed, not theory) From 500ms to 50ms A Real Fix for Sluggish Endpoints (for Go developers who want real speed, not theory)
May 15, 2025 at 6:30 AM
corentings.dev
Is Clean Architecture always the answer for your #Go monolith? 🤔
I found more speed & sanity by ditching complex layers for Vertical Slice Architecture.
My pragmatic journey from architectural dogma to #VSA clarity. Are you ready to slice?

#Golang #SoftwareDesign #PragmaticDev
Screenshot essay titled 'Trading Layers for Slices: A Go Developer's Story of Finding Simplicity and Power in Vertical Slice Architecture.' The text discusses the challenges of strict layered architecture in backend development, particularly in Go, highlighting the author's journey towards Vertical Slice Architecture (VSA). It captures how layered approaches created complications in feature changes, while VSA allowed for organizing by feature with self-contained slices. The author notes the transformative effects of refactoring into cohesive slices, emphasizing benefits such as increased development speed, simpler debugging, and improved onboarding. The essay concludes with a call to identify progress barriers and strategize to overcome them.
May 11, 2025 at 9:49 AM
corentings.dev
Nobody tells you this:
A well-designed modular monolith can get your product to market way faster than microservices -less complexity, fewer headaches, more shipping 🚀
Don’t over-engineer. Start simple, scale smart. #SoftwareEngineering
Screenshot essay titled 'Modular Monoliths: Keep It Simple!' presenting key insights into modular monoliths. The body outlines common misconceptions, emphasizing that complex tools aren't necessary, modules don't need to be perfect initially, and direct method calls are preferable to event buses. It highlights trends showing a resurgence in modular monoliths due to their simplicity and efficiency compared to microservices. The author provides actionable steps for building better modular systems, focusing on defining modules by business functions, setting rules for dependencies, and starting with a limited number of broad modules. The message encourages avoiding unnecessary complexity in system design.
May 9, 2025 at 3:31 PM
corentings.dev
Legacy code: I am your inheritance! 🧬
This #MayThe4th, embrace your codebase's heritage. Map dependencies, document wisdom, and refactor with purpose. Every line of code has a story. #DevLife #StarWarsDay
A screenshot essay titled 'Legacy Code Revelations - Embracing Your Codebase's Heritage' discusses the challenges and responsibilities of managing legacy code. It emphasizes the value of understanding and respecting the history behind a codebase, comparing the revelation of taking over a legacy system to a dramatic familial revelation. The author encourages developers to approach legacy code as an inheritance rather than an obstacle, suggesting methods such as archaeological debugging and documenting configurations. They stress the importance of understanding past decisions, embracing purposeful refactoring, and planning modernization strategies, ultimately highlighting the narrative that every codebase represents in terms of business needs and technical evolution.
May 4, 2025 at 9:30 PM
corentings.dev
I have the architectural high ground! 🏔️
This #StarWarsDay, level up your system design: decouple like a Jedi, scale like the Empire (but better), and keep your resilience patterns stronger than beskar. #SystemDesign #MayThe4th
A screenshot essay titled 'Having the High Ground - A Jedi's Guide to System Architecture'. The essay begins with a bold quote from Obi-Wan about having the high ground, connecting strategic positioning in duels to system architecture. It discusses the importance of good architecture in overcoming scaling challenges, recommending battle-tested patterns, the implementation of circuit breakers, and ensuring system observability. It advises keeping bounded contexts clear, designing small failure domains, and building resilience. The essay emphasizes planning for future growth with horizontal scaling and caching strategies, highlighting the value of technical superiority and clear documentation. The conclusion urges to empower teams with strategic advantages.
May 4, 2025 at 7:30 PM
corentings.dev
It's a trap! 🚨
'We'll fix it later' is the biggest deception in tech. That temporary hack? Still there after 3 years. That quick fix? Now it's load-bearing. This #MayThe4th, resist the dark side of technical debt! #DevLife #StarWarsDay
A screenshot essay titled 'It's a Trap! - The Technical Debt Deception' discusses the risks of postponing technical debt resolution in software development. The text warns against common phrases like 'We'll clean it up later' and highlights how temporary fixes can lead to long-lasting problems. It compares the pitfalls to the Rebels' risky approach to the Death Star, emphasizing that shortcuts often lead deeper into technical debt. The essay lists warning signs developers should recognize, including neglecting test implementation, hardcoding, and inadequate documentation. Ultimately, it stresses the importance of addressing issues immediately rather than deferring them, suggesting that acting now is better than postponing quality, with a nod to Star Wars.
May 4, 2025 at 5:15 PM
corentings.dev
These aren't the bugs you're looking for! 🐛
This #StarWarsDay, debug like a Jedi: trust your monitoring, question your assumptions, and remember—the real issue often hides in plain sight. #DevLife #MayThe4th
A screenshot essay titled 'Atomic Essay: These Aren't the Bugs You're Looking For - A Jedi's Guide to Debugging.' The content discusses common pitfalls in debugging for developers, using references to Star Wars. It emphasizes how developers can be misled by deceptive errors and logging. The essay compares debugging to a Jedi's approach, suggesting the use of monitoring tools for accurate diagnosis. It lists potential problems that might go unnoticed and stresses the importance of a clear mindset, akin to a Jedi's focus. The author encourages programmers to pause and reconsider their debugging strategies, with a playful nod to May the 4th as Star Wars Day.
May 4, 2025 at 3:30 PM
corentings.dev
Do or do not. There is no 'try' in production. 🧙‍♂️ This #MayThe4th, channel your inner Yoda: test thoroughly, monitor wisely, deploy confidently. The Force of robust systems, strong with you it will be. #DevOps #StarWarsDay
Screenshot essay titled 'Yoda's Guide to Production Excellence,' containing humorous and serious advice for deploying backend systems, inspired by Yoda from Star Wars. The text emphasizes the importance of disciplined practices, automated testing, and observability in creating reliable systems. Key phrases include 'Try to deploy to production, I will,' and 'Your production environment is your Dagobah.' The author stresses not merging untested code or skipping performance reviews and advises on being proactive with monitoring, likening good practices to Jedi training. Overall, the message promotes respect for the production environment and thorough preparation in software deployment.
May 4, 2025 at 1:30 PM