Ronald Savianto

→ The Hidden Language of APIs: Are You Fluent Yet? What if I told you mastering a few simple API concepts could dramatically level up your tech game? Many professionals overlook the fundamentals that separate good developers from great ones. It’s not just writing code - it’s speaking the API language fluently. Here’s your concise API Cheatsheet to unlock that fluency: • HTTP Status Codes: The secret signals your applications send back and forth. - 200 OK means success. - 404 Not Found signals a dead end. - 500 Internal Server Error cries for help. - Understanding these can save hours of debugging headaches.          • Top 9 HTTP Methods: More than just GET and POST. - GET retrieves data. - POST sends data. - PUT updates. - DELETE removes. - PATCH partially updates. - HEAD, OPTIONS, CONNECT, TRACE complete the toolkit you should know. • 8 API Styles Demystified: - REST: The reigning champion of simplicity. - SOAP: The heavyweight with strict rules. - GraphQL: The flexible query wizard. - RPC: The direct communicator. - Webhooks: The event whisperers. - gRPC: The speedster. - OData and JSON-RPC: Niche but powerful. Why does this matter? Because behind every seamless app or service is someone fluent in APIs. Don’t be left guessing or fumbling with trial and error. follow Sandeep Bonagiri for more insights

247

20 Komentar

🔑 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗦𝗢𝗟𝗜𝗗 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗶𝗻 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘀𝗶𝗴𝗻 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

403

29 Komentar

If you're preparing for frontend interviews, these 30 concepts are non-negotiable. After 10 years in frontend, sitting on both sides of the table, I’ve seen one thing consistently: Frameworks change. Tools evolve. But these concepts? They show up in interviews again and again. Whether you're applying for a React role or a general frontend position, mastering these will set you apart, not because they’re rare, but because very few candidates can explain them deeply. Here are 30 foundational concepts you absolutely need to know before your next interview: Event loop and call stack Microtasks vs macrotasks Closures and lexical scoping Hoisting and the temporal dead zone The this keyword and how it changes in arrow functions vs regular functions Object references vs primitive comparisons Prototypal inheritance and how it works in JavaScript Shallow vs deep copy Debounce vs throttle and where to use them Implicit vs explicit type coercion Truthy and falsy values - and how JS handles equality Difference between == and === call, apply, and bind Event delegation and bubbling typeof, instanceof, and how to check types accurately Spread vs rest operators map, filter, reduce - and when not to use them Currying and partial application async/await vs Promises vs callbacks Error handling patterns in async JavaScript Critical rendering path and what blocks it Repaint vs reflow and how to minimize layout thrashing DNS resolution, TCP handshake, TLS, and request lifecycle How browsers render HTML, CSS, and JS Preload, prefetch, and lazy loading strategies Service workers and caching strategies CORS, preflight requests, and SameSite cookies Web storage APIs: localStorage, sessionStorage, cookies - use cases and limitations Accessibility best practices (ARIA roles, focus management, semantic HTML) Responsive design principles: mobile-first, media queries, and viewport units These are not just interview questions, they’re the foundation of modern frontend engineering. Learn them deeply. Understand the "why", not just the "what." That’s how you go from writing UI to building robust, scalable, and performant frontend systems. #FrontendInterview #WebDevelopment #JavaScript #ReactJS #CodingTips #FrontendEngineer #TechCareers

188

9 Komentar

Most engineers get stumped by high-level design in system design interviews. Often, they aren't even sure where to begin. Luckily, we've put together a tried and tested framework for easily building up to a working application. 1) Identify "what the system should do" 🔶 These are also known as the functional requirements 🔶 E.g. The users can make posts, like posts, follow other users etc 💡Think about what features you would want the system to have 2) Identify "how the system should behave" under specific constraints 🔶 What are the latency requirements? 🔶 How do we ensure our servers don't crash with an increasing number of users? 🔶 How do we ensure the system is always available when it's expected to be available? 🔶 How do we ensure fault tolerance to prevent data loss? 🔶 What are the trade-offs? Why should we choose one technique over the other? 3) Start addressing functional requirements in the most basic way possible 🔶 Map the data flow for each requirement with some services. E.g. When the client makes a post, they interact with a "Tweet Service" and that gets stored in a "Tweet DB" ❌ Do not add any complicated parts - this way the interviewer can correct you early on if you've made a mistake. 4) Think about how you can use your knowledge of the core system design components when addressing the functional requirements 🔶 If we have multiple services, it probably makes sense to use an API Gateway. Think of it, you wouldn't want to expose the services directly to clients. Instead, you want controlled access. 5) Once you have a feasible "what" down, address the non-functional requirements ❌ Biggest mistake candidates make here is to not tie the recommendations back to the original non-functional requirements they identified. Think about: 🔶 How you would choose between vertical scaling and horizontal scaling, and why? In our case, we can deploy more instances of the same service so we can handle requests in parallel. 🔶 Hmm... but how would you decide traffic is distributed evenly across all instances? Maybe we should consider a load balancer. 🔶 For latency, would the system benefit from caching? Is it necessary? 🔶 Think about edge cases when it comes to preventing data loss - would it make sense to have a buffer? 🔶 How do we safeguard against a database going down? A distributed database is designed to replicate and store data across multiple nodes in a cluster. High-level design should take 15-20 minutes, which is the bulk of the interview. This is then followed by a deep dive session, which lasts another 10-15 minutes. We will be covering how to ace your deep dive session in the upcoming posts. Stay tuned! --- Put this framework into practice today -> https://lnkd.in/ecQeq-s6

104

6 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

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

"So, how will the task scheduler execute the tasks?" asked the interviewer in a system design round for building a distributed task scheduler. Interviewee: "It will poll the database for tasks scheduled in the current minute and send them to executors (workers) for execution." Interviewer: "Are you saying it would give tasks directly to workers?" Interviewee: "It can... but we’re executing 1 billion tasks a day. Considering that scale, and the spikes at times, we’ll need something to decouple the scheduler and the workers." Interviewer: "So, what will you do?" Interviewee: "I’ll use events via Kafka." Interviewer: "Great. So, tell me, how will it work?" Interviewee: "We’ll need a large number of partitions in Kafka so that we can have more consumers processing tasks in parallel." Interviewer: "Do you see any challenges with this setup, especially for long-running tasks?" Interviewee: "Hmm, I think I know what you’re hinting at… You mean that if a Kafka consumer picks up a long-running task from a partition, it blocks other tasks in that partition, since Kafka enforces strict ordering per partition." Interviewer: "Yes, exactly. Now if that task takes an hour, no other tasks from that partition can be executed, even though they should start in the current minute." Interviewee: "Agreed. We definitely need to start executing them in the current minute to meet the SLA. While we can’t guarantee completion within the same minute, execution must at least begin." Interviewer: "Exactly. So what will you do?" Interviewee: "I wouldn’t use Kafka here. I’d use an eventing system with non-blocking message consumption, like RabbitMQ or SQS." Interviewer: "Spot on. Which one would you pick?" Interviewee: "If I’m already on AWS and want to focus on business logic rather than managing infrastructure, I’d go with SQS. Otherwise, RabbitMQ. And given the scale, I’d prefer a managed queue anyway." Interviewer: "Agreed. Focus on solving the business problem first. By the way, how will you scale the workers in case of SQS?" Interviewee: "I’ll use SQS metrics like ApproximateNumberOfMessagesVisible." Interviewer: "Great." 𝘛𝘰 𝘣𝘦 𝘤𝘰𝘯𝘵𝘪𝘯𝘶𝘦𝘥… Many engineers treat Kafka as a panacea for system design problems. That’s a big mistake. While it solves many problems, it’s not always the right fit. - When you need non-blocking event consumption, or complex event routing, Kafka isn’t ideal. - For low-throughput event publishing, Kafka is often overkill. Use tools based on the problem statement and what they’re designed for, not just because everyone else is using them. If you’re preparing for mid-senior SDE or EM system design interviews and need help, DM me COACH.

55

15 Komentar