Andrea De Marco

𝗧𝗵𝗶𝘀 𝗮𝘀𝘆𝗻𝗰 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗰𝗼𝘀𝘁𝗶𝗻𝗴 𝘆𝗼𝘂 𝘁𝗵𝗼𝘂𝘀𝗮𝗻𝗱𝘀 Async/await has been in .NET for over a decade, yet production systems still suffer from the same three mistakes that destroy performance and inflate cloud costs. These patterns appear innocent. Code reviews approve them. They pass all tests. But under load, they become system killers. The symptoms are always the same: → Thread pool starvation with low CPU usage → Random deadlocks in production → Response times growing exponentially with load → Cloud costs mysteriously tripling The most dangerous part? Standard monitoring often shows the system as "healthy" with 20% CPU usage. The problem isn't CPU - it's thread exhaustion. Each blocking call consumes a thread. With default thread pool settings, just 100 concurrent requests can bring an API to its knees. Async void swallows exceptions, causing silent failures that only surface during peak traffic. Unnecessary Task.Run calls double thread usage for zero benefit. These aren't edge cases. They're in most codebases right now, waiting for the next traffic spike. 𝗧𝗼𝗺𝗼𝗿𝗿𝗼𝘄: The fixes that enable 100x throughput improvements with the same infrastructure. 𝗛𝗮𝘃𝗲 𝘆𝗼𝘂 𝘀𝗲𝗲𝗻 𝘁𝗵𝗲𝘀𝗲 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀 𝗶𝗻 𝘆𝗼𝘂𝗿 𝗰𝗼𝗱𝗲𝗯𝗮𝘀𝗲? Did you noticed potential issue in mistake 2? #AsyncAwait #Dotnet #CSharp #PerformanceOptimization #SoftwareEngineering

401

69 commenti

Data modelling is one of the most important parts of system design. Get it right, and everything else just works. I've seen too many teams rush into building APIs and UIs before truly understanding their data. It feels fast at first...until requirements change, and those early shortcuts turn into months of rework. That's why it's worth asking the right questions early: → What entities actually exist in the system? → How do they relate to one another? → Which should be immutable vs versioned? → Which fields are truly required vs optional? → How could this existing model evolve without breaking existing consumers? → Are you modelling your access patterns, not just your entities? → Do your models reflect real business concepts or just database convenience? If you're designing a new system or refactoring an existing one, here's some advice I've found helpful: [0] Start with relationships not tables → whiteboard your entities first before writing a single line of code. Truly understand how data connects, and the right structure will reveal itself. [1] Validate against reality → run real queries and flows through your model early, and if your model can't support actual access patterns efficiently, then it's not ready. [2] Be explicit about tradeoffs → every model optimises for something: consistency, availability, latency or simplicity. You can't have them all. Think PACELC not just CAP theorem. [3] Design for change → your model will change over time. The goal isn't to predict all future use cases but rather to make changes safe. Ask yourself how hard would it be to add new fields, relationships or versions without breaking downstream systems? [4] Document the reasoning, not just the result → share context with those around you, write down what you decided, why you decided it and what you explicitly chose not to do. [5] Seek diverse feedback early → share your proposals with experienced engineers before you finalise the model. They may catch scaling, indexing or risks that aren't obvious yet. Because whilst code can be rewritten easily, data lives forever. And changing it later always costs more than designing it right up front. Start with your data. Design everything else around it. #softwareengineering #systemdesign

1.048

96 commenti

→ The Untold Truth Behind Microservices Tech Stacks What if I told you building microservices is less about code and more about orchestration? The magic happens in how every piece fits together - from development to deployment - and it’s what decides your success. → Pre-production Flow: Where Ideas Take Shape • Developers craft APIs first - using OpenAPI or Postman - to set clear contracts. • Microservices and frontends are built with trusted frameworks like Java, Node.js, React. • Rigorous testing with Jenkins and JUnit ensures stability before moving forward. • Containerize with Docker, then deploy using Kubernetes for streamlined scaling. → Production Flow: The Invisible Web • Traffic is expertly routed via load balancers (NGINX) and CDNs (Cloudflare). • API Gateway manages requests - often Spring Boot paired with Netflix Eureka. • Behind the curtain, databases, caches (Redis), search engines (Elasticsearch), and message brokers (Kafka) work in concert. • All components are continuously monitored with Postman and Kubernetes, ensuring reliability. → Unified Tooling: The Secret Sauce for Scalability • Combining containerization, CI/CD pipelines, observability tools, and modular design makes fast deployment possible. • Each microservice runs independently, yet harmonizes perfectly with others. • This orchestration prevents single points of failure and supports growth. Microservices aren’t just code - they are a living ecosystem designed for resilience and agility. follow Sandeep Bonagiri for more insights

241

14 commenti

So, you want to be a Mobile Platform Engineer? In my previous article, I covered what a Mobile Platform Engineer does. This follow-up article covers the practical steps to actually get there. What I cover: - How to adjust your work so you deliver features AND help your entire team - How to position yourself with existing platform teams (hint: become their ally) - How to become the first Platform Engineer at companies that don't have platform teams yet - And more! The full guide includes positioning strategies, common mistakes that backfire, realistic timelines, and what success actually looks like.

107

3 commenti

I often talk to #CTOs, and a common topic is #technicaldebt. They say it slows down everything, makes development risky, and developers are not happy. In the same talk, the word "#refactoring" comes up. Developers want a big refactoring to fix the code. Business wants more features. This always creates a conflict. But this is a false dilemma. The problem is that many people misunderstand what refactoring is. They think it's a huge project, where you rewrite code for weeks to make it clean. But if you read the book "Refactoring", this is not the definition. Real refactoring is making small, continuous changes to improve the code design without changing what the code does. If it takes weeks, it is not refactoring. It is a rewrite. The correct way is constant refactoring. When you work on a feature, you see something to improve? Refactor it. When you finish a feature, you see a way to make the design cleaner? Refactor it. This is the key: Constant refactoring keeps code clean and flexible. It prevents the need for a big, painful rewrite. My advice for #CTOs: * Push your developers to refactor all the time. It is part of the job, not a special project. * Protect your team from business pressure to ship low-quality code. Good quality now means more speed later. #TechnicalDebt #Refactoring #SoftwareDevelopment #CTO #Agile #CleanCode #EngineeringLeadership

57

13 commenti

Blogged: Converting an xUnit test project to TUnit https://lnkd.in/eRKYKwnX In this post I discuss the new TUnit testing framework, why I ported one of my libraries to use it instead of xUnit and related issues I had to deal with #dotnet #testing

64

JetBrains just announced they're moving to a single, unified IntelliJ distribution starting with version 2025.3. No more choosing between Community and Ultimate - it's one IDE with features unlocked by subscription. Why does this matter? • Some previously paid features (Spring support, database tools) are becoming FREE • The open-source commitment remains, but with a twist • This signals bigger changes in how dev tools compete in the AI era I spent time analyzing the announcement and its implications. This isn't just about IntelliJ - it's about the future of IDEs in a world where AI assistants are changing how we write code. Full analysis here → https://lnkd.in/gBpSNWUu Curious: How many of you are using IntelliJ Community Edition today? What's your take on this change?

162

4 commenti

Systems don’t fail from missing features. They fail because the core architecture was never solid. In system design, everything depends on the foundation. Remove it, and the system collapses: - A payments platform without reliable transaction handling isn’t a platform. - A chat system without fault-tolerant real-time delivery isn’t chat. - An analytics pipeline without accurate, durable event storage isn’t analytics. Yet, teams often start at the edges, focusing on UI polish, onboarding flows, and third-party integrations, before locking in the core. Here is what I had learn: 1. Find the core Ask: If I remove this component, does the system still exist? And make it resilient. 2. Separate core from extras Core = the minimal set of services that must stay consistent and reliable. Extras = scalability add-ons, convenience APIs, or UX niceties. 3. Invest in the core first - Design for correctness and durability before performance. - Keep protocols and data models simple and explicit. - Make failure handling clear and predictable. 4. Defer the extras Adding complexity before the foundation is proven is like scaling a system that doesn’t even work correctly yet. 5. Stress test the core Push it to its breaking point early. Load, failure, recovery, and consistency testing matter more than flashy features. The truth: Shiny features don’t save a weak system. A solid core: durable, reliable, and simple, does.

137

64 commenti

From Developer to CEO Part 03: 5 to 10 years of experience Congratulations, you’re now a senior developer. But you’re not a senior just because you’ve reached 5 years of experience. You’re a senior because you’ve seen more problems— and you know how to prevent them. At this stage, you should be able to build software from A to Z. But your main focus must now shift to business impact. Not just how to code, but how to solve real business problems. Code shouldn’t be your challenge. Code should be your tool—to deliver value. For that, start asking the right questions: • What’s the real problem the customer is trying to solve? • Why does the client need this feature? • What’s the expected benefit for their business? • Is there a better solution? You’re not just a developer anymore. You should become a technical partner to your clients, not just someone who takes orders. Your new mindset: 👉 How can I maximize my customer’s success? If you follow these tips, you’ll level up faster. ⸻ After 20+ years in web development, I’m sharing what I wish I had known when I was younger. This post is a follow-up to Julien Rajerison’s post. Tomorrow, we’ll talk about developers with 10+ years of experience. ⸻ You’ve got this. I’m Toky RABESON. I’m a seasoned web developer.

94

4 commenti

Waiting half an hour for your tests to finish? That’s not feedback - that’s punishment 🧪 You might have been there: Every new integration test adds another minute to your overall build time. Twenty minutes turn to thirty. CI times explode. Developers stop writing integration tests and become unhappy. Flaky tests appear. Bugs slip through. Releases slow down. But what if you could slash that time, without deleting a single test? With Spring Test, that's possible. It's a hidden gem called Spring TestContext Context Caching 🏆 So, how do you know how many contexts are spinning up? More importantly, how do you figure out why they aren’t being reused? That’s why I built Spring Test Profiler ⏱️ Meet Spring Test Profiler - the free, open-source x-ray for your test suite. Integration is as simple as this three-step process: 1. Add the dependency (Maven/Gradle snippets appear on screen). 2. Run your tests. 3. Open the report at: target/spring-test-profiler/report.html. Within the report, you’ll see: • How many contexts started, and why. • Which tests are sharing configs versus starting their own. • Exact diffs: profiles, properties, or annotations blocking cache reuse. The overall goal is to help identify cache misses and align your tests to reuse contexts for faster feedback 🚤 Spring Test Profiler: Profile. Optimize. Deliver. Try it yourself: https://lnkd.in/djXVJiNE Below is a demo of a section in the report to analyze and compare two contexts 🆚

49

5 commenti

MediatR is powerful. But here's the truth: 👉 Using it for a simple project is like using a chainsaw to slice bread. Technically possible, but massively overkill. If your team and your app are small, chances are you don't need pipelines, handlers, and all the extra complexity. Stick to direct calls, filters, and middlewares — you'll ship faster with less cognitive load. 💡 The real flex? Choosing the simplest architecture that solves the actual problem.

35

3 commenti

Flaky tests feel random. They’re not. The patterns are clear: * Timing issues (async workflows, race conditions) * Shared state (bad test isolation, order dependencies) * Environment drift (things that work locally but fail in CI) By definition, though, they’re not obvious to spot. A missing await, an unseeded random number, a fragile assertion. These problems tend to show up after the developer who wrote them has moved on to the next thing, reducing the likelihood that anyone will take time to fix them. AI is going to multiply these issues. It’s *also* going to help us catch them faster. The challenge for leaders: don’t accept flaky tests as inevitable. They’re just tech debt we’ve been too slow to pay down.

43

🚨 More than 70% of frontend devs struggles with this follow-up question in interview about PWAs? When asked: “How does offline access work in a PWA?” Most confidently say: “Because of Service Workers!” ✅ Correct… but do you know 👇 💡 “What’s the difference between Service Workers and Web Workers?” This is where many candidates struggle but not anymore Here’s the breakdown you should never forget: ⚡ Web Workers 1️⃣ Run JS in a separate thread → avoid blocking the UI. 2️⃣ Die when the page closes. 3️⃣ Best for CPU-heavy tasks (e.g. image processing, data crunching). 🌐 Service Workers 1️⃣ Act as a proxy between your app & the network. 2️⃣ Can intercept requests, cache responses, & serve content offline. 3️⃣ Live beyond page lifecycle → even when the app is closed. 4️⃣ Backbone of offline PWAs, push notifications, & background sync. 🚀 Key takeaway: Web Workers = Performance Service Workers = Offline + Background capabilities 📌 Have you ever faced this question in your system design interview? #Frontend #Interview #frontendinterview #PWA #SystemDesign #WebWorkers #ServiceWorkers #javascript #reactjs #frontendgeek

40

6 commenti

As engineering teams grow and products mature, one common issue I’ve seen is the rebuilding of features that already exist — just hidden behind older configurations or tied to specific client use cases. Here’s a scenario: Two years ago, a feature was built for one specific customer. Now, another customer requests something similar. Since the current team doesn't know it already exists (because it was hidden behind config or built for just one case), they build it again. And now, we have two features doing the same job. To avoid this, here are 3 simple things I suggest: 1️⃣ Treat Release Notes as Internal Knowledge Too — It shouldn’t be just for customers. Developers should actively read sprint release notes to stay updated. 2️⃣ Scrum of Scrums — Leads or managers can give quick updates on what their teams are building in cross-functional sync-ups. 3️⃣ A Shared Channel for Feature Highlights — A central Slack/Teams space where developers post major features they’ve shipped. In fast-moving teams, we don’t always have time to read all the code. But we can create simple habits that save time later. If your team has found other smart ways to solve this problem, drop it in the comments — I’d love to learn from you too.

34

4 commenti