iiinova — where your digital self keeps evolving

Corentin GS @corentings.dev · 14/07/2025

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

110

Corentin GS @corentings.dev · 01/07/2025

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.

130

Corentin GS @corentings.dev · 04/06/2025

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.

110

Corentin GS @corentings.dev · 03/06/2025

DDD isn’t an architecture. It’s a mindset. • Business logic becomes clear • Code reads like user stories • Bugs get squashed fast • Features map to reality It’s the difference between organizing code vs. understanding the business. #cleancode

010

Corentin GS @corentings.dev · 03/06/2025

If you’re still scattering business logic across 15 files… Read this. DDD means: • Business in one place • Fewer bugs • Clearer features • Faster onboarding It changed how I code and think. #ddd

010

Corentin GS @corentings.dev · 03/06/2025

MVC shows you where to put code. DDD shows you what it should say. • One place for business logic • Domain-first thinking • Less glue code, more clarity I’d trade 5 years of patterns for 1 year of DDD. #domainmodeling

010

Corentin GS @corentings.dev · 02/06/2025

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.

120

Corentin GS @corentings.dev · 02/06/2025

The truth? Rust is brilliant. But Go is a cheat code. • Idiomatic Go in 2 weeks • Real-world output day one • No fighting with the compiler Want velocity? Go wins. Rust’s complexity isn’t worth it for most teams. #programming

010

Corentin GS @corentings.dev · 02/06/2025

Most devs learn MVC first. Big mistake. You learn structure before meaning. DDD flips it: • You code business, not boxes • Features shrink from days to hours • Logic finally has a home Learn the language before the grammar. #softwaredesign

010

Corentin GS @corentings.dev · 02/06/2025

You’re not building an OS. You’re building CRUD APIs. Stop over-engineering: • Go gets new hires productive in days • Rust drops team velocity by 50% • Most apps don’t need a borrow checker Choose speed over struggle. #devlife

000

Corentin GS @corentings.dev · 01/06/2025

The most brilliant engineers I know don’t always pick the “best” tech. They choose what yields the best results quickly. • Go reads like English • Devs ship in weeks • Hiring is easy • Teams move fast Rust? It slows you down for marginal gains. #softwareengineering

000

Corentin GS @corentings.dev · 01/06/2025

Choosing Rust for CRUD services is like buying a jet to drive to work. Sure, it’s fast. But you’ll burn time, money, and team morale just trying to park it. Go is simpler, faster, and way more practical. You can use the right tool for the real-world job. #backend

120

Corentin GS @corentings.dev · 29/05/2025

But if you're building microservices, backend APIs, or distributed systems, Go or even C# tends to be a better choice. Simpler tooling, faster development, easier onboarding. It's not about switching — it's about picking the right tool for the job.

000

Corentin GS @corentings.dev · 29/05/2025

Both languages have their place — it really depends on what you're building. If you're writing an OS, a device driver, or anything performance-critical where memory safety without a GC matters — Rust (or even Zig) is a great fit.

100

Corentin GS @corentings.dev · 29/05/2025

I played a bit with it a few years ago but I don't have a lot of experience. Why?

100

Corentin GS @corentings.dev · 27/05/2025

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.

140

Corentin GS @corentings.dev · 27/05/2025

Want to build stunning CLI tools in Go? Use Bubbletea. • Beautiful text UIs • Elegant architecture • Fun to use Make your terminal apps feel like magic. #cli #golang #opensource

030

Corentin GS @corentings.dev · 26/05/2025

Tired of "works on my machine"? Use Dev Containers. • Instant dev environment setup • Reproducible across the team • All dependencies pre-installed No more setup hell. Just code. #devcontainers #docker #devops

010

Corentin GS @corentings.dev · 26/05/2025

The best messaging system I’ve used in 2025: NATS. • Lightning-fast pub/sub • Lightweight & reliable • Supports clustering + persistence Easier than Kafka. More robust than Redis. Built for scale. #eventdriven #golang #scalability

040

Corentin GS @corentings.dev · 26/05/2025

Go-task made me ditch Makefiles for good. • YAML-based task runner • Dependency-aware • Cross-platform • Built-in variable support Cleaner builds, easier automation. Perfect for Go projects. #golang #buildtools

140

Corentin GS @corentings.dev · 25/05/2025

Debugging microservices used to be painful—until Jaeger. • Full request tracing • Visual bottleneck mapping • Instant visibility into distributed systems If you're scaling services, this is non-negotiable. #microservices #observability #devops

010

Corentin GS @corentings.dev · 25/05/2025

The single best Go code quality tool: golangci-lint. • Runs 40+ linters • Catches bugs pre-commit • Flags performance issues • Integrates seamlessly into CI/CD Set it up once. Let it guard every PR. #golang #devtools

030

Corentin GS @corentings.dev · 25/05/2025

Bonus: Bubbletea - Go's elegant TUI framework for building beautiful command-line tools users want to use. #GoLang #BackendDev #DevTools #Microservices #SoftwareEngineering #Programming #TechStack What's your essential backend tool? 👇

120

Corentin GS @corentings.dev · 25/05/2025

NATS: The messaging system scales without complexity. Lightweight, high-performance pub/sub with built-in clustering, persistence options, and incredible throughput. Simpler than Kafka, more reliable than Redis.

110

Corentin GS @corentings.dev · 25/05/2025

Dev Containers: Consistent development environments that eliminate "works on my machine" forever. Reproducible, isolated environments with all dependencies pre-configured. Your entire team runs identical setups instantly.

110

Corentin GS @corentings.dev · 25/05/2025

go-task: A modern alternative to Make that makes sense. YAML-based task runner with dependency management, cross-platform support, and built-in variable interpolation. Perfect for automating build pipelines and development workflows.

241

Corentin GS @corentings.dev · 25/05/2025

Jaeger: Distributed tracing that shows you exactly where your microservices are failing. Essential for debugging complex systems - visualizes request flows, identifies bottlenecks, and makes mysterious performance issues crystal clear.

120

Corentin GS @corentings.dev · 25/05/2025

golangci-lint: The ultimate Go code quality enforcer that catches bugs before they ship. Runs 40+ linters simultaneously, finds performance issues, enforces best practices, and integrates seamlessly into CI/CD pipelines.

120

Corentin GS @corentings.dev · 25/05/2025

The six #backend tools that transformed how I build production systems in 2025. After 4 years of coding 7/7, these are the non-negotiable tools in my stack. Thread 👇

120

Corentin GS @corentings.dev · 21/05/2025

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.)

100

Corentin GS @corentings.dev · 21/05/2025

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.

100

Corentin GS @corentings.dev · 16/05/2025

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.

000

Corentin GS @corentings.dev · 16/05/2025

💥 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.

100