Harits F.

🔑 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗦𝗢𝗟𝗜𝗗 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗶𝗻 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘀𝗶𝗴𝗻 Writing clean, maintainable, and scalable code isn’t just about syntaxit’s about design. That’s where SOLID Principles come in. These five timeless guidelines help developers build robust applications that are easier to extend, test, and maintain. Let’s break them down with practical detail: 1️⃣ 𝗦𝗶𝗻𝗴𝗹𝗲 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗦𝗥𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: A class should have only one responsibility or reason to change. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - Classes that do too much quickly become fragile and hard to - maintain. Changing one responsibility might accidentally break another. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Focused classes are easier to understand, test, and reuse. 2️⃣ 𝗢𝗽𝗲𝗻-𝗖𝗹𝗼𝘀𝗲𝗱 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗢𝗖𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: Classes should be open for extension, closed for modification. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - Keeps existing code stable while allowing new features to be added. - Prevents bugs from creeping in when requirements change. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Future-proof code that supports growth without breaking existing features. 3️⃣ 𝗟𝗶𝘀𝗸𝗼𝘃 𝗦𝘂𝗯𝘀𝘁𝗶𝘁𝘂𝘁𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗟𝗦𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: Subclasses should replace their base classes without breaking the application. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: Violations lead to unexpected behavior and broken inheritance chains. Ensures your abstractions actually behave as promised. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Reliable and consistent code with true polymorphism. 4️⃣ 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗦𝗲𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗜𝗦𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: No client should be forced to depend on methods it does not use. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - Large interfaces become “fat” and force implementing classes to provide dummy methods. - Leads to unnecessary coupling. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Flexible contracts that encourage clean, modular design. 5️⃣ 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗗𝗜𝗣) 👉 𝗗𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻: Depend on abstractions, not concrete implementations. 📌 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: - High-level modules shouldn’t be tied to low-level implementation details. - Makes code easier to test, mock, and extend. 🔑 𝗕𝗲𝗻𝗲𝗳𝗶𝘁: Enhances testability, reduces coupling, and increases flexibility. 💡 Next time you write a class, ask yourself: Am I following SOLID? 👉 Follow me Kanaiya Katarmal, and hit the 🔔 on my profile so you don’t miss upcoming .NET tips and deep dives. 𝗧𝗵𝗮𝗻𝗸𝘀 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 𝗹𝗲𝘁’𝘀 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲 𝗴𝗿𝗼𝘄𝗶𝗻𝗴 𝗮𝗻𝗱 𝗹𝗲𝗮𝗿𝗻𝗶𝗻𝗴 .𝗡𝗘𝗧 𝘁𝗼𝗴𝗲𝘁𝗵𝗲𝗿! 👉 𝗦𝘂𝗯𝘀𝗰𝗿𝗶𝗯𝗲 𝘁𝗼 𝗺𝘆 𝗻𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿: https://lnkd.in/dp7tz_3V #SoftwareEngineering #SOLIDPrinciples #CleanCode #DesignPatterns #Programming #CodeQuality #Developers #SoftwareDesign #OOP

402

29 Komentar

Slice like a cake, not a steak.   CTOs, VPEs: remind your engineers! Don't slice stories just to fit them into sprints. That's waterfall, but in sprints. The aim of slicing is to do just enough to get FEEDBACK. So you can therefore LEARN something. And then iterate to IMPROVE the product. If you're not getting feedback on your latest slices, you're losing out on Agile's benefits.   If you deliver a complete feature without getting feedback, there's a 70%-80% chance you've wasted all that effort. But hey, you delivered on time — so congrats!   Compared to one-shot "Hail Mary" releases, releasing in slices does seem to add overhead.   But in terms of business value, atomic one-shot releases are successful only 20-30% of the time.   Releasing in slices greatly improves on this. You'll cut unsuccessful features, or pivot unsuccessful designs, BEFORE investing the full amount of work. Your chances of getting it right increase.   The features that actually make it out the door will be on target. The non-viable features won't have cost you as much as before.   So what's that about cake vs steak? When playing Sprint Tetris, I used to win more easily by slicing this [bad] way, which minimised dependencies: - Front-end  - Back-end - DB i.e. a slicing strategy based on skill sets or software modules. But this way, the pieces only come together at the end — often after some last-minute drama.    But when slicing to get feedback, each slice must be independently functional. This does involve multiple skill sets and it crosses module boundaries. But at each point you have something that functions. And it gradually improves with each iteration. P.S. All em-dashes are my own (Option+Shift+hyphen on Mac). And unlike LLMs, I break the rules and add a space on either side — I like it that way. P.P.S. Come to my live online masterclass for CTOs and Engineering VPs where I'm giving away my protocol for driving tangible business outcomes. Sign up for my newsletter and I'll email you the details — the link is in the header of this post.

120

33 Komentar

Anthropic has taken many of the core concepts of Claude Flow and integrated them directly into its new Claude Agent SDK. In my Flow platform, I had to build orchestration around features like artifact tracking, retries, and context persistence because the SDK didn’t provide them. Now those same ideas are native. Tool governance, artifact durability, and context checkpoints are primitives in the SDK. For example, in Claude Flow I wrote custom routines to retry failed tool calls with exponential backoff. The SDK now includes built-in retry handling. I built artifact management so outputs could be stored, versioned, and reused. The SDK now provides artifact durability out of the box. I had to wire in checkpoints to let an agent recover from mid-flow errors. The SDK now exposes context checkpoints directly. This validates the Flow approach. Structured cycles weren’t a workaround, they were the correct abstraction. Developers can now spin up long-running agents without bolting on any orchestration. The friction is lower, the foundation is stronger. At the same time, Anthropic is absorbing practices we pioneered back into its stack. Not that they have given any acknowledgement. Subagents? That was literally our term. The good news is this makes agents easier for newcomers to build, but it also sets tighter boundaries on how Claude agents are expected to work.

181

33 Komentar

'We only hire senior developers' Congrats! You're building a time bomb. Here's why: Senior-only teams create: • Echo chambers of outdated practices • Zero knowledge transfer • Expensive solutions to simple problems • 10 architects, no builders What you're really missing: • Fresh perspectives • Hunger to learn • Questions that challenge assumptions • Future leaders The brutal truth: • Your 'senior' requirements are fear-based • Your '10 years experience' is arbitrary • Your 'no junior devs' policy is expensive technical debt Why this matters: • Innovation needs new eyes • Growth requires teaching • Sustainability demands succession • AI is leveling the experience gap anyway How to fix it: 1. Hire for potential, not just experience 2. Create mentorship structures 3. Balance your team pyramid 4. Accept that juniors today code better than seniors did 5 years ago Remember: Today's 'risky' junior is tomorrow's 'savior'. What's your take on the senior-only trend? Drop your thoughts below 👇 *** P.S. If your entire team is senior developers, who's asking the 'stupid' questions that prevent stupid mistakes?

93

23 Komentar

Microservices are not about scaling systems. That’s a side effect. The real reason is scaling engineering teams. If you have 1,000 developers in a monolith, the friction becomes unbearable. By breaking the system into small deployable components: - Each team owns a domain end-to-end - Deployments are independent - Teams can even optimise with different stacks (in theory; in practice, most companies standardise — e.g. Netflix is Java everywhere except frontend). The same thinking was applied to the frontend → micro-frontends. But here’s the important part: If you’re a team of five, going “microservices” will hurt you more than help you. You’ll just end up with a distributed monolith. - Start with a modular monolith. - Define clear bounded contexts. - Split only when your team size and velocity justify the extra complexity. Microservices are an organisational scaling tool, not an architectural fashion trend.

480

42 Komentar

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 Komentar

13 Lessons from 13 Years in Software Engineering: 0. Good code is wasted on a bad company 1. Understand the business, not just the tech 2. Be both a mentor & mentee - simultaneously 3. Imposter syndrome stays forever - get used to it 4. It's always a trade-off, sometimes hidden 5. Side projects are the best way to learn 6. Write things down for your own clarity 7. Write a technical book - at least one 8. Be the go-to person for something 9. Titles don't mean anything 10. Act like a leader from day 1 11. Simple is hard to achieve 12. Always be useful What should I add to the list? ♻️ Repost so that more developers see this. 🔔 Follow Miko Pawlikowski 🎙️ for more.

2.167

113 Komentar

Slack Architecture to broadcast message to all online clients 🟢 Slack Client A is sending a message, and client B (same region) and C (different region) are receiving it - (1) Once the websocket is set up the client hits Webapp API to send a message. - (3) Webapp then sends that message to Admin Server (AS). - AS looks at the channel ID in this message, discovers Channel Server (CS) through a consistent hash ring - (4) AS routes the message to the appropriate CS that hosts the real time messaging for this channel. - (5B, 5C) When CS receives the message for that channel, it sends out the message to every Gateway Server (GS) across the world that is subscribed to that channel. - (6B, 6C) Each GS that receives that message sends it to every connected client subscribed to that channel id. 🤔 over to you, how to leverage above architecture for displaying "User typing" in a channel? Let me know in the comments! 👇 --- You've got System Design skills but showcasing them in 60 minutes interview is a completely different challenge for e.g. where to start? How much time to spend on HLD vs LLD etc Let me share a FREE 7-day email course that provides a step-by-step framework for acing your 60-minute System Design interview 📣 Join 1700+ subscribers and sign up for the course to learn time allocation to demonstrate full range of design skills (link in comments 👇)

80

21 Komentar

𝐔𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠 𝐒𝐎𝐋𝐈𝐃 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞𝐬 𝐢𝐧 𝐒𝐢𝐦𝐩𝐥𝐞 𝐓𝐞𝐫𝐦𝐬 As developers, writing clean, scalable, and maintainable code is as important as solving the problem itself. The SOLID principles guide us in achieving just that. Let’s break them down with real-life relatable examples 1️⃣ 𝐒𝐑𝐏 – 𝐒𝐢𝐧𝐠𝐥𝐞 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐢𝐛𝐢𝐥𝐢𝐭𝐲 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 A class should have only one reason to change. Example: An Employee class should only handle employee data. Salary calculation should be in a separate Payroll class. 2️⃣ 𝐎𝐂𝐏 – 𝐎𝐩𝐞𝐧/𝐂𝐥𝐨𝐬𝐞𝐝 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 Classes should be open for extension, but closed for modification. Example: A Shape interface with calculateArea(). New shapes like Circle or Rectangle can be added without modifying existing code. 3️⃣ 𝐋𝐒𝐏 – 𝐋𝐢𝐬𝐤𝐨𝐯 𝐒𝐮𝐛𝐬𝐭𝐢𝐭𝐮𝐭𝐢𝐨𝐧 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 Objects of a superclass should be replaceable with objects of a subclass without breaking functionality. Example: If Bird has a fly() method, then subclasses like Sparrow should fly. But Penguin shouldn’t inherit fly()—it violates LSP. 4️⃣ 𝐈𝐒𝐏 – 𝐈𝐧𝐭𝐞𝐫𝐟𝐚𝐜𝐞 𝐒𝐞𝐠𝐫𝐞𝐠𝐚𝐭𝐢𝐨𝐧 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 No client should be forced to depend on methods it doesn’t use. Example: Instead of a single Worker interface with work() and eat(), split into Workable and Eatable. A robot implements Workable, while a human implements both. 5️⃣ 𝐃𝐈𝐏 – 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐈𝐧𝐯𝐞𝐫𝐬𝐢𝐨𝐧 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 Depend on abstractions, not on concrete classes. Example: A Switch should depend on an abstraction like Switchable. Whether it turns on a LightBulb or a Fan, the switch doesn’t need to change. #solid #principle #coding #softwareengineering

94

1 Komentar