<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Dinith Rathnayaka on Medium]]></title>
        <description><![CDATA[Stories by Dinith Rathnayaka on Medium]]></description>
        <link>https://medium.com/@dinithoshada2003?source=rss-6d9f8fd34009------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*M7PpVojy0DUxr7h8B3OARg.png</url>
            <title>Stories by Dinith Rathnayaka on Medium</title>
            <link>https://medium.com/@dinithoshada2003?source=rss-6d9f8fd34009------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 16:34:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dinithoshada2003/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[ORM — From Basics to Beyond | Part 01: Introduction to ORMs]]></title>
            <link>https://medium.com/@dinithoshada2003/orm-from-basics-to-beyond-part-01-introduction-to-orms-8625b6b5a706?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/8625b6b5a706</guid>
            <category><![CDATA[jpa]]></category>
            <category><![CDATA[orm]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[hibernate]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 12:17:00 GMT</pubDate>
            <atom:updated>2026-09-08T12:17:00.090Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lIXndVztjjtys_8H3bZhTA.png" /></figure><p>As developers whenever we work with databases, we usually deal with two different things. Our application works with <strong>objects</strong> but the relational database works with <strong>tables and rows.</strong></p><p>For example let us take a Java Application. Imagine now I have:</p><pre>User user=new User();<br>user.setName(&quot;Dinith&quot;);<br>user.setEmail(&quot;dinithoshada2003@gmail.com&quot;);</pre><p>But when It comes to database the same information will be in the database table format. So a simple question pops up right?</p><p><strong><em>How does the application object get mapped to the database table?</em></strong></p><p>This is where the concept of <strong>ORM</strong> comes in.</p><h3>What is ORM?</h3><p>ORM stands for <strong>Object-Relational Mapping. </strong>Basically, ORM is something that provides a way to work with our Database with the programming language that we use. It creates a mapping in between:</p><p>Application Object → Database Table</p><p>Object Property → Table Column</p><p>Object Relationship → Table Relationship</p><p>Right now with this we do not have to write repetitive SQL queries for every single operation and then convert the results into objects objects ourselves. We can let the ORM handle much of that work.</p><p>For example, instead of directly writing:</p><pre>SELECT * FROM users WHERE id = 1;</pre><p>we might write something like:</p><pre>userRepository.findById(1L);</pre><p>The ORM/framework can then generate the appropriate SQL and map the result back into a User object.</p><h3>Why Do We Use ORMs?</h3><p>The main reason is actually the simplicity and productivity of it. Applications can perform hundreds or even thousands of database operations. Writing and maintaining SQL, handling connections, mapping results to objects and managing relationships manually can be time consuming and also it needs lot of repetitive codes. We call these Boilerplate codes.</p><p>Here with an ORM we can handle many of these common tasks for us. It can help with:</p><ul><li>Creating, reading, updating and deleting data</li><li>Mapping database rows to objects</li><li>Managing relationships between entities</li><li>Reducing SQL boilerplate codes</li><li>Handling database interactions in an object-oriented way</li></ul><p>This is a huge relief when the application grows and scales.</p><h3><strong>Some Popular ORMs</strong></h3><p>There are different ORM tools depending on the programming language.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_3INXZyUfzcAJ3ipmfdZ-g.png" /><figcaption>Ai generated Image</figcaption></figure><p>Since I am working with Spring Boot, Hibernate and JPA are particularly relevant. One thing worth remembering is that <strong>JPA and Hibernate are not the same thing. JPA </strong>is a specification that defines how persistence should work in Java, while Hibernate is an implementation of that specification.</p><p>Spring Data JPA then provides a convenient way of working with JPA, especially through repositories.</p><p>A simplified view is:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RTFoL4Vbrhxj7nfTcvWSJQ.png" /><figcaption>Ai generated Image</figcaption></figure><h3>Does Having ORM means we don’t need SQL anymore?</h3><p>Definetly not!</p><p>An ORM is an abstraction over the database. The database still works with SQL.</p><p>If we write:</p><pre>userRepository.findById(1L);</pre><p>the database still needs to receive a query that does something similar to:</p><pre>SELECT * FROM users WHERE id = 1;</pre><p>So learning an ORM shouldn’t replace learning SQL.In fact, understanding SQL makes it much easier to understand what the ORM is actually doing, especially when dealing with performance issues or complex queries.</p><h3>What I Took Away From This</h3><p>Before learning about ORM, I mostly looked at database operations as something separate from the application code. Now I have a better understanding of what happens in between.</p><p>An ORM doesn’t replace SQL or the database. It simply gives developers a more convenient way to work with relational data through the objects and structures they already use in their applications.</p><p>For me, the important part isn’t memorizing methods like findById() or save(). It&#39;s understanding what happens underneath them.</p><p><strong>Application → ORM → SQL → Database</strong></p><p>Once that connection makes sense, technologies like Hibernate, JPA, Prisma, and other ORMs start to feel a lot less complicated.</p><p>This was one of those small concepts that made a bigger part of backend development make a little more sense.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8625b6b5a706" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Architecture : How Your Application Decides What Happens Next]]></title>
            <link>https://medium.com/linkit-intecs/software-architecture-how-your-application-decides-what-happens-next-3fb0cea22cc8?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fb0cea22cc8</guid>
            <category><![CDATA[software-design-patterns]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[fundamentals]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Fri, 04 Sep 2026 03:24:40 GMT</pubDate>
            <atom:updated>2026-09-04T03:24:40.538Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i5IMZfQiel0NnO_h1gvHwQ.png" /></figure><p>Imagine that you are building a small application. I know at first everything feels easy. You create a frontend, write a backend, connect a database, and all of a sudden now you have a working application. Wonderful right?</p><p>May be your basic architecture looks something like this :</p><p>React → Node → PostgreSQL</p><p>And You deploy it . It works. Now have you ever realized what happened afterwards?</p><p>After you deploy it Your application gets more users. You add authentication. Then payments, notifications, admin dashboard, background jobs. Then another developer joins the project. Then another. A few months later, you make one tiny change to the payment system and somehow the notification system stops working. Now You start asking questions from yourself:</p><p>“Where should this code go?”</p><p>“Why does changing this module break three other modules”</p><p>“Should we split this application”</p><p>“Do we need microservices?”</p><p>I mean eventually you will discover that</p><p><strong>“Writing code is only one part of building software. Deciding how that code should be organized is an entirely different problem.”</strong></p><p>This is where the <strong>Software Architecture</strong> comes to play.</p><h3>What exactly is this Software Architecture?</h3><p>Software Architecture is the high-level structure of a software system. It basically describes things like:</p><ul><li>What the major components of the system are</li><li>What responsibilities each component has</li><li>How these components communicate</li><li>Where business logic lives</li><li>How data flows through the system</li><li>How the system can scale</li><li>How failures are handled</li></ul><p>Let us think of building a house. You choose the color of the walls, the type of tiles, and the furniture later. But before anything you need to decide first:</p><ul><li>Where the rooms go</li><li>Where the doors are</li><li>Where the plumbing runs</li><li>Where the electrical systems goes</li><li>How everything connects</li></ul><p>That overall structure is similar to software architecture. And just like houses, there isn’t one architecture that is fixed or even perfect for every application. Now Let us dive a little deep into these architectures.</p><h3>1.Client-Server Architecture</h3><p>Let us start with something very familiar. You open a web application. Your browser displays the UI, but the browser usually does not contain everything the application needs. It communicates with a server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZjOTy8So2DosOp9rIZf3YQ.png" /><figcaption>AI generated Image</figcaption></figure><p>The <strong>client</strong> is responsible for interacting with the user. The <strong>server </strong>handles things such as:</p><ul><li>Business logic</li><li>Authentication</li><li>Databasae operations</li><li>Validation</li><li>APIs</li></ul><p>For example:</p><pre>React <br>  ↓ <br>GET /products <br>  ↓ <br>Backend <br>  ↓ <br>Database <br>  ↓ <br>Products <br>  ↓ <br>React</pre><p>This architecture is the foundation of most of the web applications that you see in the daily life. But now let us make our application bigger.</p><h3>2.Monolithic Architecture</h3><p>Imagine that you are building an e-commerce application. You start with one backend. Inside it, you have:</p><pre>User Management<br>Product Management<br>Orders<br>Payments<br>Notifications<br>Admin<br>Authentication</pre><p>Now You can see that everything lives inside one application. That is a monolith.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h7fgkYOBNOdXJ19tmWgEDA.png" /><figcaption>AI generated Image</figcaption></figure><p>And here is something important that you should know:</p><p><strong><em>Monolithic does not mean bad</em></strong></p><p>In fact, a monolith can be an excellent choice. For a small application, having one codebase and one deployment can make life dramatically easier.</p><p>You can:</p><ul><li>Develop quickly</li><li>Deploy easily</li><li>Debug locally</li><li>Run the entire application on your machine</li><li>Keep communication between module simple</li></ul><p>The real problem starts when the application grows beyond what the team can comfortably manage.</p><p>You might end up with:</p><pre>OrderController<br>     ↓<br>OrderService<br>     ↓<br>PaymentService<br>     ↓<br>NotificationService<br>     ↓<br>UserService<br>     ↓<br>...</pre><p>Everything starts depending on everything else. Now changing one part is a heavy risk. And this leads us to a common architectural approach.</p><h3>3.Layered Architecture</h3><p>Instead of throwing everything into one huge codebase, we separate responsibilities into layers.</p><p>A common structure looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J7TVumIJI-ljFqzatwfHeg.png" /><figcaption>AI generated Image</figcaption></figure><p>For example, in a Spring Boot application:</p><pre>Request <br>  ↓ <br>Controller <br>  ↓ <br>Service <br>  ↓ <br>Repository <br>  ↓ <br>Database</pre><h4>Controller</h4><p>Responsible for handling requests.</p><pre>@PostMapping(&quot;/orders&quot;)<br>public Order createOrder(...){<br>  //some codes<br>}</pre><h4>Service</h4><p>Responsible for business rules.</p><p>Check product availability</p><p>Calculate total</p><p>Apply discount</p><p>Create order</p><h4>Repository</h4><p>Responsible for communicating with the database. This separation gives each part a clear responsibility. Instead of having one giant method that does everything, we can divide responsibilities now. This actually leads to one of the most important concepts in Software Engineering :</p><p><strong><em>Separation of concerns</em></strong></p><p>A component should have a clear responsibility rather than trying to do everything.</p><h4>But Is this enough?</h4><p>For many applications, yes this approach is enough. But imagine your e-commerce application becomes extremely successful. Millions of users start placing orders. Your payment system needs to scale independently. Your notification system is receiving millions of events. Your product search system needs specialized infrastructure.</p><p>Now the question becomes:</p><p><strong><em>Why should all of these things have to live inside the same application?</em></strong></p><p>And this is where that famous word appears:</p><p><strong><em>The Microservices</em></strong></p><p>Let us dive deep now.</p><h3>4.Microservices Architecture</h3><p>Instead of building one huge application, we split the system into smaller services.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tsZ8SNsbsTqumx-n54kkjw.png" /><figcaption>AI generated Image</figcaption></figure><p>Each service focuses on a particular business capability.</p><p>For example:</p><pre>User Service<br>Order Service<br>Payment Service<br>Product Service<br>Notification Service</pre><p>The important idea isn&#39;t simply:</p><blockquote><strong>Make many small applications</strong></blockquote><p>The real idea is:</p><p><strong><em>Create independently manageable services around business capabilities.</em></strong></p><p>This actually gives us some powerful benefits.</p><h4>Independent Scaling</h4><p>Suppose your product service receives 10 times more traffic than your user service. You can scale the product service independently.</p><pre>Product Service × 10<br>User Service    × 2</pre><p>You don&#39;t necessarily need to scale the entire system.</p><h4>Independent deployment</h4><p>You can potentially deploy a new version of the payment service without redeploying every other service.</p><h4>Team ownership</h4><p>Different teams can own different services. But there’s a catch. Microservices introduce <strong>distributed systems problems</strong>. Now your application isn’t:</p><p>Function → Function</p><p>It becomes:</p><p>Service → Network → Service</p><p>And network fail. Requests can timeout. Services can become unavailable. Messages can be duplicated. Data can become temporarily inconsistent. Debugging becomes much harder. So microservices solve some problems while creating entirely new ones.</p><p>That’s why:</p><p><strong><em>Microservices are not the next level of monoliths. They are a trade-off.</em></strong></p><h3>5.Event Driven Architecture</h3><p>Now imagine a customer places an order. The system needs to:</p><ul><li>Create the order</li><li>Process payment</li><li>Send an email</li><li>Update inventory</li><li>Notify the warehouse</li></ul><p>A traditional approach might be:</p><pre>Order Service<br>     ↓<br>Payment Service<br>     ↓<br>Notification Service<br>     ↓<br>Inventory Service</pre><p>But now the order service knows about many other services. What if instead it simply says:</p><p><strong><em>An order has been created</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6OZJeMfvihzfC9VFiVeo7w.png" /><figcaption>AI generated Image</figcaption></figure><p>This is the fundamental idea behind <strong>event-driven architecture.</strong></p><p>A service publishes an event. Other services can listen and react. Technologies such as:</p><ul><li>Apache Kafka</li><li>RabbitMQ</li><li>Amazon SNS/SQS</li><li>MQTT</li></ul><p>can be used for different event-driven scenarios. You may have already encountered this idea with MQTT.</p><p>Sensor → MQTT Broker → Subscribers</p><p>The beauty of event-driven systems is that the producer does not necessarily need to know who will consume the event.</p><p><strong>Today:</strong></p><p>OrderCreated → Notification Service</p><p>Tomorrow, you could add:</p><p>OrderCreated → Analytics Service</p><p>without necessarily changing the original producer.</p><h3>6.Serverless Architecture</h3><p>Now let us change the question again.</p><p><strong><em>What if you don’t even want to manage a continuously running backend server?</em></strong></p><p>Instead, you want code to execute only when something happens. That is where <strong>serverless architecture</strong> comes in.</p><p>User → API Gateway → Function → Database</p><p>For example:</p><p>POST /register → AWS Lambda → Create User → Database</p><p>The cloud provider manages much of the underlying infrastructure. Popular examples include:</p><ul><li>AWS Lambda</li><li>Azure Functions</li><li>Google Cloud Functions</li><li>Firebase Cloud Functions</li></ul><p>These serverless can be extremely useful for event-driven workloads, APIs, scheduled jobs and applications where automatically scaling is valueble.</p><p>But again, there are trade-offs. You need to consider:</p><ul><li>Cold starts</li><li>Execution limits</li><li>Vendor lock-in</li><li>Observability</li><li>Cost at scale</li></ul><p>“Serverless” does not mean there are no servers. It means <strong>you aren’t responsive for managing the servers in the traditional way.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pjcyqkIBHcocpvwiXgaE3g.png" /><figcaption>AI generated Image</figcaption></figure><h3>7.Clean Architecture</h3><p>So far, we have mostly talked about how these applications are split into components and how they work. Yet there is another important question:</p><p><strong><em>What should our business logic depend on?</em></strong></p><p>Imagine your application’s most important business rules depend directly on:</p><pre>PostgreSQL<br>Spring Boot<br>HTTP<br>Redis<br>Kafka</pre><p>Now replacing one technology could require changing your business logic. Clean Architecture address this problem differently. The idea is to keep the business rules at the center.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jviZ5eYLeiKP7GnSkmQu6w.png" /><figcaption>AI generated Image</figcaption></figure><p>The core shouldn’t care whether data comes from:</p><pre>PostgreSQL<br>MongoDB<br>REST API<br>GraphQL</pre><p>The infrastructure should adapt to the business logic. rather than the other way around. This idea is closely related to Hexagonal Architecture, also called <strong>Ports and Adaptors.</strong></p><h3>8.Hexagonal Architecture</h3><p>The name sounds complicated. The isn’t. Imagine your application as the center.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_0C6Lkoum3pEjK7p2wXr4g.png" /><figcaption>AI generated Image</figcaption></figure><p>The external systems are adapters. The business logic communicates through defined interfaces, often called <strong>ports.</strong></p><p>For example:</p><pre>PaymentPort<br>     ↑<br>     │<br>StripePaymentAdapter<br><br>Later, you could replace it:<br><br>PaymentPort<br>     ↑<br>     │<br>PayPalPaymentAdapter</pre><p>The business logic does not have to fundamentally change. This gives us a powerful principle:</p><p><strong><em>Depend on abstractions rather than concrete infrastructure where it matters.</em></strong></p><h3>Architecture Is About Trade-Offs</h3><p>This is probably the most important lesson in this entire topic.There is no architecture that wins everywhere. Consider a small startup application.</p><p>A monolith might be perfect.</p><pre>Simple<br>Fast to build<br>Easy to deploy<br>Easy to debug</pre><p>Moving immediately to 20 microservices could actually make the project worse.</p><p>You would suddenly need to think about:</p><pre>Service discovery<br>Network failures<br>Distributed tracing<br>Message brokers<br>Deployment<br>Monitoring<br>Authentication between services<br>Data consistency</pre><p>All before you even have enough users to justify the complexity.</p><p>On the other hand, a huge organization operating a massive platform may benefit enormously from independently deployable services.</p><p>So instead of asking:</p><p><strong><em>Which architecture is the best?</em></strong></p><p>Ask:</p><p><strong><em>Which architecture solves our current problems without creating unnecessary complexity?</em></strong></p><h3>Architecture vs Design Patterns</h3><p>One more distinction is worth understanding.</p><p>You might hear about:</p><ul><li>Singleton</li><li>Factory</li><li>Observer</li><li>Strategy</li><li>Adapter</li></ul><p>These are <strong>design patterns</strong>, not application architectures.</p><p>Think about the levels like this:</p><pre>Software System<br>       │<br>       ↓<br>Architecture<br>       │<br>       ↓<br>Components<br>       │<br>       ↓<br>Design Patterns<br>       │<br>       ↓<br>Classes / Functions</pre><p>Architecture determines the broad structure.</p><p>Design patterns help solve recurring problems inside that structure.</p><p>For example:</p><pre>Microservices Architecture<br>        ↓<br>Order Service<br>        ↓<br>Strategy Pattern<br>        ↓<br>Different payment methods</pre><p>They work together rather than competing with each other.</p><h3>So Which Architecture Should You Choose?</h3><p>A practical decision might look something like this:</p><h3>Starting a small application?</h3><p>Start with a <strong>monolith</strong>.</p><p>You can still organize it using <strong>layers</strong>.</p><pre>Controller<br>    ↓<br>Service<br>    ↓<br>Repository<br>    ↓<br>Database</pre><h4>Growing application with clear business boundaries?</h4><p>Consider <strong>modular monoliths</strong> or eventually <strong>microservices</strong>.</p><h4>Lots of asynchronous processing?</h4><p>Consider <strong>event-driven architecture</strong>.</p><h4>Small independent functions or cloud-native workloads?</h4><p>Consider <strong>serverless</strong>.</p><h4>Complex business logic that needs to remain independent from infrastructure?</h4><p>Consider principles from <strong>Clean Architecture</strong> or <strong>Hexagonal Architecture</strong>.</p><p>And remember:</p><p><strong>You don’t have to choose only one.</strong></p><p>Real systems often combine multiple architectural styles.</p><p>For example:</p><pre>Microservices<br>      +<br>Layered Architecture<br>      +<br>Event-Driven Communication<br>      +<br>Clean Architecture<br>      +<br>Caching<br>      +<br>Load Balancing</pre><p>Architecture is rarely a single checkbox.</p><h3>The Architecture Evolves With the Application</h3><p>Perhaps the biggest misconception about architecture is that you must design the “perfect architecture” before writing the first line of code.</p><p>In reality, architecture evolves.</p><p>A project might begin as:</p><pre>Simple Monolith</pre><p>Then become:</p><pre>Layered Monolith</pre><p>Then perhaps:</p><pre>Modular Monolith</pre><p>And eventually some parts might become:</p><pre>Microservices</pre><p>while other parts remain inside the monolith.</p><p>That’s perfectly fine.</p><p>In fact, it can be a much healthier evolution than trying to predict every future requirement on day one.</p><h3>My Final Thoughts</h3><p>The next time you open a project and see:</p><pre>controllers/<br>services/<br>repositories/<br>events/<br>workers/<br>api/<br>database/</pre><p>don’t just think about folders. Think about the decisions behind them.</p><p><strong><em>Why are these components separated?</em></strong></p><p><strong><em>Why does this service communicate through an event?</em></strong></p><p><strong><em>Why does this module depend on an interface?</em></strong></p><p><strong><em>Why is this functionality a separate service?</em></strong></p><p><strong><em>Why isn’t everything inside one application?</em></strong></p><p>Those questions are the beginning of <strong>software architecture thinking</strong>.</p><p>Because as developers, we eventually move beyond simply asking:</p><p><strong><em>How do I make this code work?</em></strong></p><p>We start asking:</p><blockquote><strong>How should I structure this system so that it can continue working when the application, team, traffic, and requirements become ten times larger?</strong></blockquote><p>And that is where software architecture becomes more than diagrams and fancy terminology.</p><p><strong>It’s the art of making decisions today that your future self won’t hate.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fb0cea22cc8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/software-architecture-how-your-application-decides-what-happens-next-3fb0cea22cc8">Software Architecture : How Your Application Decides What Happens Next</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OAuth vs API vs JWT vs bcrypt- Four Concepts that Every Web Developer Must Know]]></title>
            <link>https://medium.com/linkit-intecs/oauth-vs-api-vs-jwt-vs-bcrypt-four-concepts-that-every-web-developer-must-know-60415aa4583e?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/60415aa4583e</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[jwt]]></category>
            <category><![CDATA[oauth]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[bcrypt]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Mon, 03 Aug 2026 05:50:17 GMT</pubDate>
            <atom:updated>2026-08-03T05:50:17.563Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XThKTh9pq7fjli0rNz2p9A.png" /><figcaption>Cover Image by Author</figcaption></figure><p>If you have ever build a Full Stack Application You might have encountered terms like API, OAuth , JWT and bcrypt. At the beginning These might seem related, I mean of course They are But each of these solve entirely different problems. From this Article I hope to explain what are these , why these exists and where should these be used when we are developing real world application.</p><h3>Understanding using a Simple Analogy</h3><p>Now Imagine that You are entering an Large Office Building. During this different things happen.</p><ul><li>You enter through the main entrance.</li><li>The security guard verifies your identity.</li><li>You receive a permission card as a visitor pass.</li><li>You walk through different departments to get your work done requesting services.</li></ul><p>You know what , This is exactly how a web application works</p><p>Below image shows what does each analogy element represent inside a web application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PA-58GA9YmBDp72y8TfinQ.png" /><figcaption>Office Building Analogy vs Web Applicaion : AI generated Image</figcaption></figure><p>Before diving deep into technologies, let us understand what problem does each of this solve.</p><h3>The Four Different Problems</h3><p>Almost every application has these four separate challenges.</p><h4>Problem No 1</h4><p><em>How can users request data?</em> <strong>API solve this.</strong></p><h4>Problem No 2</h4><p><em>How can users prove who they are? </em><strong>OAuth helps at this point.</strong></p><h4>Problem No 3</h4><p><em>How can the server remember that the user has already logged in? </em><strong>JWT solves</strong><em> </em><strong>this.</strong></p><h4>Problem No 4</h4><p><em>How can the passwords be stored in a secured manner?</em> <strong>bcrypt solves this.</strong></p><p>Did you actually notice something here? These are <strong>four completely different problems.</strong></p><h3>What is an API?</h3><p>The term API stands for <strong>Application Programming Interface.</strong></p><p>Basically , this is a way for two software application to communicate with each other. Think of it as a waiter in a restaurant. As the customer you never enter the kitchen. Instead You order and waiter enters the kitchen and kitchen prepares your and and then again waiter comes and servers you the Food you ordered. See Here the Waiter is the <strong>API.</strong></p><p>You → Waiter → Kitchen → Waiter → You</p><p>Similarly inside a web application the Frontend never directly talks to the database. Instead it request data from APIs. API fetch data the data requested.</p><p>Frontend → API → Backend → Database</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qppSD6ED0ywksIBRb7Dc_w.png" /><figcaption>API Architecture Diagram : AI generated Image</figcaption></figure><p>Example:</p><pre>GET /movies</pre><p>Now the server returns,</p><pre>[<br>  {<br>    &quot;title&quot;:&quot;Titanic&quot;,<br>    &quot;rating&quot;:8.7<br>  }<br>]</pre><p>The API simply delivers the information we need. It does not care who you are. Just responds to the requests.</p><h4>Types of API Requests</h4><p>Here I will summarize four most commonly used HTTP methods.</p><ol><li><strong>GET : </strong>Retrieve data</li><li><strong>POST :</strong> Create data</li><li><strong>PUT : </strong>Update data</li><li><strong>DELETE :</strong> Delete data</li></ol><p>Example:</p><pre>GET /users<br>POST /login<br>PUT /profile<br>DELETE /user/7</pre><h3>What is OAuth?</h3><p>Suppose you visit <strong>ChatGPT. </strong>Instead of creating another account you click <strong>sign up with Google.</strong> You never typed your password manually into<strong> </strong>ChatGPT. So how did ChatGPT know who are you? Is it because of AI? Not really. The answer at this point is <strong>OAuth.</strong></p><p>OAuth is basically an <strong>Authorization Framework.</strong></p><p>This allows one application to access certain information from another application without sharing your password.</p><p>This one also can be easy understand using a real-life analogy.</p><p>Now consider that you visit a hotel. Instead of giving your house key to the receptionist, you give them temporary permission to verify your identity. This is <strong>OAuth.</strong></p><h4>OAuth Flow</h4><ol><li>User clicks Login with Google.</li><li>Google asks “Do you allow this application to know your email”.</li><li>User clicks allow.</li><li>Google sends secure token.</li><li>The application logs the user in.</li></ol><p>Remember this. The application <strong>never sees your Google Password. </strong>Google handles authentication safely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hR_yo7hQmhszruOSwTsxoQ.png" /><figcaption>OAuth Login Flow : AI generated Image</figcaption></figure><h4>OAuth vs Traditional Login</h4><p>In Traditionary login the flow is very simple.</p><p><strong>User → Website → Password Database</strong></p><p>In OAuth the flow is ,</p><p><strong>User → Google → Website</strong></p><p><strong>Popular OAuth Providers:</strong></p><ul><li>Google</li><li>GitHub</li><li>Facebook</li><li>Microsoft</li><li>Apple</li></ul><h3>What is JWT?</h3><p>Okay Now suppose that you successfully log into Netflix. If Netflix asked you to enter your password every single time you clicked another movie , How are you going to react? Terrible Right? Instead , After login , Netflix gives you something like a Permission card or a visitor pass. Every time you enter another room , you simply show the pass. No troubles.</p><p>JWT works exactly like that. The term JWT stands for <strong>JSON Web Token. </strong>It is a signed token to prove that “I already logged in”. A JWT token contains information like ,</p><pre>{<br> &quot;id&quot;:10,<br> &quot;email&quot;:&quot;dinithoshada2003@gmail.com&quot;,<br> &quot;role&quot;:&quot;admin&quot;<br>}</pre><p>This information is actually digitally signed. The client stores the token usually in <strong>Local Storage , Cookies or Session Storage. </strong>Whenever the client calls an API like <strong>GET /profile </strong>It sends ,</p><pre>Authorization<br><br>Bearer JWT_TOKEN</pre><p>Now the server verifies the signature and if the signature is valid <strong>Access</strong> <strong>granted</strong> and if not <strong>401 Unauthorized error occurs.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ckHMnlLFUtykwy9XhG_vlQ.png" /><figcaption>JWT Lifecycle : AI generated Image</figcaption></figure><h4>JWT Structure</h4><p>A JWT has three parts ,</p><ol><li>Header.</li><li>Payload.</li><li>Signature.</li></ol><p>Basically it looks something like ,</p><pre>aaaaa.bbbbb.ccccc</pre><p><strong>Header</strong> contains<strong> Algorithmic information</strong> , <strong>Payload</strong> contains <strong>User</strong> <strong>Information</strong> and <strong>Signature ensures the token was not modified.</strong></p><p>Remember that JWT is <strong>NOT Encryption. </strong>JWT is encoded not encrypted. Anyone can decode it. But nobody can modify it without invalidating the signature. So, Never store passwords inside JWT.</p><h3>What is bcrypt?</h3><p>I mean we cannot just store passwords like <strong>dinith2003. </strong>Imagine a hacker steals your database. All your sensitive data is breached and stolen. Game Over. Instead , passwords are hashed.</p><p>Example:</p><pre>dinith2003 ---&gt; $2b$10$eQJd8....</pre><p>That’s bcrypt. bcrypt is a<strong> hashing algorithm</strong> designed specifically for passwords. Remember in hashing whenever you hash a password it is impossible to reverse. Unlike in encryption you can decrypt the passwords. But , Hashing cannot be undone.</p><p>Now you might be wondering Does the server decrypt it or what? No , when the user logs in the server does not decrypt the password. Instead , It hashes the entered password again. If the hashed password is equal to the Stored Hash in the Database the Login succeeds.</p><h4>Why bcrypt?</h4><p>bcrypt automatically ,</p><ol><li>Adds random salt.</li><li>Slows brute-force attacks.</li><li>Produces unique hashes even for identical passwords.</li></ol><p>Example:</p><p>Password</p><pre>dinith2003</pre><p>Hash #1</p><pre>$2b$10$......</pre><p>Hash #2</p><pre>$2b$10$......</pre><p>Different Hashes every time. This is because of the salting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a21nsONgUqbUzg9ZYa4Eqg.png" /><figcaption>Bcypt Password Hashing Workflow : AI generated Image</figcaption></figure><h3>How These Four Work Together</h3><p>Imagine now you are opening Netflix using Google Login. Here is what happens behind the screen.</p><h4>Step 01</h4><p>User clicks Login with Google → OAuth authenticates the user</p><h4>Step 02</h4><p>Google returns user information → Server Creates a JWT</p><h4>Step 03</h4><p>Browser stores the JWT → Every future API request sends the JWT</p><h4>Step 04</h4><p>User requests using GET /playlist → API verifies JWT → Returns playlists</p><h4>Step 05</h4><p>Now if the users registered with email and password instead of Google Passwords were stored using bcrypt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4Lf2OPVClVxZ-1jNCTSpw.png" /><figcaption>Comparision of OAuth, JWT, API &amp; Bcrypt Integration : AI generated Image</figcaption></figure><h3>Final Recap</h3><p>API, OAuth, JWT and bcrypt aren’t competing technologies, they are complementary building blocks of modern web applications.</p><p>Think of them as part of a security team:</p><ul><li><strong>API</strong> is the communication channel that lets applications exchange data.</li><li><strong>OAuth</strong> verifies identity through trusted providers without exposing passwords.</li><li><strong>JWT</strong> acts as a secure digital pass that proves a user is already authenticated.</li><li><strong>bcrypt</strong> protects passwords by storing irreversible hashes instead of plain text.</li></ul><p>Once you understand the role of each, it’s much easier to design and implement authentication flows. Whether you’re building a React frontend, a Spring Boot API, a Node.js backend, or any modern web application, you can combine these technologies to deliver a secure and seamless user experience.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60415aa4583e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/oauth-vs-api-vs-jwt-vs-bcrypt-four-concepts-that-every-web-developer-must-know-60415aa4583e">OAuth vs API vs JWT vs bcrypt- Four Concepts that Every Web Developer Must Know</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Load Balancing Algorithms and Their Real-World Applications]]></title>
            <link>https://medium.com/linkit-intecs/understanding-load-balancing-algorithms-and-their-real-world-applications-fa66522675ec?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa66522675ec</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[load-balancing-algorithm]]></category>
            <category><![CDATA[load-balancer]]></category>
            <category><![CDATA[load-balancing]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Wed, 08 Jul 2026 07:50:49 GMT</pubDate>
            <atom:updated>2026-07-08T07:50:49.233Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KdhshrwAIwnpRAhfkUFNWQ.png" /><figcaption>A load balancer intelligently distributes incoming requests across multiple servers to improve performance and reliability.</figcaption></figure><p>As modern applications continue to grow in scale, handling thousands or may be millions of users simultaneously has become a fundamental challenge. It does not matter whether it is a streaming platform, an E-commerce website during a flash sale or a cloud based API service, ensuring that incoming requests are processed efficiently is critical.</p><p>This is where <strong>Load Balancing </strong>come into play.</p><p>Load balancing is the process of distributing incoming network traffic or application requests across multiple servers to prevent any single server from becoming overwhelmed. By intelligently sharing the workload, organizations can improve performance, increase reliability, and ensure high availability for users.</p><p>In this article We will explore what is load balancing, the most common balancing algorithms and their advantages and disadvantages when those are used in real world applications.</p><h3>What is Load Balancing?</h3><p>Imagine a supermarket with only one cashier while hundreds of customers wait in line. The queue becomes long, customers become frustrated, and the cashier eventually becomes overwhelmed.</p><p>Now imagine opening multiple checkout counters and directing customers to the least busy one. Everyone gets served faster, and the workload is distributed evenly.</p><p>This is basically what a load balancer does inside a computer system.</p><p>A load balancer sits between clients and backend servers, receiving requests and deciding which server should handle each one.</p><h4>Benefits Include:</h4><ol><li>Improvement of application performance</li><li>Better fault tolerance</li><li>Increased scalability</li><li>Reduced server overload</li><li>Higher availability</li><li>Better user experience</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tRcXxvvW8oWqvcCrsjT-Mg.png" /><figcaption>Basic Load Balancing Architecture</figcaption></figure><h3>Common Load Balancing Algorithms</h3><h4>1. Round Robin</h4><p>This algorithm distributes requests sequentially among available servers.</p><p>For example, if we get three servers (A, B, and C):</p><ul><li>Request 1 → Server A</li><li>Request 2 → Server B</li><li>Request 3 → Server C</li><li>Request 4 → Server A</li><li>Request 5 → Server B</li></ul><p>This method is extremely simple and works well when all servers have similar hardware specifications and workloads.</p><p><strong>Advantages:</strong></p><ol><li>Easy to Implement</li><li>Fair distribution in a homogenous environments</li><li>Minimal computational overhead</li></ol><p><strong>Limitations:</strong></p><ol><li>Ignores current server load</li><li>Performs poorly when servers have different capacities</li><li>Cannot trust for long running requests</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>Small web applications</li><li>Development environments</li><li>Clusters with identical servers</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2DeSKNH3swznNGjPy7Ij3A.png" /><figcaption>Round Robin Algorithm workflow</figcaption></figure><h4>2. Weighted Round Robin</h4><p>Weighted Round Robin extends the Round Robin strategy by assigning weights based on server capacity.</p><p>Let us say we got three servers A,B and C;</p><ul><li>Server A: Weight 5</li><li>Server B: Weight 3</li><li>Server C: Weight 2</li></ul><p>Server A receives more requests because it has greater processing power.</p><p><strong>Advantages:</strong></p><ol><li>Better resource utilization</li><li>Supports heterogenous server environments</li><li>Easy to configure</li></ol><p><strong>Limitations:</strong></p><ol><li>Uses pre-defined weights rather than real-time performance</li><li>May become inefficient if server conditions change dynamically</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>Mixed hardware infrastructure</li><li>Cloud deployments with different instance sizes</li><li>Enterprise web services</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mxE8MQDnco62z2JbNlVyGQ.png" /><figcaption>Weighted Round Robin Algorithm workflow</figcaption></figure><h4>3. Least Connections</h4><p>This algorithm forwards each new request to the server currently handling the fewest active connections.</p><p>If:</p><ul><li>Server A has 120 active users</li><li>Server B has 40 active users</li><li>Server C has 15 active users</li></ul><p>The next request is routed to Server C.</p><p><strong>Advantages:</strong></p><ol><li>Dynamically adapts to workload</li><li>Prevents overloaded servers</li><li>Excellent for the session which are long-lived</li></ol><p><strong>Limitations:</strong></p><ol><li>Requires continuous monitoring of active connections</li><li>Slightly higher overhead than Round Robin</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>Websocket services</li><li>Chat applications</li><li>Video streaming platforms</li><li>Online gaming servers</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BTNQ8Thnk9VnlOxuwBFM9g.png" /><figcaption>Least Connections Algorithms workflow</figcaption></figure><h4>4. Least Response Time</h4><p>This strategy measures how quickly servers respond and selects the fastest one over counting connections.</p><p>The load balancer continuously evaluates server latency and performance before routing traffic.</p><p><strong>Advantages:</strong></p><ol><li>Optimizes user experience</li><li>Avoids slow-performing servers</li><li>Adapts to changing conditions</li></ol><p><strong>Limitations:</strong></p><ol><li>Requires constant performance monitoring</li><li>Slightly more complex to implement</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>API gateways</li><li>Financial services</li><li>Latency sensitive applications</li><li>Cloud native systems</li></ol><h4>5. IP Hash</h4><p>IP Hash uses the client’s IP address to determine which backend server should process the request.</p><p>The same client will generally be directed to the same server.</p><p><strong>Advantages:</strong></p><ol><li>Maintains session persistence</li><li>Reduces session synchronization requirements</li><li>Predictable request routing</li></ol><p><strong>Limitations:</strong></p><ol><li>Uneven traffic distribution if client IPs are not uniformly distributed</li><li>Rebalancing may occur when servers are added or removed</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>Session-bases web applications</li><li>Shopping carts</li><li>Authentication systems</li></ol><h4>6. Random Selection</h4><p>Just like the name suggests, requests are assigned randomly to available servers.</p><p>Although simplistic, randomness often produces surprisingly balanced distributions at scale.</p><p><strong>Advantages:</strong></p><ol><li>Very simple implementation</li><li>Minimal processing overhead</li></ol><p><strong>Limitations:</strong></p><ol><li>Can temporarily overload servers</li><li>Does not consider capacity or utilization</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>Small internal services</li><li>Experimental deployments</li><li>Low-traffic systems</li></ol><h4>7. Weighted Least Connections</h4><p>This algorithm combines server capacity (weights) with the number of active connections.</p><p>Larger, more powerful servers are allowed to handle proportionally more active requests while still preventing overload.</p><p><strong>Advantages:</strong></p><ol><li>Excellent resource utilization</li><li>Adapts to heterogenous infrastructure</li><li>Balances both capacity and workload</li></ol><p><strong>Limitations:</strong></p><ol><li>More computationally complex</li><li>Requires accurate configurations</li></ol><p><strong>Best to Apply For:</strong></p><ol><li>Enterprise cloud environments</li><li>Large SaaS platforms</li><li>Hybrid infrastructure</li></ol><h3>Brief Description about Real-World Applications of Load Balancing</h3><h4>Cloud Computing</h4><p>Major cloud providers distribute workloads across multiple virtual machines to ensure scalability and resilience.</p><h4>E-Commerce Platforms</h4><p>Online stores experience traffic spikes during promotions and holiday sales. Load balancing prevents server failures and keeps checkout processes smooth.</p><h4>Streaming Services</h4><p>Video streaming platforms distribute user requests across many servers and content delivery nodes to reduce buffering and improve playback quality.</p><h4>Banking and Financial Systems</h4><p>Financial institutions rely on load balancing to maintain low latency and high availability for online transactions and payment processing.</p><h4>Online Gaming</h4><p>Game servers use load balancing to distribute players evenly, reducing lag and improving gameplay stability.</p><h4>Microservices Architectures</h4><p>Modern applications built with microservices often place a load balancer in front of replicated service instances to distribute requests efficiently and support automatic scaling.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fZ4XRmJxp3Is6FpBcoAAKg.png" /><figcaption>Real World Applications</figcaption></figure><h3>Summary</h3><p>Load balancing is a foundational technology for building scalable, reliable, and high-performing distributed systems. By distributing traffic intelligently across multiple servers, organizations can maximize resource utilization, reduce downtime, and provide a seamless user experience.</p><p>No single algorithm is best for all cases. Simple methods like Round Robin are good for uniform environments while adaptive strategies like Least Connections or Least Response Time are better suited for dynamic workloads. The choice of the algorithm depends on the application requirements, the infrastructure and expected traffic patterns.</p><p>As cloud computing, microservices, and large-scale web applications continue to evolve, understanding load balancing algorithms will remain an essential skill for developers, system architects, and DevOps engineers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa66522675ec" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/understanding-load-balancing-algorithms-and-their-real-world-applications-fa66522675ec">Understanding Load Balancing Algorithms and Their Real-World Applications</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The ESP32, The University Wi-Fi, and the Rabbit Hole That Taught Me About Proxy Servers]]></title>
            <link>https://medium.com/@dinithoshada2003/the-esp32-the-university-wi-fi-and-the-rabbit-hole-that-taught-me-about-proxy-servers-f0cf33a9f13a?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/f0cf33a9f13a</guid>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[iot]]></category>
            <category><![CDATA[proxy-server]]></category>
            <category><![CDATA[reverse-proxy]]></category>
            <category><![CDATA[proxy]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 18:54:43 GMT</pubDate>
            <atom:updated>2026-07-06T18:54:43.028Z</atom:updated>
            <content:encoded><![CDATA[<p>Sometimes the best way to learn something is not through a textbook it is just by getting stuck.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i6m6VE3lsZd-bV74Be8KCQ.png" /><figcaption>AI generated Image</figcaption></figure><h3>A Curious Problem That Started Everything</h3><p>Back in my first year at university, I was working on an micro-controller based project using an ESP32.</p><p>Like in most universities, the Wi-Fi network required users to log in through a web page before accessing the internet. If you’ve ever connected to public Wi-Fi at a university, airport, hotel, or café, you’ve probably seen this type of login screen. It’s known as a <strong>captive portal</strong>.</p><p><strong>The challenge was simple:</strong></p><p>My ESP32 could not open a browser so it basically could not complete the login process.</p><p>At the time, I started searching online for possible solutions. I kept encountering a term that was completely new to me:</p><p><strong>The Proxy Server</strong></p><p>People were discussing proxy servers, gateways, relays, authentication, and captive portals. I didn’t fully understand any of it back then.</p><p>Now I am almost in my Third Year and I am going to revisit that question again. Not because I wanted to bypass my university’s network, but because I wanted to understand <strong>how the internet actually works behind the scenes.</strong></p><p>That curiosity led me into one of the most fascinating topics in networking.</p><h3>What Exactly Is a Proxy Server?</h3><p>Think of the internet like ordering food from a restaurant.</p><p>Normally:</p><pre>You  →  Restaurant</pre><p>With a proxy server:</p><pre>You  →  Waiter (Proxy)  →  Restaurant</pre><p>Instead of talking directly to the restaurant, you tell the waiter what you want.</p><p>The waiter communicates with the restaurant, gets your food, and brings it back. I got this as a real world analogy to support the idea of proxy server.</p><p>A <strong>proxy server</strong> works the same way.</p><p>Instead of your device communicating directly with a website or online service, it sends requests to the proxy server first.</p><p>The proxy forwards the request, receives the response, and sends it back to your device.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SEwybChuyNQ0CRC_l4Vqaw.png" /><figcaption>AI generated Image</figcaption></figure><h3>Why Do Proxy Servers Exist?</h3><p>Many people assume proxy servers are only used to hide IP addresses. That is just a small use case. In reality, organizations rely on proxy servers every day.</p><h4>1. Security</h4><p>Companies don’t want every employee’s computer directly communicating with the internet.</p><p>Instead they want :</p><pre>Employees<br>      ↓<br>Corporate Proxy<br>      ↓<br>Internet</pre><p>The proxy can inspect traffic, block malicious websites, and detect suspicious behavior.</p><h4>2. Privacy</h4><p>Instead of exposing your device’s IP address to every website, the proxy communicates on your behalf. Websites only see the proxy’s IP address.</p><h4>3. Content Filtering</h4><p>Schools and universities often block certain websites.</p><p>Examples include:</p><ul><li>Social media</li><li>Gambling websites</li><li>Malware sites</li><li>Adult content</li></ul><p>Every request passes through the proxy before reaching the internet.</p><h4>4. Caching</h4><p>Suppose 500 students all visit the same university homepage.</p><p>Without caching:</p><pre>500 requests</pre><p>With a proxy cache:</p><pre>First student downloads the page.</pre><pre>The proxy stores it.</pre><pre>Next 499 students receive the cached copy.</pre><p>This reduces bandwidth usage and speeds up browsing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fzbWNzfGpQ5TQIv7-_UhNw.png" /><figcaption>AI generated Image</figcaption></figure><h4>5. Load Balancing</h4><p>Large services use reverse proxies to distribute incoming traffic across multiple servers.</p><p>Instead of:</p><pre>Users<br>   ↓<br>One Server</pre><p>They use:</p><pre>Users<br>   ↓<br>Reverse Proxy<br>   ↓ <br>Server 1<br>Server 2<br>Server 3</pre><p>This prevents one server from becoming overloaded.</p><h3>Forward Proxy vs Reverse Proxy</h3><p>These two terms confuse many beginners.</p><h4>Forward Proxy</h4><p>Works on behalf of the client.</p><pre>You<br> ↓<br>Forward Proxy<br> ↓<br>Internet</pre><p>The client chooses to use the proxy.</p><p>Examples:</p><ul><li>Corporate networks</li><li>Privacy tools</li><li>Content filtering</li></ul><h4>Reverse Proxy</h4><p>Works on behalf of the server.</p><pre>Internet Users<br>       ↓<br>Reverse Proxy<br>       ↓<br>Website Servers</pre><p>Users don’t even know it exists.</p><p>Popular websites like online stores and streaming platforms commonly use reverse proxies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lWOhuyFotndBwM_sXj_ezw.png" /><figcaption>AI generated Image</figcaption></figure><h3>Where Have You Already Used a Proxy Without Realizing It?</h3><p>You probably use proxy technologies every day.</p><p>Examples include:</p><ul><li>Company office networks</li><li>University computer labs</li><li>School internet</li><li>Public Wi-Fi</li><li>Large websites</li><li>Cloud services</li><li>Content delivery networks (CDNs)</li></ul><p>Most users never notice they’re interacting with one.</p><h3>What Is a Captive Portal?</h3><p>Let’s go back to my university story. When you connect to some Wi-Fi networks, you don’t immediately get internet access. Instead, you’re redirected to a login page. This is called a <strong>captive portal</strong>.</p><p>Examples include:</p><ul><li>Universities</li><li>Airports</li><li>Hotels</li><li>Coffee shops</li><li>Libraries</li></ul><p><strong>The purpose is to:</strong></p><ul><li>Authenticate users</li><li>Display terms and conditions,</li><li>Manage bandwidth</li><li>Record access when required</li><li>Protect the network from unauthorized use.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D-bsifw-9SDOHfUqMCuDFA.png" /><figcaption>AI generated Image</figcaption></figure><h4>Why My ESP32 Couldn’t Connect</h4><p>An ESP32 is a microcontroller.</p><p>It can:</p><ul><li>Connect to Wi-Fi</li><li>Send HTTP requests</li><li>Communicate with cloud APIs.</li></ul><p>However, it doesn’t include a normal web browser that can display a captive portal page and let a user interact with it. So while it could join the Wi-Fi network, it couldn’t complete the login flow required by the network. That mismatch is what sparked my curiosity.</p><h4>Can Proxy Servers Help?</h4><p>I did my own research back then and I found discussions suggesting that proxy servers could be part of certain network architectures.</p><p>For example, in authorized environments, a proxy or gateway might relay traffic between IoT devices and external services after a user or administrator has properly authenticated the network.</p><p>However, it’s important to understand that a proxy is <strong>not</strong> a magic tool for bypassing captive portals or network access controls. Those systems are designed to enforce authentication and usage policies, and attempting to circumvent them without permission may violate the network’s terms of use or applicable laws.</p><p>If you’re building an IoT project for a managed network, the appropriate approach is to work with the network administrator or use a network configuration that explicitly supports your devices.</p><h3>How Does a Basic Proxy Server Work?</h3><p>At the high level, the flow is simple.</p><pre>Client sends request<br>        ↓<br>Proxy receives request<br>        ↓<br>Proxy checks policies<br>        ↓<br>Proxy forwards request<br>        ↓<br>Website responds<br>        ↓<br>Proxy returns response<br>        ↓<br>Client receives data</pre><p>The proxy may also:</p><ul><li>Log requests</li><li>Filter content</li><li>Cache responses</li><li>Enforce authentication</li><li>Apply security policies.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RiTQ9JQjOdjbPjbkhZmiIw.png" /><figcaption>Ai generated Image</figcaption></figure><h3>Common Types of Proxy Servers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jbJXKR8m1yUj_7bDC34MsQ.png" /><figcaption>AI generated Image</figcaption></figure><h3>Where Are Proxy Servers Used?</h3><p>Almost everywhere.</p><p>Examples include:</p><ul><li>Enterprise security</li><li>Schools and universities</li><li>Banking systems</li><li>Content delivery</li><li>API gateways</li><li>Cloud infrastructure</li><li>Malware filtering</li><li>Internet monitoring</li><li>Load balancing</li><li>Performance optimization</li></ul><p>Many modern web applications rely on reverse proxies to improve scalability and resilience.</p><h3>What I Learned From One Simple Question</h3><p>It’s funny how a single hardware project can send you down an entirely different learning path. At first, my goal was simply to get an ESP32 online. Instead, I ended up discovering concepts like:</p><ul><li>HTTP</li><li>DNS</li><li>Authentication</li><li>Reverse proxies</li><li>Forward proxies</li><li>Firewalls</li><li>Captive portals</li><li>Gateways</li><li>Load balancing</li></ul><p>Sometimes, the most valuable part of a project isn’t solving the original problem. It’s the everything you learn while trying.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0cf33a9f13a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Typing Every Line to Guiding AI: Why Coding Fundamentals Still Matter in the Age of Agentic…]]></title>
            <link>https://medium.com/linkit-intecs/from-typing-every-line-to-guiding-ai-why-coding-fundamentals-still-matter-in-the-age-of-agentic-6895b4122c7f?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/6895b4122c7f</guid>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Tue, 02 Jun 2026 05:10:20 GMT</pubDate>
            <atom:updated>2026-06-02T05:10:20.418Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Typing Every Line to Guiding AI: Why Coding Fundamentals Still Matter in the Age of Agentic Development</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h36xjchOxRsKTkdTEuOgyA.png" /><figcaption>AI generated Image</figcaption></figure><p>A few years ago, I was working with my laptop staring at a blank React project. This was not because I didn’t know what to build. I mean I got plenty of ideas. A healthcare platform, A chat application, A landing page…</p><p>But the problem was the one every developer knows too well: turning ideas into actual code. Open the IDE, Create folders, Set up routes, Debug errors, Fix dependencies, Search stack overflow, Repeat. Hours later, Progress felt painfully slow. Then something changed. Instead of manually writing every component, I started working differently. I described what I wanted “Build a responsive authentication page with React + Vite , Firebase and Modern Dark themed UI”. Guess what within few seconds , code appeared.</p><p>Not just some code snippets. Full working structures. For the first time in my life coding felt like typing instructions into a machine and more like collaborating with one.</p><p>That was my first real encounter with <strong>Agentic Coding </strong>or what many people casually calls <strong>Vibe coding.</strong></p><p>I mean honestly I felt like stepping into the future. But after the initial excitement wore off , Now a bigger question appeared:</p><p><strong>IF AI CAN WRITE CODE, DO WE STILL NEED THE FUNDAMENTALS?</strong></p><p>Short Answer: <strong>Yes….Absolutely Yes</strong></p><p>Now Let us dive deep talking about why we still need the fundamentals.</p><h3>The Evolution of Coding Eras</h3><h4>1.The Manual Era</h4><p>There was a time when developers wrote nearly everything from scratch. Need a website? Write HTML manually and then style with CSS manually and after that Add JavaScript manually.</p><p>Need backend functionality? Set up servers, routes, authentication logic, database connections all manually by hand. This era actually built strong engineers. Why?</p><p>Because every feature forced you to understand the system deeply. You learned:</p><ol><li>Data Structures</li><li>Algorithms</li><li>Memory</li><li>Networking</li><li>Architecture</li><li>Debugging</li></ol><p>Of course It was slower , but incredibly educational.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gWhrEj7K44regk1AEyQzsw.png" /><figcaption>AI generated Image</figcaption></figure><h4>2.The Framework Era</h4><p>Then after that era came the framework and libraries. Tools like,</p><ol><li>React</li><li>Angular</li><li>Vue</li><li>Spring boot</li><li>Django</li><li>Node.js</li></ol><p>suddenly made development faster than the previous era.</p><p>Now , Here No need to reinvent routing. state management or server logic. Instead of building every thing brick by brick Here developers were able to assemble systems with better tools. This was a massive productivity shift. But it also introduced a new risk. Now what is this risk:</p><p>Developers could now build apps without fully understanding the framework was abstracting away. I mean you could create a React app without deeply understanding:</p><ol><li>JavaScript closures</li><li>Rendering cycles</li><li>State management principles</li><li>Browser behavior</li></ol><p>See Still the fundamentals mattered. Because once things broke, abstractions stopped helping.</p><h4>3.The Stack Overflow/GitHub Era</h4><p>Here came the era that many developers know intimately.</p><p>Search-driver development. Error? Copy it into Google.</p><p>Need Authentication? Search GitHub</p><p>Need a date picker? Install package</p><p>This era normalized rapid problem solving. Developers became better at:</p><ol><li>Research</li><li>Reading docs</li><li>Adapting code</li></ol><p>This was not actually cheating. This was practical engineering. The Software Development became less about memorization and more about problem solving. But here again If someone had copied the code Those were never the real engineers , Bugs became nightmares for them.</p><h4>4. The Agentic Era</h4><p>Now We are here in this era. The New Era where everyone tries to use the best agent for coding. Now Instead of searching for answers , you delegate tasks.</p><p>Basically What developers are doing here:</p><ul><li>Build this feature</li><li>Refactor this code</li><li>Debug this issue</li><li>Explain this function</li><li>Generate tests</li><li>Optimize performance</li></ul><p>Right now AI does not just autocomplete lines. It increasingly acts like an autonomous collaborator. This changes almost everything. Right now in this era the coding is actually shifting from writing the code to directing systems. The developer actually become less of a typist and more of a system thinker. This is kind of powerful. But sometimes people misunderstand the future. AI can generate code of course Yes. But generated code is not always a good code. It actually does not become a good code automatically. That difference matters a lot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kEYKv7dGhyPN2FWd34bgVw.png" /><figcaption>AI generated Image</figcaption></figure><h3>The Pros of Agentic Coding</h3><h4>1.Massive speed boost</h4><p>Here the Boilerplate work becomes nearly instant. Instead of spending hours building forms, CRUD operations, layouts, APIs now We can generate first versions in minutes. This is actually used for MVPs , Prototypes, Hackathons even for some startups right now.</p><h4>2.Lower Barrier to entry</h4><p>Beginners can now build things earlier and Guess what this is huge. Someone with basic knowledge can actually experiment with web apps, APIs, Automation, AI integrations much faster than before. Overall I guess this is a plus point.</p><h4>3.Better Learning Assistant</h4><p>You should know that If you can use AI correctly Now AI can be your personal and incredible tutor. You can basically ask:</p><ul><li>Why is this error happening?</li><li>Explain closures simply</li><li>Compare JWT vs sessions</li><li>Refactor this code</li></ul><p>This compresses learning loops dramatically.</p><h4>4.Focus on higher-level thinking</h4><p>Less time spent on repetitive syntax. More time spent on:</p><ul><li>architecture</li><li>product thinking</li><li>user experience</li><li>business logic</li></ul><p>Now this is actually valuable.</p><h3>The Cons of Agentic Coding</h3><h4>1.False Confidence</h4><p>This is probably the biggest danger. Code that works is not always the code that is correct. Beginners can think like “Ahh the app runs fine So I understand it”. Not really. See whether you can explain:</p><ul><li>why state updates trigger re-renders?</li><li>why a query is slow?</li><li>why authentication failed?</li><li>why memory leaks happen?</li></ul><p>If not you are just another AI user who is basically renting knowledge. Not actually owning it.</p><h4>2.Debugging becomes painful without fundamentals</h4><p>AI will actually get you to 80 % real quick. But that last 20 % can be brutal. When weird bugs happen:</p><ul><li>deployment failures</li><li>race conditions</li><li>CORS issues</li><li>async bugs</li><li>architecture bottlenecks</li></ul><p>AI suggestions alone often are not enough. You need reasoning and analytical thinking.</p><h4>3.Overdependence Risk</h4><p>Relying entirely on AI for every step can weaken independent thinking. If every problem is outsourced immediately, your problem-solving muscles never develop. Critical thinking , Logical Thinking as well as Analytical thinking will be destroyed gradually. It’s like using a calculator before learning arithmetic. Convenient? Yes. Smart long-term? Not really.</p><h4>4.Generated Technical debt</h4><p>AI can produce code fast. Very fast. Sometimes too fast.</p><p>Without careful review, teams may accumulate:</p><ul><li>poor architecture</li><li>duplicated logic</li><li>security issues</li><li>hidden bugs</li></ul><p>This velocity without understanding can become expensive later.</p><h3>Fundamentals Are Not Dead</h3><p>This is what I actually want to highlight in this blog. People love dramatic headlines. You know “Coding is Dead”, “Software Engineers will be replaced”, “Do not study Computer Science Now”, “AI writes everything now”. Relax . Most of these are actually either rage baits or someone’s attempt to grab your desperate attention.</p><p>Coding is changing. Evolving. But not disappearing. What is actually happening here is Low level implementation is being automated and Higher value is given to High level thinking which is actually more valuable. And to think well, you still need fundamentals. Because fundamentals will teach you :</p><ul><li>How systems work</li><li>Why code behaves a certain way</li><li>How to debug intelligently</li><li>How to evaluate AI output critically</li></ul><p>AI makes strong developers faster. But weak fundamentals + AI can create fragile developers. The future probably belongs to those who can do both:</p><ul><li>Understand deeply</li><li>Move fast with AI</li></ul><p>That combination is dangerous in the best way.</p><h4>Conclusion</h4><p>So Before the end I want to say Agentic coding is not the death of programming. It is the next era of coding . You know:</p><p>just like frameworks did not kill programming ,</p><p>just like libraries did not kill programming,</p><p>just like Stack Overflow / GitHub did not kill programming</p><p>AI will not kill programming. AI will change the workflow. But keep in mind fundamentals still matter. So never skip the Hard stuff.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6895b4122c7f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/from-typing-every-line-to-guiding-ai-why-coding-fundamentals-still-matter-in-the-age-of-agentic-6895b4122c7f">From Typing Every Line to Guiding AI: Why Coding Fundamentals Still Matter in the Age of Agentic…</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Figma to Production Code in Minutes: Using Figma MCP with Cursor AI IDE]]></title>
            <link>https://medium.com/linkit-intecs/from-figma-to-production-code-in-minutes-using-figma-mcp-with-cursor-ai-ide-f6bc8c5d594b?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/f6bc8c5d594b</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[figma-mcp]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[cursor]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Wed, 11 Mar 2026 04:33:39 GMT</pubDate>
            <atom:updated>2026-03-11T04:33:39.439Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2pNbd3h4z2FWPfDcVwYi9Q.jpeg" /><figcaption>AI Generated Image</figcaption></figure><p>Few months ago, I was staring at a beautifully designed webpage in Figma. Perfect layout, spacing and the typography was just clean. And there I was zooming to check padding, Opening Dev-Tools, Copying hex codes, Inspecting margins and writing Flexbox manually. Yeah, This was actually a good learning experience for me. But, What about effeciency? Effectiveness? Quick Designs? Then I asked myself “Why am I still doing this manually in this AI Era?”</p><p>That is when I discovered MCP(Model Context Protocol) and How it works with the Cursor.</p><h3>What is MCP(Model Context Protocol)?</h3><p>MCP is a standardized protocol that allows AI models to connect to external tools and data sources in a structured way.</p><p>Instead of giving AI:</p><ul><li>Screenshots</li><li>Copied text</li><li>Manual explanations</li></ul><p>MCP allows AI to directly access structured data from tools like Figma</p><h3>Simple Explanation of MCP</h3><p>Think of this MCP as a bridge between AI and your real project tools. Without MCP AI guesses based om prompts but with the MCP AI reads actual data.</p><p>It is like describing your house to someone or giving them the architectural blueprints of your house.</p><h3>What are MCP Servers?</h3><p>Now let’s go deeper into this.</p><p>A <strong>MCP Server </strong>is a service that:</p><ol><li>Connects to an external tool(Like Figma)</li><li>Extracts structured data</li><li>Exposes that data to AI models in a standardized format</li></ol><p><strong>In Technical terms:</strong> An MCP server translates tool-specific APIs into AI-understandable structured context.</p><h4>What does it usually expose?</h4><ol><li>Components</li><li>Layout Hierarchy</li><li>Metadata</li><li>Design tokens</li><li>Structured content</li></ol><p>So when AI(like cursor) asks, “What does this frame contain?” the MCP server responds with structured JSON-like data, not just visual info.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nVs8Kz_U6OPYXO2bu5XPyA.png" /><figcaption>AI generated Image</figcaption></figure><h3>What is Figma MCP?</h3><p>Figma MCP is a MCP implementation that connects to Figma and exposes:</p><ol><li>Frames</li><li>Auto Layout rules</li><li>Component hierarchy</li><li>Colors and styles</li><li>Typography</li><li>Spacing</li><li>Design tokens</li></ol><p>Instead of AI looking at a screenshot, it sees the frame and the components there.Now, this is powerful. It actually means AI understands:</p><ul><li>What should be a reusable React component</li><li>What should use CSS Grid</li><li>What spacing values to use</li><li>What should use Flexbox</li></ul><p>Isn’t this powerful enough to make all your manual design and coding workflow easy?</p><h3>What is Cursor AI IDE?</h3><p><strong>Cursor</strong> is an AI-powered code editor built on top of VS Code.</p><p>Unlike basic AI tools Cursor</p><ol><li>Understand your entire code base.</li><li>Edits multiple files.</li><li>Refactors intelligently.</li><li>Generates components contextually.</li><li>Connects with MCP servers.</li></ol><h3>How Figma MCP + Cursor Work Together</h3><p>Full Workflow:<br>1.Figma design exists.</p><p>2.Figma MCP server exposes design structure.</p><p>3.Cursor connects to the MCP server.</p><p>4.AI reads structured design data.</p><p>5.AI generates production-ready code.</p><p>So , basically No need to use screenshots , No manual pixel checking , No guessing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FIvmJLxuJKIucDFqBcE6hA.png" /><figcaption>AI Generated Image</figcaption></figure><h3>Beginner Guide: Small Project Example</h3><p>Okay Let me guide through this little project to building a simple landing page,</p><h4>Project Goal</h4><p>Convert a Figma landing page into Next + Tailwind project using Cursor + Figma MCP.</p><h4>STEP 01: Prepare Your Figma File</h4><p>Make sure the Figma design:</p><ol><li>Uses Auto Layout</li><li>Has properly named layered</li><li>Uses reusable components</li><li>Has consistent styles</li></ol><p>This is Very important.</p><p>Cursor AI works best with clean structure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ALrCYbZl2Zvfm91C7Y1pg.png" /><figcaption>My Figma Landing Page Design</figcaption></figure><h4>STEP 02:Set Up Your Next Project</h4><p>Use these commands</p><pre>npx create-next-app figma-mcp-demo<br>cd figma-mcp-demo<br>npm install</pre><p>Then Open the project in Cursor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TnKZgrXcW3lzNHDhYB2PLg.png" /><figcaption>New Next Project Opened in Browser</figcaption></figure><h4>STEP 03:Connect Figma MCP</h4><p>This depends on your MCP setup, but conceptually:</p><ol><li>Install Figma MCP server</li><li>Authenticate with Figma API token</li><li>Connect Cursor to the MCP Endpoint</li></ol><p>Now Cursor can access:</p><ul><li>Frames</li><li>Components</li><li>Layout metadata</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*60K-DaLqbVatnhjbMa93bA.png" /><figcaption>Figma MCP Installed on Cursor IDE</figcaption></figure><h4>STEP 04:Ask Cursor to Generate Code</h4><p>In Cursor, you can prompt:</p><p>“Generate a React component for the Landing Page frame using Tailwind CSS. Use proper reusable components based on Figma structure.”</p><p>Because of MCP, Cursor already understands:<br>Which sections are reusable</p><ul><li>Layout direction</li><li>Padding</li><li>Font styles</li></ul><p>Here Carefully look at the Proper spacing , Correct hierarchy , Clean structure. This is not random generation. This is structured generation powered by MCP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D-RiX36lHQ8wYYcUy4v77w.png" /><figcaption>Output After Code Generation</figcaption></figure><h3>Why This Is a Game-Changer for Developers</h3><p>If you are building:</p><ul><li>SaaS dashboards</li><li>Landing pages</li><li>Admin panels</li><li>Healthcare apps</li><li>AI products</li></ul><p>This workflow can:</p><ul><li>Reduce UI development time by 40–60%</li><li>Improve design accuracy</li><li>Reduce designer-developer friction</li><li>Enforce design system consistency</li></ul><h3>Limitations:</h3><ul><li>AI-generated code still needs review</li><li>Complex animations may require manual coding</li><li>Poorly structured Figma files produce messy code</li><li>Not a replacement for frontend knowledge</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f6bc8c5d594b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/from-figma-to-production-code-in-minutes-using-figma-mcp-with-cursor-ai-ide-f6bc8c5d594b">From Figma to Production Code in Minutes: Using Figma MCP with Cursor AI IDE</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Real-Time Technologies and Platforms for IoT Projects]]></title>
            <link>https://medium.com/linkit-intecs/real-time-technologies-and-platforms-for-iot-projects-e0186801f3e6?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0186801f3e6</guid>
            <category><![CDATA[websocket]]></category>
            <category><![CDATA[network]]></category>
            <category><![CDATA[iot]]></category>
            <category><![CDATA[mqtt]]></category>
            <category><![CDATA[real-time-communication]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 05:31:45 GMT</pubDate>
            <atom:updated>2026-02-19T05:31:45.115Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>A Sensor Blinked And a System Responded!</strong></h3><p>At 2.30am in the morning where most of the people are in sleep a temperature sensor inside a small warehouse crossed a critical threshold. But, Within seconds, an SMS alert appeared on a mobile phone, a buzzer activated locally, and a notification reached the facility manager. No human was watching a screen. No manual triggering.</p><p>Yup ! This is not Magic</p><p>This is what we call <strong>Real-Time IoT.</strong></p><p>Behind this instant reaction lies a very carefully designed pipeline of sensors, communication protocols, platforms and software architectures. In this article, <strong>we will travel step by step through that pipeline</strong> starting from the physical world moving through networks and cloud platforms and ending at the real-time dashboards and alerts.</p><p>From this blog, you will learn which technologies to use and why they are used and where architectural decisions matter most.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/748/0*BnOWL62HOl1xq3N3.png" /><figcaption>High level IoT Architecture: Image from ScienceSoft.com</figcaption></figure><h3>Why Real-Time Matters in IoT?</h3><p>I still see many people talk about “sending data to the cloud”. This is not bad but in real world systems, the timing of that data is more important than the data itself. I guess from the scenario I have given you in the beginning You might have an idea about how important it is to deliver the data timely.</p><p>Consider the difference:</p><ul><li>A temperature value received <strong>10 minutes late</strong></li><li>The same value received <strong>in 1 second</strong></li></ul><p>For applications like:</p><ul><li>Fire detection</li><li>Patient vital monitoring</li><li>Industrial fault detection</li><li>Smart traffic systems</li></ul><p>Here Late data is effectively the<strong> WRONG DATA.</strong></p><p>This is the where the Real Time technologies become the backbone of the IoT systems.</p><h3>What “Real-Time” Actually Means in IoT Systems?</h3><p>Before diving deep into tech and tools It is important to clarify the term <em>real-time.</em></p><h4>Hard vs Soft Real-Time</h4><p><strong>Hard real-time systems:</strong> Missing a deadline causes system failure (Ex: airbag deployment).</p><p><strong>Soft real-time systems: </strong>Delays reduce usefulness but do not cause total failure (Ex: live dashboards).</p><p>Most of the IoT systems that we see often fall into the category of<strong> soft</strong> <strong>real-time </strong>category, where responses are expected within milliseconds to seconds.</p><h4>Where Delays Come From</h4><p>Latency in IoT systems accumulates across layers:</p><ul><li>Sensor sampling interval</li><li>Microcontroller processing time</li><li>Network type (Wi‑Fi, GSM, LPWAN)</li><li>Communication protocol overhead</li><li>Cloud ingestion and processing</li><li>Frontend rendering</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-k9zvbx1azjFaLS_iKdWPw.png" /><figcaption>AI generated Image</figcaption></figure><p>Understanding these layers is essential before choosing technologies.</p><h3>The Journey of Data: From Sensor to a Screen</h3><p>Let us follow a single sensor reading:</p><ul><li>A sensor measures a physical parameter</li><li>A microcontroller preprocesses the data</li><li>Data is transmitted over a network</li><li>A communication protocol delivers the message</li><li>A cloud platform routes and processes it</li><li>A user interface updates instantly</li></ul><h3>Communication Protocols That Enable Real-Time IoT</h3><h4>MQTT-The Backbone of Real-Time IoT</h4><p>MQTT (Message Queuing Telemetry Transport) is the most widely used protocol in real-time IoT systems.</p><p>This is not like HTTP,MQTT uses a <strong>publish-subscribe model.</strong></p><ul><li>Devices publish data to topics</li><li>A broker routes messages</li><li>Applications subscribe to topics</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N1avRgfKLes3kdGlAq3jAA.png" /><figcaption>AI generated Image</figcaption></figure><h4>Why this MQTT Works so Well ?</h4><ul><li>Extremely lightweight</li><li>Low bandwidth consumption</li><li>Reliable on unstable networks</li><li>Scales efficiently</li></ul><h4>Quality of Service (QoS)</h4><ul><li><strong>QoS 0</strong> — Fastest, no guarantee</li><li><strong>QoS 1</strong> — At least once</li><li><strong>QoS 2</strong> — Exactly once</li></ul><p>Choosing QoS is a <strong>trade-off between latency and reliability</strong>.</p><h4>WebSockets-Real-Time for Dashboards</h4><p>While MQTT excels between devices and servers, WebSockets dominate the frontend layer.</p><p><strong>These WebSockets</strong>:</p><ul><li>Maintain persistent connections</li><li>Enable bi-directional communication</li><li>Eliminate HTTP polling delays</li></ul><p><strong><em>In many systems:</em></strong></p><ul><li>MQTT handles device communication</li><li>WebSockets stream data to dashboards</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T9CoYMUcn3xsJBdtmm2WLg.png" /><figcaption>AI Generated Image</figcaption></figure><h4>HTTP / REST-Near Real-Time Simplicity</h4><p>This is actually popular because of the simplicity and compatibility.</p><p><strong><em>However:</em></strong></p><ul><li>It is request–response based</li><li>Introduces polling delays</li><li>Has higher overhead</li></ul><p><strong><em>Best suited for:</em></strong></p><ul><li>Periodic data uploads</li><li>Prototypes and academic projects</li></ul><h4>CoAP-Real-Time for Constrained Devices</h4><p>CoAP (Constrained Application Protocol) is designed for low-power environments.</p><ul><li>UDP-based</li><li>Minimal overhead</li><li>REST-like semantics</li></ul><p>Used in large-scale sensor networks and battery-powered deployments.</p><h3>Cloud Platforms That Power Real-Time IoT</h3><h4>ThingSpeak -Prototyping and Learning</h4><p>ThingSpeak is widely used in academic and early stage projects.</p><p><strong><em>Strengths:</em></strong></p><ul><li>Easy setup</li><li>Built-in visualization</li><li>REST and MQTT support</li></ul><p><strong><em>Limitations:</em></strong></p><ul><li>Limited scalability</li><li>Not suitable for complex workflows</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*52GXdLLM3pAjUP5u4--D9Q.png" /><figcaption>ThingSpeak screenshot</figcaption></figure><h4>Firebase Realtime Database-Instant Synchronization</h4><p>Firebase provides real-time data synchronization.</p><p><strong><em>When data changes:</em></strong></p><ul><li>All connected clients update instantly</li></ul><p><strong><em>This makes Firebase ideal for:</em></strong></p><ul><li>Live dashboards</li><li>Mobile and web applications</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vOVEqkDbqLr-7ORcGnNFSw.png" /><figcaption>AI generated Image</figcaption></figure><h4>AWS IoT Core &amp; Azure IoT Hub-Industrial Scale</h4><p><strong><em>Enterprise platforms offer:</em></strong></p><ul><li>Secure device authentication</li><li>Managed MQTT brokers</li><li>Real-time rule engines</li><li>Analytics and AI integration</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fdxwhtUuR4A9FXSmQ8XdyQ.png" /><figcaption>AI generated Image</figcaption></figure><p>Designed for <strong>thousands to millions of devices</strong>.</p><h4>Edge Computing: When Real-Time Can’t Wait for the Cloud</h4><p>Sending every data point to the cloud introduces delay.</p><p><strong>Edge computing</strong> shifts decision-making closer to devices.</p><p><strong><em>Benefits:</em></strong></p><ul><li>Lower latency</li><li>Reduced bandwidth usage</li><li>Improved reliability</li></ul><p><strong><em>Example:</em></strong></p><ul><li>ESP32 triggers a local alarm instantly</li><li>Only critical data is sent to the cloud</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rfW9lv7QDD7kdpD8uFHkdA.png" /><figcaption>AI generated Image</figcaption></figure><h4>Security in Real-Time IoT Systems</h4><p>Speed must not compromise security.</p><p><strong><em>Essential measures:</em></strong></p><ul><li>TLS encryption</li><li>Secure MQTT (MQTTS)</li><li>Device certificates</li><li>Token-based authentication</li></ul><p>Security must be <strong>designed in from the start</strong>, not added later.</p><h4>Challenges and Trade-Offs</h4><p><strong><em>Real-time IoT design involves balancing:</em></strong></p><ul><li>Latency</li><li>Reliability</li><li>Power consumption</li><li>Scalability</li><li>Cost</li></ul><p>Every architectural choice is a compromise.</p><p>As some final words I need to say that Real-time IoT systems do more than collect data.<br>They <strong>respond to the physical world as it changes</strong>.</p><p>When designed correctly, they become invisible yet powerful and quietly monitoring, reacting, and protecting without human intervention.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0186801f3e6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/real-time-technologies-and-platforms-for-iot-projects-e0186801f3e6">Real-Time Technologies and Platforms for IoT Projects</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Art of Not Giving Up: Why “Just Passing the Exam” Is a Dangerous Goal]]></title>
            <link>https://medium.com/linkit-intecs/the-art-of-not-giving-up-why-just-passing-the-exam-is-a-dangerous-goal-d0b030ba12c9?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0b030ba12c9</guid>
            <category><![CDATA[motivation]]></category>
            <category><![CDATA[goals]]></category>
            <category><![CDATA[pshychology]]></category>
            <category><![CDATA[study-tips]]></category>
            <category><![CDATA[student-life]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Thu, 15 Jan 2026 05:34:25 GMT</pubDate>
            <atom:updated>2026-01-15T05:34:25.112Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RYJbhMUDAcMGJUZ7iH3_lw.png" /><figcaption>AI generated Image</figcaption></figure><p>Have you ever felt this strange sudden emptiness in your mind just after you finish an exam? Well personally for me Few years ago I used to feel like this. If I say you very openly It was like,<br>“I had studied for weeks.”<br>“I had stressed, sacrificed sleep, and isolated myself.”<br>“I passed.”</p><p>And Yet Nothing !</p><p>Does this sound familiar for you? No satisfaction. No pride. Just relief. And within days, most of what I had “learned” was already fading. Okay , I guess this is kind of a situation most of us are facing and Actually, I cannot blame you or blame myself for this. I mean We all are trained by a certain system within the country to study like this. Practice like this for exams. We were advised by elders, teachers to go in this pathway. Rarely, We meet someone who is opposed to this system. Well To be honest the way we got ready for exams are not bad. That is kind of a fascinating method. Study and understand theory and then practice with lot of questions and then passed ! As a young man for me That is kind of “Done and Dusted” status.</p><p>But , Did you study just to pass the exam? Was it your primary goal? If the answer is Yes Then this blog is for you. I mean this is reason why many things faded away just after the exam. It is actually fine If you are not going to use whatever you learnt in the future. Well honestly I am an undergraduate right now. The things that I am learning right now during the lectures are really important for me to grow as a professional. For you the situation might be the same. Right now If we study<strong> JUST TO PASS AN EXAM</strong> that is a <strong>Dangerous Goal</strong>. Yes I have to emphasize this fact.</p><p>I see many of us sometimes ask a question ourselves.<br>“If all this effort ends the moment the exam ends… why am I even doing this?”</p><p>Most students never ask this question. And that’s exactly why so many burn out, lose motivation, or give up entirely.</p><h3>The silent mindset that traps students</h3><p>“I am studying this just to pass this exam”</p><p>I know this sentence and It sounds harmless. Practical even !</p><p>But, If you think deeply in bit of a psychological aspect, It is one of the most dangerous goals a student can set.</p><p>This is what We call a <strong>Localized Goal.</strong></p><p>A localized goal is short-term, event-based, and disconnected from long-term meaning. It exists only until a single checkpoint is crossed. It could be an exam,a grade, a semester. Tell me right now. Do you really work for these kind of things? See the thing is once this checkpoint is reached , the goal dies. And when the goal die, motivation dies with them.</p><h3>Why the brain resists “just passing” goals</h3><p>Psychology tells us something important:</p><p>The human brain can tolerate difficulty only when it sees meaning.</p><p>When our goal is just to pass an exam, your brain subconsciously asks:<br>“And then what?”</p><p>For this now you might not have a properly planned answer.</p><p>So your mind quietly responds with :</p><ul><li>Procrastination</li><li>Resistance</li><li>Fatigue before you even start a work</li><li>The urge to do the bare minimum.</li></ul><p>This is not because You are lazy not because You are incapable. But because your brain sees no future value in the suffering. Passing state becomes the survival not growth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J7QQwFLyT1OLOQNq.jpg" /><figcaption>Credit: <a href="https://red.msudenver.edu/">https://red.msudenver.edu/</a></figcaption></figure><h3>The motivation problem nobody talks about</h3><p>Localized goals rely almost entirely on <strong>extrinsic motivation</strong>:</p><ol><li>Grades</li><li>Fear of failure</li><li>Parental pressure</li><li>Social comparison</li></ol><p>This kind of motivation or let us say this kind of mindset works only for Brief goals. In that very moment the exam is over:</p><ol><li>Discipline collapses</li><li>Curiosity disappears</li><li>Learning stops</li></ol><p>This is why many students:</p><ol><li>Forget subjects they once ‘aced’</li><li>Feel lost between semesters</li><li>Lose confidence despite good grades</li></ol><p>The thing that I realized and understood was that This kind of mindset is not building a person. People just escape failure.</p><h3>Why this mindset makes giving up feel logical</h3><p>The Truth that I am going to spill out might be uncomfortable.<br>“Most students do not give up because they are weak. They just give up because their goals are too small to carry the pain”</p><p>For an example consider a goal like “Just pass this exam” cannot justify things like,</p><ul><li>Long nights</li><li>Confusion</li><li>Repeated failure</li><li>Self-doubt</li></ul><p>So when things get hard, quitting feels rational which is not a good thing.The problem was never the Effort. It was always there. It was the meaning. You might think this is a little thing, but this can actually affect really bad to your life, if you keep on setting localized goals.</p><h3>The shift that changed everything for me</h3><p>I have failed so many times in my life and still I am failing. But, from those failures I always learnt something new and for my next step I did it in the correct way. I was person who used to keep localized goals until my A/Ls . I was that kid who studied only the syllabus facts and just to pass an exam, just to get a A pass. After that everything was gone. I thought myself and did a little research and understood these facts.</p><p>Okay, Now What did I changed:</p><p>At some point I stopped asking:<br>“Will this come in the exam?”</p><p>And started asking:<br>“What kind of thinking is this developing?”<br>“What skill is this training in me?”</p><p>“How is this shaping the person I’m becoming?”</p><p>This is what How I changed from <strong>Localized Goal states</strong> to <strong>Overarching goal states</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C1-uPWDxDCP0HRKxIMeTow.png" /><figcaption>Difference between Localized and Overarching Goal states</figcaption></figure><p>An <strong>overarching goal state</strong> is a <strong>long-term, identity-level orientation</strong> that guides many short-term actions.</p><p>Here the exam did not dissapear. It just stopped being the <strong>destination.</strong> Instead it became a<strong> checkpoint.</strong></p><p>When you did this kind of a transformation, something powerful happens:</p><ol><li>Failure becomes feedback</li><li>Difficulty becomes necessary</li><li>Giving up stops making sense</li></ol><p>See Now quitting does not just mean failing an exam. It means abandoning the person you’re trying to build or trying to become. So ,basically an Overarching Goal State:</p><p>1.It is not a single task</p><p>2.It is not a checkpoint</p><p>3.It is a state of becoming.</p><h3>The real art of not giving up</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/0*TvNW1SEnyFee_hyE" /><figcaption>Credit: <a href="https://daringtolivefully.com/">https://daringtolivefully.com/</a></figcaption></figure><p>Not giving up is not about motivation hacks or discipline tricks. It is about the depth of the Goals that you set. Their meaning. Look we have to understand that <strong>Shallow goals collapse under pressure</strong> and <strong>Deep goals</strong> <strong>create endurance.</strong></p><p>Grades will fade, Exams will end and Semesters will pass. Like who cares? Think about the mindset you build. How you think,persist and learn and realize. That stays forever. If you are an Undergraduate just like me and If you are reading this, ask yourself honestly.</p><p>Are you studying to survive the system?</p><p>Or Are you using that system to build yourself and reach your maximum potential?</p><p>I have tried first path and It lead me to burnout. And the other I am trying and I can understand and feel that It leads to resilience.</p><p>And that difference decides whether you quit or keep going.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0b030ba12c9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/linkit-intecs/the-art-of-not-giving-up-why-just-passing-the-exam-is-a-dangerous-goal-d0b030ba12c9">The Art of Not Giving Up: Why “Just Passing the Exam” Is a Dangerous Goal</a> was originally published in <a href="https://medium.com/linkit-intecs">LinkIT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Diamond Problem In Java: Why Java Chose Safety Over Power]]></title>
            <link>https://medium.com/@dinithoshada2003/the-diamond-problem-in-java-why-java-chose-safety-over-power-9ded23d457b2?source=rss-6d9f8fd34009------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ded23d457b2</guid>
            <category><![CDATA[objectorientedprogramming]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Dinith Rathnayaka]]></dc:creator>
            <pubDate>Mon, 29 Dec 2025 18:25:52 GMT</pubDate>
            <atom:updated>2025-12-29T18:25:52.622Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/660/0*7PVn2eyxiApgpP2F.png" /><figcaption>Image From GeeksforGeeks</figcaption></figure><p>Okay At First, multiple inheritance sounds like a really great idea. So, Why should a class inherit from only one parent? <br>Why not reuse behavior from multiple classes and save time?</p><p>Java asked this question early and guess what the answer led to a famous design challenge known as the “Diamond Problem” or in other words we say this “Ambeguity Problem”.</p><p>Understanding this problem explains <strong>why Java looks the way it does today</strong> and why some “limitations” are actually intentional design choices.</p><h3>What Is the Diamond Problem?</h3><p>The <strong>Diamond Problem</strong> occurs when a class inherits from two classes that both inherit from the same parent class.</p><p>Visually, the inheritance structure looks like a diamond:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/238/0*KV4445JXfXt9xqU7" /><figcaption>Inheritance Structure From ResearchGate</figcaption></figure><p><strong>A </strong>is the Base class<br><strong>B</strong> and <strong>C </strong>inherit from <strong>A</strong><br><strong>D </strong>inherit from both <strong>B</strong> and<strong> C</strong></p><p>The problem comes up when B and C override the same method from A.</p><h3>Now, Where does this confusion come from?</h3><p>Let us imagine the following situation in a code,</p><pre>class A {<br>    void show() {<br>        System.out.println(&quot;Class A&quot;);<br>    }<br>}<br><br>class B extends A {<br>    void show() {<br>        System.out.println(&quot;Class B&quot;);<br>    }<br>}<br><br>class C extends A {<br>    void show() {<br>        System.out.println(&quot;Class C&quot;);<br>    }<br>}</pre><p>Now, Imagine a class D that tries to inherit from both B and C</p><pre>// Now,This one is NOT allowed in Java<br>class D extends B, C {<br>}</pre><p>If we call,</p><pre>D obj = new D();<br>obj.show();</pre><p>Which show() method should be called? Is it B.show()? or C.show()? Now, this is where the Diamond problem appears.</p><h3>Why Java Doesn’t Allow Multiple Inheritance of Classes</h3><p>Java <strong>intentionally disallows multiple inheritance of classes</strong> to avoid ambiguity.</p><p>Allowing it would introduce:</p><ul><li>Unclear method resolution</li><li>Hard-to-debug behavior</li><li>Unexpected runtime results</li><li>Increased complexity in large codebases</li></ul><p>Java’s designers chose a strict rule:<br><strong>If something can be ambiguous, it should be disallowed not guessed.</strong></p><p>This decision keeps Java:</p><ul><li>Predictable</li><li>Maintainable</li><li>Easier to reason about</li></ul><h3>Did Java Completely Reject Multiple Inheritance?</h3><p>Not exactly.</p><p>Java <strong>allows multiple inheritance of behavior through interfaces</strong>, but with strict rules that force the developer to resolve conflicts explicitly.</p><p>This is where Java becomes smart not restrictive.</p><h3>The Diamond Problem with Interfaces (Java 8+)</h3><p>With Java 8, interfaces can contain <strong>default</strong> methods.</p><p>This brings back the diamond shape but in a controlled way</p><p>Consider this code:</p><pre>interface A {<br>    default void show() {<br>        System.out.println(&quot;Interface A&quot;);<br>    }<br>}<br><br>interface B extends A {<br>    default void show() {<br>        System.out.println(&quot;Interface B&quot;);<br>    }<br>}<br><br>interface C extends A {<br>    default void show() {<br>        System.out.println(&quot;Interface C&quot;);<br>    }<br>}</pre><p>Now a class implements both B and C.</p><pre>class D implements B, C {<br>    @Override<br>    public void show() {<br>        B.super.show(); // Explicit choice<br>    }<br>}</pre><p>Okay, So What is the key difference here?<br>It is that Java allows multiple inheritance <strong>only when ambiguity is resolved explicitly by the developer</strong>. No guessing and No surprises.</p><h3>Why This Approach Works</h3><p>Java’s interface solution:</p><ul><li>Preserves flexibility</li><li>Avoids ambiguity</li><li>Makes intent explicit</li><li>Keeps code readable</li></ul><p>If there’s a conflict, <strong>the compiler forces you to fix it</strong>.</p><p>This makes Java safer for large-scale applications where silent behavior changes can be disastrous.</p><p>So , This Diamond problem; This is not actually a weakness in Java.By choosing safety, predictability, and clarity over raw power, Java avoids a whole class of bugs before they ever exist.</p><p>Hope You Would Enjoy and Took something from this Lesson !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ded23d457b2" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>