Corentin GS

@corentings.dev

34 Followers 57 Following

Teaching Go for cloud-native microservices to backend beginners. Self-taught developer with 5 years of experience. Making the practical course I wish existed.

2. Custom Error Types Pattern: Attach rich context via structs. Use case: Precise HTTP-status mapping, structured logs, Sentry tags.
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.
🛡️ 7 Go Error Handling Patterns Real-world examples to bulletproof your backend
👨‍💻 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.
🔑 3 Key Programming Languages for Beginners Who want to become Elite Software Engineers💡 And it’s easier than you think.
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.
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.
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.
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.
The basics are easy: • go func() • channels • select But mastery? That’s a different game entirely.
Most Go developers don’t struggle with syntax. They struggle with concurrency. (And after 4 years in production, I’ve seen exactly why.)
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.
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.
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.
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.
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.
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.
From 500ms to 50ms A Real Fix for Sluggish Endpoints (for Go developers who want real speed, not theory)
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.
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.
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.
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.
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.
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.
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.
A screenshot essay titled 'Atomic Essay: Our Last Hope - The Obi-Wan Guide to Tech Mentorship'. The essay humorously compares the role of senior developers to Obi-Wan Kenobi guiding junior developers. It emphasizes the importance of mentorship, knowledge sharing, and teaching with patience. Key points include the need for senior developers to explain algorithms and performance impact, conduct thorough code reviews while focusing on understanding, and document experiences to aid future developers. The author encourages seniors to take on a mentoring role, highlighting that even experienced developers like Obi-Wan started as novices. Concludes with a motivational message for May the 4th, urging mentors to support junior developers.
Screenshot essay titled 'This Is The Way - The Mandalorian Developer's Code' discussing principles for reliable system development inspired by Mandalorian culture. The text emphasizes the importance of discipline in coding and ethical practices, suggesting that great code is like beskar steel. It describes the community of developers as a tribe, highlighting coding conventions, deployment responsibilities, and best practices. Key tools mentioned include monitoring, logging, backups, and code reviews. The essay compares onboarding junior developers to taking on foundlings, stressing the importance of team support and shared practices. The conclusion underlines the importance of honoring the code, writing tests, reviewing code, and protecting production environments.
An illustrated essay titled 'May the 4th Be With You: Open-Source Dev Wisdom,' featuring whimsical and humorous references from Star Wars to convey advice for open-source developers. The essay encourages commitment to small tasks, collaboration, and providing clear documentation. It uses analogies like wielding keyboards as lightsabers and the open-source community as the Rebel Alliance. Key points emphasize the importance of writing clear issue reports and treating README files as crucial for attracting project contributors. The writer wishes to promote a spirit of teamwork and good coding practices, concluding with a positive note on contributing to the open-source community.
Screenshot essay titled 'Unlimited Power - A Cautionary Tale of System Scaling'. The text discusses the allure of unlimited computing power for developers, comparing AWS and Kubernetes to a Death Star and an Imperial fleet. It emphasizes that true power lies in efficiency, advising against overprovisioning. Key advice includes: smart resource allocation, profiling before scaling, monitoring resource use, optimizing algorithms, and wise caching to avoid excessive costs. It urges developers to be intentional in scaling decisions, checking database indexing, query optimization, caching strategies, and potential memory leaks. The essay concludes by warning that unchecked power ultimately leads to inefficiency and high costs.
A screenshot essay titled 'When 900 Years Old You Reach - The Art of Code Longevity'. The body contains a reflection on the longevity of code systems, using a quote from Yoda to explore why some systems thrive while others deteriorate. It emphasizes the importance of simplicity, resilience, and focused functionality for enduring code. The author discusses principles that contribute to longevity, such as clear interfaces, robust error handling, and documentation. The essay further notes that not all code should last indefinitely and highlights the importance of knowing when to maintain legacy systems versus sunset them or refactor technical debt. It concludes with a call to build code that endures, comparing good systems to fine Corellian brandy.
Screenshot essay titled 'Now This is Podracing! - The Zero-Allocation Speed Run'. The text discusses the importance of zero-allocation patterns in high-performance programming, comparing it to racing pods through Beggar's Canyon. It emphasizes the necessity of eliminating overhead and minimizing allocations for optimal performance. The essay provides insights on tuning high-performance systems, using tools like object pools and preallocated buffers, and stresses the value of profiling and monitoring memory usage. It warns against premature optimization while urging programmers to optimize where necessary for critical systems.
A screenshot essay titled 'I've Got a Bad Feeling About This - The Open Source Crisis' discusses the challenges faced by open source maintainers. The text describes the feelings developers experience when critical dependencies show signs of neglect, such as outdated commits and unresolved issues. It emphasizes the reliance of the digital landscape on a few unpaid maintainers who carry the burden alone. The essay lists symptoms of troubled projects, including accumulating issues and delayed responses, and highlights the precariousness of using libraries maintained by overworked developers. It calls for action, urging the public to sponsor maintainers, contribute time and skills, and recognize the importance of maintenance work. The closing remarks stress the urgent need for corporate support to ensure the sustainability of open source dependencies in the community.
Screenshot essay titled 'How I Dropped Out of College and Earned the Trust to Lead in Tech—In Just 3 Years.' The text discusses the author's journey of self-teaching backend development after dropping out of college, detailing emotional challenges and isolation. Key lessons learned include the importance of daily consistency, starting small, and the impact of sacrifice. The author reflects on overcoming insecurity without formal credentials and challenges conventional advice about career paths. The narrative emphasizes personal growth, resilience, and the unique journey towards becoming a trusted tech leader.
Screenshot of an essay titled 'The Framework Trap: Why Most Self-Taught Developers Never Break Through'. The text discusses the importance of mastering backend engineering fundamentals and building real-world applications instead of constantly chasing new frameworks. It highlights two key ways to become a great backend engineer: mastering systems and architecture, and building production-grade applications. The author warns against habits like tutorial hell and learning obsolete tools, emphasizing the need for a deep understanding of system architecture. The essay concludes with advice on sticking to one backend stack for at least six months, building real systems, and studying large-scale architectures.
Screenshot essay titled 'From CRUD to Production-Grade: The Hidden Path Most Tutorials Don't Teach'. The content discusses the author's experience in backend engineering, emphasizing five optimization techniques for improving database performance. Technique #1 explains connection pooling, detailing how to create a configurable pool and monitor its health. Technique #2 focuses on intelligent caching, offering advice on data access patterns and cache management. Technique #3 covers asynchronous processing, suggesting the use of background jobs over synchronous operations. Technique #4 highlights the importance of proper indexing, advising on query analysis and compound index creation. Lastly, Technique #5 stresses the need for load testing to identify bottlenecks. The essay is insightful and practical, aimed at backend developers seeking performance improvements.
A screenshot essay titled '5 Key Steps to Mastering Advanced Concurrency in Go', discussing the significance of mastering Go's concurrency model for backend engineering. It includes five main points: 1) Understanding Go's concurrency model and goroutines, illustrated by an example of a web scraper improved from 30 minutes to under 2 minutes using goroutines. 2) Mastering channel communication for safe inter-process communication, as shown by a case where crashes stopped after switching from shared memory to channels. 3) Implementing mutex to avoid race conditions, supported by an example of a game service that improved balance accuracy with mutex locks. 4) Controlling goroutine lifecycles with context to prevent leaks, improving a memory leak issue in an early service. 5) Emphasizing the importance of real-world practice alongside theory.
Screenshot essay titled 'Learn by Building: Why That Project You Abandoned Still Mattered'. The essay discusses the valuable lessons learned from unfinished projects, emphasizing that they teach problem-solving skills, stack fundamentals, personal interests, muscle memory through repetition, and resilience in the face of failure. Each section highlights how even abandoned projects contribute to a developer's growth by providing real-world experience and insights. Key points include practicing problem-solving, understanding stack fundamentals, discovering personal preferences, building muscle memory through repeated tasks, and fostering grit by tackling difficult challenges. The closing statement encourages continued building, asserting that every effort is significant.
Screenshot essay titled 'From localhost to Production: The Real-World Backend Skills They Don't Teach in Coding Bootcamps'. The content discusses the challenges developers face when transitioning from local development to production environments. It presents a 'Production Readiness Checklist' that includes five key topics: 1) Configuration Management emphasizing the use of environment variables, 2) Error Handling & Logging highlighting the importance of structured logging, 3) Performance Monitoring focusing on health checks and metrics, 4) Database Optimization detailing indexing and connection pooling, and 5) Security Hardening with strategies for input sanitization and CORS policies. The essay concludes with a reminder that ensuring operational excellence is crucial for user satisfaction.
A screenshot of an essay titled 'The Only 3 Linux Distros Developers Need in 2025'. The body text discusses three key Linux distributions: Fedora, Arch Linux, and Bluefin. It describes Fedora as a balanced choice for developers seeking stability and up-to-date features, emphasizing its six-month release cycle. Arch Linux is portrayed as a customizable option for developers who prefer to build their environment from scratch, highlighting its comprehensive Arch User Repository. Bluefin is presented as a specialized distribution that facilitates cloud-native development and deployment, based on Fedora Silverblue. The conclusion encourages readers to choose a distro that aligns with their individual development philosophy.
Screenshot essay titled '4 Effective Memory Management Techniques for Go Developers' providing insights on Go memory management for system performance. Highlights include: 1. Using 'defer' for resource cleanup ensures proper closure of files and network connections, enhancing server reliability. 2. Optimizing garbage collection (GC) through tuning 'GOGC' and understanding allocation patterns for consistent performance. 3. Utilizing 'Nil' to minimize unused memory by initializing maps, slices, or channels only when necessary, saving memory in large applications. 4. The importance of measuring and iterating with profiling tools like 'pprof' to monitor memory usage accurately. Concludes with encouragement to apply these techniques in real-world projects.
Screenshot essay titled 'Stop Learning Frameworks First. Start Here Instead.' The content emphasizes that frameworks should not be the starting point for developers. It advises building without frameworks by utilizing standard libraries like net/http in Go or http in Node to understand the underlying mechanics. It encourages writing raw SQL to grasp fundamental database concepts and managing queries effectively. The essay underscores the importance of thinking in systems, focusing on inputs, outputs, data flow, and potential failure points through diagrammatic representations. Finally, it suggests adding frameworks later once a solid understanding of backend layers is established, leading to better coding practices and engineering mentality.
Screenshot essay titled 'AI Won’t Save You—Unless You Follow These 3 Rules'. The essay discusses the common mistake of blindly trusting AI-generated code and offers three essential tips to prevent this error. Tip #1 emphasizes the importance of cross-checking AI-generated advice with official documentation, suggesting bookmarking trusted sources. Tip #2 warns against skipping double-sourcing opinions and stresses verifying recommendations from at least two reliable sources. Tip #3 reminds readers that AI should be used as an assistant rather than the primary decision-maker, advising to outline problems and solutions before consulting AI. The closing remark reflects on the author's experiences and encourages others to learn from these lessons.
A screenshot essay titled 'Think Clearer, Build Faster: 5 Simple Frameworks to Master AI Development'. The essay emphasizes that using AI effectively is a crucial skill, warning against treating AI as a flawless assistant. It describes the author's past mistakes and introduces five frameworks to improve AI development: 1. Clarity First - define problems in simple terms, sketch solutions, and use AI as assistance. 2. Double Prompt - never accept the first answer, rephrase questions, and compare responses. 3. Source or Ignore - always verify sources and trust citations over confidence. 4. Debug Loop - run AI-generated code, report errors, and inquire about missed aspects. 5. You're the Architect - prioritize thinking before coding, leverage AI for routine tasks, and critically review outputs. The author notes these frameworks have greatly improved their workflow.
Screenshot essay titled 'Production-Ready Code 101: The Shortcut Guide'. It includes three main parts: 'Myths Debunked', 'Critical Data', and '5-Pillar Survival Framework'. 'Myths Debunked' lists three common misconceptions in software production: 1) Working locally doesn't guarantee production readiness; 2) Retries are crucial to avoid cascading failures; 3) Observability involves more than just logging. 'Critical Data' presents statistics on API performance, the impact of chaos testing, and the cost of downtime. '5-Pillar Survival Framework' outlines five strategies: enforce timeouts, use structured logging, conduct load testing, simulate failures, and abstract I/O processes. Each section is visually distinct with highlights and bullet points for clarity.
A screenshot essay titled "You’re Not Behind — You’re Just Not Learning the Right Things Yet" describing a personal journey of a self-taught backend developer. The author recounts their initial struggles with learning advanced concepts such as clean architecture and system design while feeling overwhelmed by tutorials and side projects. The turning point came when they faced a real production environment, leading to the realization of their gaps in debugging and system understanding. The essay emphasizes the importance of focusing on foundational knowledge rather than pursuing additional tools, culminating in the insight that they were never behind; rather, they were learning the wrong things. The author concludes by encouraging the reader to prioritize learning the right concepts at the right time.
Screenshot of an essay titled 'How Working on Things I Knew Nothing About Helped Me Grow Faster'. The body of the essay recounts a personal experience of the author encountering a C# project for the first time late at night, expressing feelings of confusion and stagnation while working with familiar languages like Golang. The author highlights a desire to broaden their skills and understanding of programming patterns, specifically mentioning the discovery of Vertical Slice Architecture and Modular Monoliths, which enhanced their coding practices. The piece concludes with encouragement to explore unfamiliar technologies as a means to foster growth and innovation in one's career.