<?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 Sharanya Bharghavi on Medium]]></title>
        <description><![CDATA[Stories by Sharanya Bharghavi on Medium]]></description>
        <link>https://medium.com/@ssharanyab?source=rss-8b5359d5576c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KGGQk9ZFjzFjNl48WpZY2g.jpeg</url>
            <title>Stories by Sharanya Bharghavi on Medium</title>
            <link>https://medium.com/@ssharanyab?source=rss-8b5359d5576c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 14:10:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ssharanyab/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[Building DiyaOnHand: Bringing a 3D Diya to Your Palm Without an AR SDK]]></title>
            <link>https://medium.com/antaeus-ar/building-diyaonhand-bringing-a-3d-diya-to-your-palm-without-an-ar-sdk-1601e22c8bc7?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1601e22c8bc7</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[augmented-reality]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 07:03:03 GMT</pubDate>
            <atom:updated>2026-11-11T14:29:21.574Z</atom:updated>
            <content:encoded><![CDATA[<iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FsTRmnh8TR7s%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DsTRmnh8TR7s&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FsTRmnh8TR7s%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/9b337ea4aa537b8cffcb525db7ba2954/href">https://medium.com/media/9b337ea4aa537b8cffcb525db7ba2954/href</a></iframe><p>Augmented reality experiences often rely on frameworks such as ARCore, ARKit, or Unity. But what happens when you want to build a small AR-like experience from the ground up, using native Android tools and computer vision?</p><p>That question led me to build <strong>DiyaOnHand</strong> — an Android application that detects a user’s hand through the camera and places a 3D brass diya on the palm.</p><p>The goal was simple: make a virtual diya appear as though it is resting on your hand, following its movement in real time.</p><p>No ARCore. No Unity. No AR Foundation.</p><p>Just Kotlin, CameraX, MediaPipe, and Filament.</p><h3>The idea</h3><p>I wanted to explore how far I could get by combining individual technologies instead of relying on a complete AR framework.</p><p>The application needed to:</p><ul><li>Capture live camera frames.</li><li>Detect and track a hand.</li><li>Estimate the palm’s position, size, and orientation.</li><li>Map the detected palm coordinates into a 3D scene.</li><li>Render a 3D diya over the camera feed.</li><li>Keep the object visually stable as the hand moves.</li></ul><p>This sounds straightforward, but connecting a 2D computer vision pipeline to a 3D rendering pipeline introduces some interesting challenges.</p><h3>The technology stack</h3><p>I chose native Android technologies for the implementation.</p><p>ComponentTechnologyResponsibilityApplicationKotlinCore Android implementationCameraCameraXLive camera framesHand trackingMediaPipe Hand LandmarkerHand landmark detection3D renderingFilamentRendering the diya model3D assetGLBDiya model</p><p>One important decision was to keep the camera preview and 3D renderer separate. CameraX handles the live camera feed, while Filament renders the 3D object in a transparent overlay.</p><p>This allowed me to build the experience without introducing a full AR runtime.</p><h3>Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j5wvCj0YwBQ6_-UN2uN5gw.png" /></figure><p>The application follows a pipeline:</p><p><strong>Camera → Hand Detection → Palm Pose Estimation → Coordinate Mapping → 3D Rendering</strong></p><h3>1. Capturing camera frames with CameraX</h3><p>CameraX provides the live camera feed and image analysis frames.</p><p>I used a separate image-analysis pipeline so that hand detection could run without blocking the camera preview.</p><p>Frames are converted into bitmaps, accounting for image rotation, and passed to the hand-tracking component.</p><h3>2. Detecting the hand with MediaPipe</h3><p>MediaPipe Hand Landmarker provides 21 landmarks for a detected hand.</p><p>These landmarks describe important points such as the wrist, finger joints, and fingertips.</p><p>Instead of treating the entire hand as a single detected object, I used these landmarks to estimate the palm’s position and orientation.</p><p>I also explored MediaPipe’s world landmarks for estimating the palm’s 3D orientation.</p><h3>3. Estimating the palm pose</h3><p>The next challenge was translating 21 landmarks into a useful palm pose.</p><p>I used four MCP landmarks — the index, middle, ring, and pinky finger joints — to estimate the palm center.</p><p>The distance between the index and pinky MCP landmarks provides an estimate of palm width.</p><p>For the initial 2D rotation, I used the direction from the wrist to the middle MCP landmark.</p><p>The result is a simplified representation of the palm:</p><ul><li>Center X and Y</li><li>Estimated palm width</li><li>Rotation angle</li></ul><p>This representation is enough to drive the position and scale of the 3D object.</p><h3>4. Mapping 2D coordinates to the 3D scene</h3><p>Hand landmarks are detected in image coordinates, whereas Filament renders objects in a 3D scene.</p><p>I needed a mapping layer to translate the estimated palm pose into the renderer’s coordinate system.</p><p>The mapper converts the normalized palm center into scene coordinates and derives the diya’s scale from the estimated palm width.</p><p>This is an approximation rather than a calibrated physical-world transformation. The objective was to create a convincing visual interaction within the camera view.</p><h3>5. Rendering the diya with Filament</h3><p>For the 3D object, I used a GLB diya model and Filament.</p><p>The renderer loads the model, applies its base transform, and updates its position, scale, and rotation based on the incoming palm transform.</p><p>The interesting part was compositing the rendered object over the live camera feed.</p><p>I configured Filament’s rendering surface to support transparency, allowing the CameraX preview to remain visible underneath.</p><p>This was one of the important implementation details that made the overall experience work.</p><h3>The challenges</h3><p>Getting each individual component working was only part of the problem. The real work was making them behave together.</p><h3>1. Keeping the diya stable</h3><p>Hand landmarks naturally fluctuate between frames. Directly applying every detected position and rotation made the diya appear jittery.</p><p>I introduced exponential moving average smoothing, with separate smoothing factors for position, scale, and rotation.</p><p>This helped reduce visual instability while retaining responsiveness.</p><h3>2. Handling hand detection loss</h3><p>A hand tracker does not necessarily detect a hand in every frame.</p><p>Immediately hiding the diya whenever a frame returned no detection caused it to flicker.</p><p>I added a short detection-loss grace period. This allows the last known transform to remain visible briefly before hiding the object.</p><h3>3. Getting the orientation right</h3><p>The initial orientation was not correct. The diya appeared upside down, so I adjusted the rotation offset.</p><p>I also experimented with MediaPipe world landmarks to improve 3D palm orientation.</p><p>This was a useful reminder that a set of 3D landmarks is not automatically equivalent to a calibrated camera pose. Coordinate systems, axes, and transformations matter.</p><h3>4. Getting transparency right</h3><p>The camera preview and 3D renderer needed to coexist without the renderer covering the camera feed with an opaque background.</p><p>Configuring Filament’s surface and blending behavior correctly was essential to achieving the overlay effect.</p><h3>What I learned</h3><p>This project was a practical exercise in connecting computer vision with real-time graphics.</p><p>A few takeaways stood out:</p><ol><li><strong>Computer vision and rendering are different problems.</strong> Detecting a hand is only the beginning. The output needs to be transformed into a coordinate system that the renderer understands.</li><li><strong>Small sources of instability become visually obvious.</strong> Even minor landmark fluctuations can make a virtual object look disconnected from the hand.</li><li><strong>Coordinate systems matter.</strong> Image coordinates, normalized landmarks, world landmarks, and 3D scene coordinates are not interchangeable.</li><li><strong>A full AR framework is not always necessary for a focused experience.</strong> Individual components can be combined when the requirements are limited and well understood.</li></ol><h3>What’s next?</h3><p>DiyaOnHand is intentionally a small experiment rather than an attempt to build a general-purpose AR framework.</p><p>The current implementation demonstrates live hand detection, palm-based positioning, and 3D object rendering over a camera preview.</p><p>There are still limitations around accurate 3D alignment and physical-world interaction. Solving those would require more work on pose estimation, calibration, and occlusion.</p><p>For now, the objective was to understand the pipeline, build a working experience, and explore what can be achieved with native Android and standalone computer vision and rendering tools.</p><h3>Final thoughts</h3><p>I enjoyed building this because it pushed me beyond the usual mobile application development workflow.</p><p>It brought together Android camera APIs, computer vision, coordinate transformations, 3D mathematics, and real-time rendering in one small project.</p><p><strong>DiyaOnHand is a reminder that interesting AR-like experiences can be built by understanding and combining the underlying technologies — not just by using an AR SDK.</strong></p><p><strong>Tech stack:</strong> Kotlin · CameraX · MediaPipe · Filament · GLB</p><p><strong>Project:</strong> DiyaOnHand<br><strong>Source code:</strong> <a href="https://github.com/ssharanyab/DiyaInHand">ssharanyab/DiyaInHand</a><br><strong>Demo:</strong> <a href="https://youtu.be/sTRmnh8TR7s">https://youtu.be/sTRmnh8TR7s</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1601e22c8bc7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/antaeus-ar/building-diyaonhand-bringing-a-3d-diya-to-your-palm-without-an-ar-sdk-1601e22c8bc7">Building DiyaOnHand: Bringing a 3D Diya to Your Palm Without an AR SDK</a> was originally published in <a href="https://medium.com/antaeus-ar">Antaeus AR</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond HTTPS: What Mobile Engineers Need to Know About Certificate Pinning]]></title>
            <link>https://ssharanyab.medium.com/beyond-https-what-mobile-engineers-need-to-know-about-certificate-pinning-fb168f7b137a?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb168f7b137a</guid>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[devsecops]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[network-security]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 16:41:21 GMT</pubDate>
            <atom:updated>2026-10-29T16:41:21.072Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Certificate pinning for Flutter, Android, and iOS developers — what it protects, where it belongs, and how to ship it safely.</em></h4><p>Imagine you are reviewing a mobile application’s security report. One finding stands out:</p><blockquote><em>“No TLS/SSL certificate pinning is implemented.”</em></blockquote><p>You open the application, sign in, and navigate through a few screens. The app communicates with its backend over HTTPS, so the traffic should be encrypted.</p><p>Then you configure an intercepting proxy such as Burp Suite, install its custom certificate authority (CA) certificate on the test device, and repeat the same actions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UhljFvaxsL1M8s-40l2eLA.png" /></figure><p>Suddenly, you can read the application’s API requests and responses.</p><p>You see request headers, JSON payloads, and perhaps session-related data. The traffic that looked opaque a moment ago is now readable.</p><p>Your first reaction might be: “Wait, isn’t HTTPS supposed to prevent exactly this?”</p><p>It is. But there is an important distinction: <strong>HTTPS encrypts traffic, while certificate validation determines whom your app is willing to trust.</strong></p><p>HTTPS has not necessarily been broken. Instead, the device has been configured to trust an additional certificate authority, and the app has accepted a certificate presented through that authority.</p><p>The proxy can now sit between the app and its intended server, decrypting one connection and establishing another.</p><p>This is the gap certificate pinning is designed to narrow.</p><p>Before adding it, though, you need to understand what your app is actually trusting.</p><h4>HTTPS in plain English</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hquz5fQ1c5uypt19KTcMXA.png" /></figure><p>When your mobile app connects to https://api.example.com, the server presents a TLS certificate. The certificate contains information about the server&#39;s identity and its public key.</p><p>The app doesn’t normally know that particular certificate in advance. Instead, the platform validates a chain of certificates.</p><p>A simplified chain looks like this:</p><p><strong>Leaf certificate → Intermediate CA → Root CA</strong></p><ul><li><strong>Leaf certificate:</strong> The certificate presented for the server’s hostname.</li><li><strong>Intermediate certificate:</strong> Connects the leaf certificate to a trusted authority.</li><li><strong>Root certificate:</strong> A trust anchor that the client already trusts.</li></ul><p>Real certificate chains can contain multiple intermediates, and the root is often omitted from the certificates sent by the server because the client already has it.</p><p>During a normal TLS connection, the client checks several things, including whether the certificate chain leads to a trusted authority, whether the hostname matches, whether the certificate is valid for the intended use, and whether relevant validity checks pass.</p><p>A simplified way to describe the default trust decision is:</p><p><em>“Is this server presenting a valid certificate for this hostname, signed through a certificate authority I trust?”</em></p><p>Notice what that question doesn’t ask:</p><p><em>“Is this the particular server key that my application expects?”</em></p><p>That distinction matters.</p><h4>How a custom CA changes the situation</h4><p>Suppose an intercepting proxy generates a certificate for api.example.com and signs it using its own CA certificate.</p><p>If the device trusts that CA and the app accepts certificates issued through it, the certificate may pass the app’s normal validation checks.</p><p>The proxy can then establish separate TLS connections with the app and the real server.</p><p>The attacker doesn’t need to decrypt the original TLS session directly. The proxy participates in two separate sessions and can inspect the traffic between them.</p><p>User-installed CAs can be legitimate. Organizations may install them through mobile device management (MDM), and developers may install them for debugging. A malicious actor with sufficient device access could also introduce a trusted CA in some circumstances.</p><p>The precise behavior depends on the platform, operating system version, application configuration, and HTTP stack. Some configurations already reject user-installed CAs for particular apps.</p><p>But the general lesson remains: trusting a certificate authority is broader than trusting one specific server key.</p><h4>What certificate pinning actually means</h4><p>Certificate pinning adds an additional trust requirement.</p><p>Instead of relying only on the system’s certificate authorities, your application maintains an allowlist of expected certificate or public-key fingerprints.</p><p>For public-key pinning, the value commonly used is the SHA-256 hash of the certificate’s <strong>Subject Public Key Info (SPKI)</strong> structure.</p><p>In plain English:</p><ol><li>The server presents its leaf certificate.</li><li>The client performs normal TLS certificate and hostname validation.</li><li>The client extracts the leaf certificate’s public-key information.</li><li>The client calculates its SHA-256 fingerprint.</li><li>The client compares that fingerprint against an approved list.</li><li>The connection is accepted only if the required checks pass.</li></ol><p>If the proxy presents a certificate containing a different public key, the pin check fails, even if the certificate chains to a CA the device trusts.</p><blockquote>A pin is not a secret</blockquote><p>This is worth emphasizing because it is a common source of confusion.</p><p>An SPKI pin is a fingerprint, not a password. It can be visible in your application binary, your source repository, or your security documentation.</p><p>There is no need to hide it as if it were a private credential.</p><p>The server’s <strong>private key</strong> is the sensitive material. It must remain under appropriate control on the server side. Never request or embed it in a mobile app.</p><h4>Leaf pin or intermediate pin?</h4><p>You generally have two choices.</p><p><strong>Leaf public-key pinning</strong> ties the app to the key in the server’s leaf certificate. This is more specific: a proxy using a different key will not match the pin.</p><p>However, a certificate renewal that introduces a new key can break the app unless the new key has already been authorized.</p><p><strong>Intermediate public-key pinning</strong> allows a broader set of leaf certificates issued under the pinned intermediate key. This can make routine leaf renewals easier, provided the issuing arrangement remains consistent.</p><p>The trade-off is that an intermediate pin trusts a wider set of possible leaf certificates. It is not equivalent to pinning the exact server key.</p><p>Choose the scope based on your threat model and infrastructure’s ability to manage keys safely.</p><h4>Why backup pins matter</h4><p>Imagine the current server key is pinned in your mobile app. Your infrastructure team rotates that key, and the new certificate contains a different public key.</p><p>The backend works perfectly. The certificate is valid. The hostname matches.</p><p>Your released app still rejects the connection.</p><p>For affected users, that can look like an ordinary network outage.</p><p>The solution is to ship a backup pin before the rotation. Ideally, your app contains both the current leaf SPKI pin and the next approved leaf SPKI pin. The infrastructure team then rotates to a key the installed app already recognizes.</p><p>A backup pin should represent a real, approved future key — not an arbitrary value added merely to make the list longer.</p><h4>Flutter, Android, and iOS: where pinning belongs</h4><p>One of the easiest ways to implement pinning incorrectly is to configure the right thing in the wrong place.</p><p>On Android, for example, network_security_config can define trust and pinning policies for supported platform networking APIs. This is useful, but it does not automatically mean every networking implementation in a Flutter application follows that policy.</p><p>Flutter apps may make requests through different stacks, including:</p><ul><li>Dart’s dart:io HttpClient.</li><li>HTTP clients built on top of dart:io.</li><li>A client using Dio and its configured adapter.</li><li>Native Android or iOS networking code invoked through plugins or platform channels.</li></ul><p>The actual behavior depends on the selected client, adapter, platform, and configuration.</p><p>Dio is an HTTP client library, not a guarantee that a particular native trust policy is being enforced. Likewise, adding a platform configuration file doesn’t prove that requests made through every Dart or native networking path are pinned.</p><p><strong>Pin the connection at the layer that actually sends the request.</strong></p><p>For Flutter, that usually means inspecting the HTTP client and adapter used by the application. For native Android and iOS code, identify the networking APIs and their trust-evaluation behavior.</p><p>If the app has several clients, audit them all. Authentication, analytics, file uploads, and background jobs may use different paths.</p><h4>Three anti-patterns to remove</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n9RN--GghkMJH8blVG2vCA.png" /></figure><p><strong>1. Accepting every bad certificate</strong></p><p>A callback that accepts a certificate regardless of its validity effectively disables an important TLS safeguard. A typical example is an unconditional badCertificateCallback that returns true.</p><p>Do not use this as a shortcut to make development proxies work. A certificate-validation bypass is not pinning.</p><p><strong>2. Leaving cleartext traffic enabled</strong></p><p>If production builds permit unencrypted HTTP unnecessarily, pinning HTTPS connections won’t protect those HTTP requests.</p><p>Disable cleartext traffic by default and document any legacy exception that genuinely requires it.</p><p><strong>3. Shipping debug proxy trust in production</strong></p><p>A debug configuration may intentionally trust a development proxy or relax validation. That’s reasonable in a controlled development environment.</p><p>It becomes a security problem when the same behavior is enabled by default in store builds.</p><p>Debug-only behavior must be separated from production behavior, and release configurations should fail closed.</p><h4>Getting SPKI pins without a private key</h4><p>You do not need the server’s private key to calculate its SPKI pin. The public key is included in the server’s certificate.</p><p>The following example uses api.example.com as a placeholder. Replace it with your actual hostname.</p><p>First, inspect the certificate chain presented by the server:</p><p>bash</p><pre>openssl s_client \<br>  -connect api.example.com:443 \<br>  -servername api.example.com \<br>  -showcerts \<br>  &lt;/dev/null</pre><p>The output includes certificates in PEM format. Save the leaf certificate as leaf.pem and the relevant intermediate certificate as intermediate.pem.</p><p>Be careful when selecting the intermediate: the server may provide more than one certificate, and the exact chain depends on the deployment.</p><p>Now calculate the leaf SPKI pin:</p><p>bash</p><pre>openssl x509 -in leaf.pem -pubkey -noout |<br>  openssl pkey -pubin -outform DER |<br>  openssl dgst -sha256 -binary |<br>  openssl base64 -A</pre><p>Calculate the intermediate SPKI pin using the same pipeline:</p><p>bash</p><pre>openssl x509 -in intermediate.pem -pubkey -noout |<br>  openssl pkey -pubin -outform DER |<br>  openssl dgst -sha256 -binary |<br>  openssl base64 -A</pre><p>The resulting Base64 string is commonly represented in pin configurations with the prefix sha256/.</p><p>For example, the format is:</p><p>text</p><pre>sha256/BASE64_ENCODED_SHA256_DIGEST</pre><p>That is a format illustration, not a usable pin.</p><p>Do not hash the entire certificate when you intend to implement SPKI pinning. Hashing the certificate’s DER representation produces a different fingerprint. Your implementation and your OpenSSL calculation must use the same input bytes.</p><p>Also, retrieving a certificate from a live host tells you what that endpoint presents at the time of inspection. It does not, by itself, establish which keys are approved for future use.</p><h4>Get confirmation from infrastructure</h4><p>Before shipping, ask your infrastructure or DevOps team to confirm:</p><ul><li>The currently approved leaf SPKI pin.</li><li>The backup or next leaf SPKI pin.</li><li>The intended key-rotation and certificate-renewal process.</li><li>How much notice mobile engineers will receive before a key or CA change.</li></ul><p>Do not request the private key.</p><p>Keep the approved pins in the application binary or another appropriately controlled build-time configuration that becomes part of the shipped binary. Avoid fetching the authoritative pin list from Remote Config or a mutable API at runtime: an attacker able to change that configuration could potentially change what the app trusts.</p><h3>A generic implementation sketch</h3><p>You don’t need to begin with a large security framework. Start with a clear, testable policy.</p><h4>Step 1: Define which hosts are pinned</h4><p>Create an explicit allowlist of production API hostnames and their approved SPKI pins.</p><p>Do not automatically apply a production pin to every hostname the app might contact. Third-party services, content delivery networks, and unrelated endpoints may have different certificate lifecycles.</p><p>Match hostnames carefully. A pin for one production API should not accidentally become a policy for arbitrary destinations.</p><h4>Step 2: Enforce pins in the shared HTTP client</h4><p>Centralize networking where practical. In the shared client, perform ordinary TLS validation and compare the leaf SPKI fingerprint against the approved allowlist before allowing the connection.</p><p>The required policy is:</p><ul><li>The certificate chain and hostname must validate normally.</li><li>The leaf SPKI must match an approved pin for that host.</li><li>An unrecognized key must cause the connection to fail.</li></ul><p>Do not replace normal TLS validation with a pin comparison alone. Pinning is an additional constraint, not a substitute for certificate and hostname validation.</p><p>For Flutter, verify the behavior of the exact client and adapter in use. If you extract SPKI from certificate DER yourself, you will generally need light ASN.1 parsing to isolate the Subject Public Key Info structure correctly. Hashing the wrong DER bytes will produce a different fingerprint from OpenSSL.</p><p>Prefer a well-maintained implementation that performs this extraction correctly, or test your parser against known certificate fixtures and independently generated OpenSSL fingerprints.</p><h4>Step 3: Keep debugging explicit</h4><p>Developers still need to inspect traffic during development.</p><p>A reasonable policy is to allow interception only when an explicit debug-proxy mode is enabled in a non-production build, with the intended proxy trust or address configured.</p><p>That mode should be off by default. Release builds should not expose a general-purpose certificate-validation bypass or silently accept arbitrary proxy certificates.</p><p>A debug proxy setting is a development convenience, not a production security feature.</p><h4>Step 4: Consider OS-level pinning as defense-in-depth</h4><p>For networking paths that support it, an operating-system-level pin set can provide another layer of enforcement.</p><p>On Android, this may include network_security_config. On iOS, trust evaluation can be implemented through the relevant native networking APIs.</p><p>But don’t count two configurations as two independent protections until you’ve verified that both are actually applied to the connections you care about. If the primary HTTP stack bypasses the platform’s pinning policy, the second layer may not protect that request.</p><h4>Step 5: Disable cleartext by default</h4><p>Production builds should use HTTPS for network traffic, with cleartext HTTP disabled unless a documented legacy requirement makes an exception necessary.</p><p>Review platform configuration, Dart client configuration, native plugins, and any custom networking code. Security settings are only useful when the real request path enforces them.</p><h4>How to test pinning before release</h4><p>A successful build doesn’t prove pinning works. Test the behavior from the perspective of the connection.</p><p>Test scenarioExpected resultProduction build on a normal networkPinned API requests succeed.Production build with a custom CA and intercepting proxyRequests to pinned hosts fail when the proxy presents an unapproved key.Non-production build with explicitly enabled debug proxy modeInterception works as intended for development.Non-production build with pinning disabled by policyRequests follow the documented development trust configuration.</p><p>For the custom-CA test, confirm that the app is actually routing the request through the proxy. Otherwise, a failed interception could be caused by proxy configuration rather than pinning.</p><p>Likewise, if the request fails, inspect the reason. A hostname mismatch, expired certificate, DNS issue, or ordinary connectivity problem is not proof that the pin check worked.</p><p>Test every relevant networking path, including background requests and uploads. Verify the release artifact rather than assuming debug and release builds behave identically.</p><p>Finally, exercise the rotation process in a non-production environment. Confirm that the app accepts the intended next key and rejects an unrelated key.</p><h4>What pinning does not solve</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-C_0I9LX24G326Odqf5THw.png" /></figure><p>Certificate pinning is useful, but it is not a universal defense.</p><p>A determined attacker who controls a device may be able to decompile the app, patch its validation logic, instrument it with a tool such as Frida, or modify its runtime behavior to bypass client-side pinning.</p><p>Rooted or jailbroken devices can increase the attacker’s options, but pinning is not a reliable way to establish that a device is uncompromised.</p><p>Pinning therefore helps protect <strong>official, unmodified app builds against certain custom-CA man-in-the-middle attacks</strong>. It does not guarantee protection against a modified client, and it is not DRM.</p><p>There is also an operational risk: a poorly managed key rotation can disconnect legitimate users from your backend. An aggressive pinning policy without a reliable backup-key process can turn a routine infrastructure change into a production incident.</p><p>Treat pinning as one layer in a broader security design. Continue to use proper TLS validation, sound server-side authorization, secure credential handling, and appropriate monitoring.</p><h4>What to ask Infra for</h4><ul><li><strong>Current pins:</strong> Which leaf SPKI pins are approved for each production API hostname?</li><li><strong>Backup/next leaf SPKI:</strong> What is the approved backup key, and can its pin be included before rotation?</li><li><strong>Change notice:</strong> How will mobile engineers be notified before a certificate, public key, issuing CA, or TLS configuration changes?</li></ul><h4>The shipping checklist</h4><p>Before you close that security finding, check these five items.</p><ul><li><strong>Trust is understood:</strong> Normal TLS validation remains enabled, and the app enforces an approved SPKI pin for every intended production host.</li><li><strong>The real HTTP stack is covered:</strong> Flutter clients, adapters, native code, plugins, and background requests have been reviewed and tested.</li><li><strong>Rotation is planned:</strong> Current and backup pins are shipped, and infrastructure has a documented process for changing keys without breaking existing clients.</li><li><strong>Debug exceptions are controlled:</strong> Proxy interception is explicit and restricted to appropriate non-production builds; release builds contain no trust-all bypass, and cleartext is disabled by default.</li><li><strong>Negative tests pass:</strong> Normal requests succeed, an unapproved custom-CA interception fails for pinned hosts, and the intended debug workflow works only when explicitly enabled.</li></ul><p>The important shift is to stop thinking of HTTPS as a complete answer to every interception scenario.</p><p>HTTPS protects the connection using TLS. Certificate pinning narrows which server keys your app is willing to accept. When you implement it in the actual networking path, manage backup keys, and test both successful and failed connections, you can address the security finding without turning the next certificate rotation into an outage.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb168f7b137a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Route Finding: Building an Adaptive AI Commute Agent for Bengaluru]]></title>
            <link>https://ssharanyab.medium.com/beyond-route-finding-building-an-adaptive-ai-commute-agent-for-bengaluru-107b203b98c3?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/107b203b98c3</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[gemini]]></category>
            <category><![CDATA[google-cloud]]></category>
            <category><![CDATA[google-adk]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 17:47:46 GMT</pubDate>
            <atom:updated>2026-09-10T17:47:46.357Z</atom:updated>
            <content:encoded><![CDATA[<h4>How I built an adaptive multimodal mobility agent for Bengaluru using Google ADK, Gemini, deterministic graph search, historical mobility data, and a multi-objective decision engine.</h4><p>Urban mobility is usually treated as a route-finding problem.</p><p>You enter a source and destination, choose a preference, and receive a route. But real commuting is rarely that simple.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*0_FwTgikJc5FeZLb" /></figure><p>Urban mobility is usually treated as a route-finding problem.</p><p>You enter a source and destination, choose a preference, and receive a route.</p><p>But real commuting is rarely that simple.</p><p>Sometimes the fastest option isn’t the cheapest. Sometimes a slightly longer Metro journey is preferable to sitting in traffic. Sometimes you don’t want to use a cab or an auto at all. And sometimes the journey that was optimal five minutes ago is no longer the right choice.</p><p>That led me to a different question:</p><blockquote><strong><em>What if an AI system didn’t just find a route, but decided how you should travel?</em></strong></blockquote><p>That is the idea behind <strong>Commute Agent</strong>, with <strong>GoWise</strong> as its user-facing application</p><p>Github Link: <a href="https://github.com/ssharanyab/commute-agent">https://github.com/ssharanyab/commute-agent</a></p><h3>From Routes to Mobility Strategies</h3><p>GoWise is designed as a personalized multimodal mobility planner for Bengaluru.</p><p>Instead of treating a journey as a single route, the system can compose combinations of:</p><ul><li>🚶 Walking</li><li>🚌 BMTC buses</li><li>🚇 Metro</li><li>🛺 Auto-rickshaws</li><li>🚕 Cabs</li></ul><p>A commute can therefore become something like:</p><p><strong>Walk → Metro → Walk</strong></p><p>or:</p><p><strong>Walk → Bus → Walk</strong></p><p>or, when appropriate:</p><p><strong>Auto → Metro → Walk</strong></p><p>The important part is that these combinations aren’t hardcoded.</p><p>The system searches the mobility network and discovers feasible journeys algorithmically.</p><h3>The Architecture</h3><p>The system is built around a deliberate separation between <strong>AI orchestration</strong> and <strong>deterministic decision-making</strong>.</p><p>At a high level:</p><pre>Flutter / GoWise<br>       ↓<br>    FastAPI<br>       ↓<br>Google ADK Orchestrator<br>       ↓<br>  Journey Builder<br>       ↓<br>Live + Historical Enrichment<br>       ↓<br>  Decision Engine<br>       ↓<br>Gemini Explanation</pre><p>The Flutter application provides the commuter experience, while the backend coordinates the actual mobility planning workflow.</p><p>Google ADK acts as the orchestration layer.</p><p>But there is an important architectural decision here:</p><blockquote><strong><em>The LLM does not decide the route.</em></strong></blockquote><h3>Deterministic Journey Discovery</h3><p>The Journey Builder operates over a mobility network containing transit stops, stations, connections and walking/access relationships.</p><p>It uses deterministic graph search to discover feasible multimodal journeys.</p><p>This means the system isn’t asking Gemini:</p><blockquote><em>“What’s the best way to get from Majestic to Indiranagar?”</em></blockquote><p>Instead, it first generates candidate journeys algorithmically.</p><p>Those candidates can contain different combinations of mobility modes and transfers.</p><p>This makes the planning process much more predictable and auditable than relying on an LLM to directly construct a route.</p><h3>Turning Candidates Into Decisions</h3><p>Finding possible journeys is only half the problem.</p><p>The system then needs to decide which journey is actually best <strong>for this commuter</strong>.</p><p>GoWise uses a deterministic multi-objective decision engine.</p><p>Different commuters can prioritize different things:</p><ul><li>Fastest</li><li>Cheapest</li><li>Low walking</li><li>Reliable</li><li>Low traffic</li><li>Balanced</li></ul><p>The engine evaluates candidate journeys against these preferences while also enforcing hard constraints.</p><p>For example:</p><blockquote><strong><em>Avoid cab + Avoid auto</em></strong></blockquote><p>shouldn’t simply make the system dislike those modes.</p><p>They become constraints that eliminate journeys containing those modes.</p><p>The remaining feasible journeys are then evaluated and ranked.</p><p>This separation between <strong>constraints</strong> and <strong>preferences</strong> was an important design decision.</p><h3>Real Bengaluru Mobility Data</h3><p>The system is grounded in actual Bengaluru mobility data rather than being a purely conceptual demo.</p><p>The mobility network incorporates:</p><ul><li>BMTC GTFS data</li><li>BMRCL Metro network data</li><li>Government-sourced auto fare information</li><li>Government-sourced policy information</li><li>Historical mobility data from Uber Movement</li></ul><p>The system also maintains provenance and versioned network snapshots so that a failed data refresh doesn’t silently replace a working dataset.</p><h3>Historical Mobility Intelligence</h3><p>Historical mobility data is used to derive route-context signals such as:</p><ul><li>Expected travel time</li><li>Travel-time variability</li><li>Reliability</li><li>Coverage</li><li>Deviation from expected conditions</li></ul><p>The historical model is intentionally positioned as a <strong>route-context estimator</strong>, rather than claiming to predict arbitrary future traffic.</p><p>That distinction matters.</p><p>Good AI systems should be honest about what their models actually know.</p><h3>Live Routing and Context</h3><p>Historical information isn’t enough for a commute happening right now.</p><p>GoWise can enrich road-based journey segments using Google Maps routing information, providing current routing and traffic-aware travel estimates.</p><p>This creates a useful separation:</p><p><strong>Historical data → what is normally expected</strong></p><p><strong>Live routing → what conditions look like now</strong></p><p>The decision engine can then reason over the resulting journey candidates.</p><h3>Where Gemini Fits</h3><p>Gemini is used through Google ADK as the <strong>explanation layer</strong>.</p><p>Once the deterministic system has selected a journey, Gemini receives grounded information about that decision and generates a commuter-friendly explanation.</p><p>This prevents the language model from inventing route IDs, scores, costs or unsupported reasoning.</p><p>In other words:</p><blockquote><strong><em>The system makes the decision. Gemini explains the decision.</em></strong></blockquote><p>That separation was one of the most important principles in the architecture.</p><h3>Making the System Personal</h3><p>Consider the same journey:</p><p><strong>Majestic → Indiranagar</strong></p><p>One commuter might say:</p><blockquote><em>“I need the cheapest option.”</em></blockquote><p>Another might say:</p><blockquote><em>“I don’t want to walk much.”</em></blockquote><p>Another:</p><blockquote><em>“Avoid cabs and autos.”</em></blockquote><p>The underlying mobility network doesn’t have to change.</p><p>What changes is the <strong>decision context</strong>.</p><p>GoWise therefore treats personalization as part of the planning process rather than simply changing the UI.</p><h3>GoWise vs Traditional Navigation</h3><p>GoWise isn’t trying to replace Google Maps.</p><p>Google Maps is excellent at navigating a selected journey.</p><p>The problem GoWise focuses on is slightly different:</p><blockquote><strong><em>Which mobility strategy should I choose in the first place?</em></strong></blockquote><p>A simple way to describe the distinction is:</p><p><strong>Google Maps → Navigate a route</strong></p><p><strong>GoWise → Decide and compose how you should travel</strong></p><p>GoWise can then hand the selected journey off to Google Maps for navigation.</p><h3>Building the Adaptive Layer</h3><p>The system also supports adaptive replanning.</p><p>A commute isn’t static.</p><p>If conditions change significantly, the original recommendation may no longer be optimal.</p><p>The adaptive layer can take the existing journey context, update the relevant conditions, reevaluate the candidate journeys and determine whether a different mobility strategy should now be preferred.</p><p>This turns the system from a one-time route planner into something closer to a <strong>mobility decision agent</strong>.</p><h3>What I Learned</h3><p>The biggest lesson from building Commute Agent was that adding an LLM doesn’t automatically make a system an AI agent.</p><p>The difficult parts were often deterministic engineering problems:</p><ul><li>Building a useful mobility graph</li><li>Discovering genuinely diverse multimodal journeys</li><li>Handling first and last mile connections</li><li>Preserving transit identities across planning stages</li><li>Managing incomplete data</li><li>Separating unknown values from zero values</li><li>Designing meaningful multi-objective scoring</li><li>Enforcing user constraints correctly</li><li>Keeping explanations grounded in actual decisions</li></ul><p>The LLM is only one component.</p><p>The intelligence comes from how all these components work together.</p><h3>What’s Next</h3><p>There is still plenty of room to evolve GoWise.</p><p>Future versions could incorporate richer real-time transit information, more precise walking networks, additional mobility providers, stronger temporal planning, learned personalization and larger-scale mobility datasets.</p><p>The longer-term vision is not simply to build a better route planner.</p><p>It is to build a system that understands:</p><p><strong>the commuter, the mobility network, the current context, and the trade-offs between different ways of travelling.</strong></p><h3>Final Thought</h3><p>We have become very good at asking:</p><blockquote><strong><em>“What is the fastest route?”</em></strong></blockquote><p>But that isn’t always the question a commuter actually wants answered.</p><p>Sometimes the better question is:</p><blockquote><strong><em>“Given who I am, what I care about, and what is happening right now — how should I travel?”</em></strong></blockquote><p>That’s the problem GoWise is trying to solve.</p><p><strong>GoWise — your commute, intelligently composed.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=107b203b98c3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Python I Learned for Teaching Machines to Learn]]></title>
            <link>https://ssharanyab.medium.com/the-python-i-learned-for-teaching-machines-to-learn-7ba19aa862b7?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ba19aa862b7</guid>
            <category><![CDATA[matplotlib]]></category>
            <category><![CDATA[numpy]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[python3]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Sun, 31 May 2026 12:38:26 GMT</pubDate>
            <atom:updated>2026-05-31T12:38:26.600Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why file systems, NumPy, and data visualization mattered more than I expected on my journey into Machine Learning</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1021/1*vfoE6iIbH-toyZ15pgdCKA.png" /></figure><p>A little late to learning Machine learning... but I guess better late than never!</p><p>When I decided to transition into Machine Learning, I imagined myself spending most of my time building models, training neural networks, and experimenting with computer vision systems.</p><p>Instead, I spent days learning Python fundamentals, file handling, NumPy arrays, and plotting graphs.</p><p>At first, it felt like I was moving away from Machine Learning.</p><p>Later, I realized I was building the foundation that almost every ML system depends on.</p><p>Alongside my learning journey, I’m documenting everything publicly in a GitHub repository containing notebooks, exercises, interview questions, examples, and notes:</p><p>🔗 GitHub Repository: <a href="https://github.com/ssharanyab/python-for-machine-learning">python-for-machine-learning</a></p><p>The goal isn’t to create a course.</p><p>It’s simply a structured place where I can learn, revisit concepts, and build stronger foundations for Machine Learning, Computer Vision, and perception-driven systems.</p><h3>Why I Started Learning Machine Learning</h3><p>For most of my career, I’ve worked on mobile applications, real-time systems, connected hardware, and interactive experiences.</p><p>Over time, I became increasingly interested in something deeper:</p><p>How systems perceive the world.</p><p>Not just how applications display information.</p><p>But how machines understand images, detect patterns, make predictions, and interact with uncertainty.</p><p>That curiosity naturally pushed me toward:</p><ul><li>Machine Learning</li><li>Computer Vision</li><li>Perception Systems</li><li>Robotics-adjacent software</li></ul><p>The problem was that every roadmap seemed overwhelming.</p><p>People were talking about:</p><ul><li>PyTorch</li><li>Transformers</li><li>CNNs</li><li>Diffusion Models</li><li>LLMs</li></ul><p>Meanwhile, I still hadn’t fully understood the foundations those tools rely on.</p><p>So I stepped back.</p><p>Instead of rushing into models, I focused on the Python ecosystem that powers modern Machine Learning.</p><h3>The Skills Behind Machine Learning</h3><p>One thing surprised me immediately.</p><p>Machine Learning isn’t just about models.</p><p>Before training anything useful, you need to understand:</p><ul><li>How data is stored</li><li>How datasets are loaded</li><li>How numerical computations work</li><li>How arrays are manipulated efficiently</li><li>How to visualize patterns in data</li><li>How ML libraries are structured</li></ul><p>That’s what led me toward learning:</p><ul><li>Python Fundamentals</li><li>File Systems</li><li>NumPy</li><li>Matplotlib</li></ul><p>What looked like beginner topics were actually the building blocks behind almost every Machine Learning workflow.</p><h3>Setting Up Python</h3><p>The first step was creating an environment where experimentation felt easy.</p><p>I installed:</p><ul><li>Python 3</li><li>Visual Studio Code</li><li>Jupyter Notebook</li></ul><p>Jupyter immediately changed how I learned.</p><p>Instead of writing large scripts, I could:</p><ul><li>Execute code step-by-step</li><li>Visualize outputs instantly</li><li>Mix explanations with code</li><li>Experiment without breaking everything</li></ul><p>For Machine Learning, that workflow is incredibly powerful because exploration becomes part of the learning process.</p><h3>Python Fundamentals Matter More Than I Expected</h3><p>Coming from software engineering, I initially underestimated this step.</p><p>I thought:</p><blockquote><em>“</em>I already know programming. Let’s move on.”</blockquote><p>That would’ve been a mistake.</p><p>Machine Learning libraries are built around Python abstractions.</p><p>Understanding the language properly makes everything later feel easier.</p><p>Some concepts I revisited included:</p><h3>Variables and Data Types</h3><pre>age = 25<br>name = &quot;Sharanya&quot;<br>is_learning_ml = True</pre><p>Simple concepts, but they become important when handling datasets, labels, predictions, and configurations.</p><h3>Lists and Dictionaries</h3><pre>students = [&quot;Alice&quot;, &quot;Bob&quot;, &quot;Charlie&quot;]</pre><pre>scores = {<br>    &quot;Alice&quot;: 90,<br>    &quot;Bob&quot;: 85<br>}</pre><p>Most data eventually starts looking like some combination of lists, dictionaries, arrays, or tables.</p><h3>Functions</h3><pre>def square(number):<br>    return number * number</pre><p>Functions become essential when preprocessing datasets or building reusable ML pipelines.</p><h3>List Comprehensions</h3><pre>numbers = [1, 2, 3, 4]</pre><pre>squared = [n * n for n in numbers]</pre><p>This style appears everywhere in data processing code.</p><h3>Classes</h3><pre>class Student:<br>    def __init__(self, name):<br>        self.name = name</pre><p>Later, many ML frameworks expose models, datasets, and transforms through classes.</p><p>Understanding object-oriented programming makes those APIs feel much less intimidating.</p><h3>Learning to Work With Files</h3><p>This was the first time Machine Learning started feeling real.</p><p>Because real-world ML starts with data.</p><p>And data usually lives in files.</p><p>I learned how to:</p><ul><li>Read files</li><li>Write files</li><li>Work with directories</li><li>Load CSVs</li><li>Handle JSON data</li></ul><p>Example:</p><pre>from pathlib import Path</pre><pre>dataset = Path(&quot;data.csv&quot;)</pre><pre>print(dataset.exists())</pre><p>At first glance, this doesn’t feel related to AI.</p><p>But every Machine Learning project eventually begins by loading data from somewhere.</p><p>Images.</p><p>Videos.</p><p>Sensor streams.</p><p>CSV files.</p><p>Annotations.</p><p>Understanding file systems became much more important than I expected.</p><h3>NumPy Changed How I Think About Data</h3><p>This was probably the biggest turning point.</p><p>NumPy introduced me to the idea that Machine Learning is fundamentally numerical.</p><p>Instead of thinking about individual values, you start thinking about vectors, matrices, and operations applied across entire datasets.</p><p>Example:</p><pre>import numpy as np</pre><pre>arr = np.array([1, 2, 3, 4])</pre><pre>print(arr * 2)</pre><p>Output:</p><pre>[2 4 6 8]</pre><p>A tiny example.</p><p>But it introduces a huge idea:</p><p>Operations can happen across entire collections of data at once.</p><h3>Broadcasting</h3><p>One concept that felt almost magical was broadcasting.</p><pre>arr + 10</pre><p>Instead of looping manually, NumPy applies operations efficiently across the array.</p><p>This idea appears everywhere in Machine Learning.</p><p>Feature scaling.</p><p>Normalization.</p><p>Image processing.</p><p>Tensor operations.</p><p>Neural networks.</p><p>The more I learned, the more I realized that many modern ML frameworks are built on ideas NumPy teaches first.</p><h3>Data Visualization Made Everything Easier</h3><p>Machine Learning isn’t just about making predictions.</p><p>It’s also about understanding data.</p><p>That’s where Matplotlib became useful.</p><p>Example:</p><pre>import matplotlib.pyplot as plt</pre><pre>x = [1, 2, 3, 4]<br>y = [2, 4, 6, 8]</pre><pre>plt.plot(x, y)<br>plt.show()</pre><p>For the first time, data stopped looking like rows and columns.</p><p>Patterns became visible.</p><p>Relationships became visible.</p><p>Problems became visible.</p><p>Some visualizations I learned:</p><ul><li>Line Plots</li><li>Scatter Plots</li><li>Histograms</li><li>Bar Charts</li></ul><p>Good visualizations often reveal issues long before model training begins.</p><h3>What Surprised Me Most</h3><p>When people talk about Machine Learning online, the conversation usually revolves around:</p><ul><li>LLMs</li><li>Neural Networks</li><li>Computer Vision Models</li><li>State-of-the-art Research</li></ul><p>What gets discussed far less is the foundation underneath all of it.</p><p>The reality is that before building intelligent systems, you spend a lot of time learning how to:</p><ul><li>Work with data</li><li>Manipulate arrays</li><li>Visualize information</li><li>Load datasets</li><li>Debug code</li><li>Understand numerical computations</li></ul><p>And honestly, that makes sense.</p><p>Machine Learning isn’t magic.</p><p>It’s structured problem-solving powered by data.</p><h3>The Foundation Before the Models</h3><p>The biggest lesson from this stage of my journey is simple:</p><p>Learning Python wasn’t a detour from Machine Learning.</p><p>It was the foundation.</p><p>The concepts that seemed basic at first — file handling, arrays, plotting, data structures — keep appearing everywhere as I explore Machine Learning and Computer Vision.</p><p>That’s exactly why I’m documenting everything publicly.</p><p>Not because these topics are flashy.</p><p>But because they’re the layers that make everything else possible.</p><p>If you’re starting a similar transition into Machine Learning, AI, or Computer Vision, don’t rush toward the most advanced models.</p><p>The foundations compound.</p><p>And in many cases, they matter more than people realize.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ba19aa862b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Real-World AI Still Depends on Perception]]></title>
            <link>https://ssharanyab.medium.com/why-real-world-ai-still-depends-on-perception-2d5cf1669650?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d5cf1669650</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[perception]]></category>
            <category><![CDATA[computer-vision]]></category>
            <category><![CDATA[robotics]]></category>
            <category><![CDATA[generative-ai-use-cases]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Sun, 24 May 2026 08:51:38 GMT</pubDate>
            <atom:updated>2026-05-24T08:51:38.210Z</atom:updated>
            <content:encoded><![CDATA[<h4>Understanding why The Future of AI Is Not Just LLMs</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/998/1*3j3MHGalXtqExPJdQ27y3w.png" /></figure><p>A few years ago, most AI conversations were happening inside research labs.</p><p>Today, everyone talks about AI.</p><p>You open LinkedIn and see terms like Generative AI, AI agents, RAG, LangChain, MCP etc., and honestly, the excitement is justified.</p><p>Large language models changed the way we interact with machines almost overnight. For the first time, software stopped feeling rigid. You could just <em>talk</em> to systems naturally.</p><p>But somewhere along the way, a strange misconception started growing:</p><p>People began treating AI as if it only means chatbots and content generation.</p><p>The reality is much bigger than that.</p><p>Because outside the browser window, the physical world still exists.<br>And AI systems operating in the real world still face problems that prompts alone cannot solve.</p><p>A robot cannot understand a room through text.<br>A drone cannot navigate using token prediction.<br>An autonomous system cannot rely only on language reasoning.</p><p>Before intelligent systems can act, they first need to perceive.</p><p>And that part of AI still matters enormously.</p><h3>What Perception Actually Means</h3><p>When people hear “computer vision,” they often think of image classification demos or object detection boxes around random objects.</p><p>But perception is much broader than that.</p><p>Perception is how machines build awareness of the environment around them.</p><p>That includes things like:</p><ul><li>understanding depth</li><li>tracking motion</li><li>recognizing scenes</li><li>interpreting sensor data</li><li>estimating position</li><li>identifying obstacles</li><li>understanding spatial relationships</li></ul><p>Humans do this effortlessly.</p><p>You walk into a room and instantly understand:</p><ul><li>where objects are</li><li>what is moving</li><li>how far things are</li><li>whether something feels unsafe</li><li>how to navigate around obstacles</li></ul><p>Machines have to compute all of this explicitly.</p><p>And once you start exploring robotics or realtime AI systems, you realize how difficult this actually is.</p><p>A lot of “intelligence” in physical-world systems is not flashy reasoning.<br>It is stable perception running reliably at realtime speeds.</p><h3>Why Generative AI Did Not Replace Computer Vision</h3><p>There is a narrative online that LLMs are replacing everything.</p><p>I do not think that is true.</p><p>LLMs are exceptional at reasoning over language.<br>But the physical world is continuous, noisy, unpredictable, and realtime.</p><p>That changes the engineering problem completely.</p><p>For example, a robot navigating a warehouse cannot pause for several seconds to think about what a chair looks like.</p><p>It needs to:</p><ul><li>detect obstacles instantly</li><li>estimate motion continuously</li><li>maintain spatial awareness</li><li>process sensor streams in realtime</li><li>react under latency constraints</li></ul><p>Those are perception problems.</p><p>And interestingly, many of the hardest challenges are still deeply tied to systems engineering:</p><ul><li>latency</li><li>memory constraints</li><li>sensor synchronization</li><li>efficient inference</li><li>hardware limitations</li><li>reliability under unstable conditions</li></ul><p>This was one of the biggest things that surprised me while moving deeper into AI.</p><p>From the outside, modern AI often looks purely model driven.<br>But once you start looking at robotics, edge AI, or realtime perception systems, you realize models are only one part of the equation.</p><p>The surrounding system matters just as much.</p><p>Sometimes more.</p><h3>The Industry Is Quietly Moving Toward Multimodal AI</h3><p>I think the most important shift happening right now is not “better chatbots.”</p><p>It is the move toward multimodal systems.</p><p>AI models are starting to combine:</p><ul><li>vision</li><li>language</li><li>audio</li><li>spatial reasoning</li><li>memory</li><li>action planning</li></ul><p>This is where things become genuinely interesting.</p><p>We are already seeing:</p><ul><li>vision-language models</li><li>embodied AI systems</li><li>robotics foundation models</li><li>AI agents connected to cameras</li><li>spatial intelligence research</li></ul><p>The direction is becoming very clear.</p><p>Future AI systems will not just generate responses.<br>They will observe environments, interpret context, make decisions, and interact with the physical world.</p><p>And perception becomes the foundation for all of that.</p><p>Because language alone is not enough to ground intelligence in reality.</p><h3>Why This Matters for Engineers</h3><p>I think software engineering is also going through a shift because of this.</p><p>For years, most software lived primarily inside screens:<br>web apps, mobile apps, dashboards, APIs.</p><p>But intelligent systems increasingly interact with cameras, sensors, hardware, and realtime environments.</p><p>That changes what matters.</p><p>Now engineers suddenly care about:</p><ul><li>inference speed</li><li>edge deployment</li><li>sensor pipelines</li><li>battery consumption</li><li>threading</li><li>memory efficiency</li><li>realtime processing</li></ul><p>Running an AI model locally on-device is a very different engineering problem from running a cloud API.</p><p>And honestly, this intersection between systems engineering and AI feels massively underrated right now.</p><p>A lot of the discussion online focuses only on models.</p><p>But real-world AI products need much more than model quality.<br>They need reliability.</p><h3>My Interest in This Space</h3><p>Coming from realtime mobile systems, this shift is partly what pulled me toward computer vision and robotics.</p><p>I spent years working on systems where responsiveness, synchronization, connectivity, and realtime behavior actually mattered in production.</p><p>And the deeper I explored AI, the more I noticed similar engineering constraints appearing again:</p><ul><li>latency bottlenecks</li><li>memory pressure</li><li>streaming data</li><li>realtime pipelines</li><li>hardware-aware optimization</li></ul><p>That surprised me.</p><p>I initially assumed modern AI progress was mostly about larger models and more compute.</p><p>But perception-heavy systems reminded me that intelligence alone is not enough.<br>Systems still need to operate reliably under real-world constraints.</p><p>That intersection between AI and engineering is what I find most exciting now.</p><h3>Closing Thoughts</h3><p>Generative AI changed the industry. There is no question about that. But I do not think the future of AI stops at generating text, images, or code.</p><p>The next wave of intelligent systems will interact directly with the physical world:</p><ul><li>robots</li><li>autonomous systems</li><li>smart devices</li><li>industrial automation</li><li>spatial computing</li><li>embodied agents</li></ul><p>And none of these systems can function meaningfully without perception.</p><p>Because before AI can reason about the world, it first needs to understand what is happening inside it.</p><p>That is why perception still matters.</p><p>And I think it is going to matter even more over the next decade.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d5cf1669650" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From LLMs to Agents: AI Concepts Every Engineer Should Know]]></title>
            <link>https://ssharanyab.medium.com/from-llms-to-agents-ai-concepts-every-engineer-should-know-0cb82b7b725c?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/0cb82b7b725c</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[generative-ai-tools]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Sun, 17 May 2026 12:54:11 GMT</pubDate>
            <atom:updated>2026-05-17T12:54:11.365Z</atom:updated>
            <content:encoded><![CDATA[<h4>A practical guide to understanding the key terms shaping AI world</h4><p>Artificial Intelligence discussions today are filled with new terms almost every week.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/933/1*zgqYbFo1SnxpfE13IruHQw.png" /><figcaption>LLMs. Agents. RAG. Embeddings. Multimodal AI. Context windows. etc</figcaption></figure><p>For engineers coming from traditional software development background, this can be overwhelming. Rather than just understanding what these terms mean, the real challenge lies in understanding, why they matter, how they are connected together and where modern AI system is heading.</p><p>Over the past few weeks, while exploring deeper into AI systems, I realized something important:</p><blockquote>Most AI concepts make far more sense when you stop viewing them as “magic” and start viewing them as engineering systems.</blockquote><p>This article is my attempt to simplify some of the most important AI concepts every engineer should understand.</p><figure><img alt="https://media.makeameme.org/created/lets-get-started-5ab513.jpg" src="https://cdn-images-1.medium.com/max/600/0*5hoN80c6OUMRibpO.jpg" /><figcaption><a href="https://media.makeameme.org/created/lets-get-started-5ab513.jpg">https://media.makeameme.org/created/lets-get-started-5ab513.jpg</a></figcaption></figure><h3>1. LLMs (Large Language Models)</h3><p>Large Language Models are the foundation behind systems like: ChatGPT, Gemini, Claude etc.</p><p>At their core, LLMs are trained to predict the next token in a sequence. That sounds surprisingly simple for systems that appear intelligent. But because these models are trained on enormous amounts of text, they learn:</p><ul><li>patterns</li><li>reasoning structures</li><li>language relationships</li><li>code syntax</li><li>conversational behavior</li></ul><p>This is why they can:</p><ul><li>answer questions</li><li>generate code</li><li>summarize documents</li><li>explain concepts</li><li>write content</li></ul><p>But an important realization is:</p><p>LLMs are language systems first. They are not inherently connected to the physical world or realtime environments.</p><h3>2. Tokens</h3><p>When interacting with AI systems, models do not process text as complete sentences. They process smaller chunks called tokens.</p><p>A token may be:</p><ul><li>a word</li><li>part of a word</li><li>punctuation</li><li>or even spaces</li></ul><p>For example:</p><pre>“unbelievable”</pre><p>might become:</p><pre>[&quot;un&quot;, &quot;believ&quot;, &quot;able&quot;]</pre><p>Why does this matter?</p><p>Because:</p><ul><li>context limits are measured in tokens</li><li>API costs are measured in tokens</li><li>memory constraints depend on tokens</li></ul><p>Understanding tokens helps engineers think more realistically about AI system limitations.</p><h3>3. Context Windows</h3><p>A context window defines how much information a model can “remember” during a conversation or request.</p><p>For example:</p><ul><li>earlier chat history</li><li>uploaded documents</li><li>code files</li><li>instructions</li></ul><p>Larger context windows allow models to:</p><ul><li>analyze bigger codebases</li><li>maintain longer conversations</li><li>reason across documents</li></ul><p>But larger context also introduces engineering tradeoffs:</p><ul><li>increased compute cost</li><li>slower inference</li><li>memory usage challenges</li></ul><p>This becomes especially important in realtime systems and edge AI environments.</p><h3>4. Embeddings</h3><p>Embeddings are one of the most important concepts in modern AI systems. An embedding converts data into numerical vectors that capture semantic meaning.</p><p>In simpler terms:</p><blockquote>Embeddings help machines understand similarity.</blockquote><p>For example:</p><ul><li>“car”</li><li>“vehicle”</li><li>“automobile”</li></ul><p>may end up mathematically close to each other in vector space.</p><p>Embeddings power:</p><ul><li>semantic search</li><li>recommendation systems</li><li>retrieval systems</li><li>modern AI assistants</li></ul><p>They are a major reason why modern AI feels context aware.</p><h3>5. RAG (Retrieval-Augmented Generation)</h3><p>One common misconception is that AI models “know everything.” In reality, models often:</p><ul><li>hallucinate</li><li>provide outdated information</li><li>lack company-specific knowledge</li></ul><p>RAG solves this problem. Instead of retraining the model, a RAG system:</p><ol><li>searches relevant information</li><li>retrieves useful context</li><li>sends that context to the LLM</li><li>generates a better answer</li></ol><p>In practice, RAG is powering:</p><ul><li>enterprise AI assistants</li><li>document search tools</li><li>AI customer support systems</li><li>coding assistants</li></ul><p>This is one of the most practical and widely used AI architectures today.</p><h3>6. Multimodal AI</h3><p>Most people interact with AI through text. But the future of AI is increasingly multimodal. That means systems capable of understanding:</p><ul><li>text</li><li>images</li><li>video</li><li>audio</li><li>sensors</li></ul><p>This is where modern AI starts becoming much more interesting.</p><p>Instead of simply generating responses, AI systems begin understanding environments. Examples include:</p><ul><li>visual assistants</li><li>autonomous robots</li><li>AI-powered cameras</li><li>realtime translation systems</li><li>spatial computing interfaces</li></ul><p>This shift toward multimodal systems is one reason computer vision and perception remain extremely relevant.</p><h3>7. AI Agents</h3><p>Agents are one of the biggest trends in AI right now. An AI agent is not just a chatbot. It is a system capable of:</p><ul><li>reasoning</li><li>using tools</li><li>retrieving information</li><li>taking actions</li><li>executing workflows</li></ul><p>For example, an AI agent might:</p><ul><li>read emails</li><li>search documentation</li><li>query databases</li><li>generate reports</li><li>trigger APIs</li></ul><p>The important shift here is, AI is moving from:</p><pre>“generate text”</pre><p>toward:</p><pre>“perform tasks”</pre><p>That changes how engineers think about software systems entirely.</p><h3>8. Inference</h3><p>Inference is the process of running an AI model after training. This is where many practical engineering challenges appear:</p><ul><li>latency</li><li>memory usage</li><li>GPU optimization</li><li>power consumption</li><li>realtime responsiveness</li></ul><p>In production systems, inference speed often matters more than raw model capability. Especially in:</p><ul><li>mobile apps</li><li>robotics</li><li>smart devices</li><li>realtime AI systems</li></ul><h3>9. Edge AI</h3><p>Most AI demos today happen in the cloud. But many real-world systems cannot depend entirely on cloud inference.</p><p>That is where Edge AI becomes important. Edge AI means running models directly on:</p><ul><li>phones</li><li>robots</li><li>drones</li><li>IoT devices</li><li>embedded hardware</li></ul><p>Benefits include:</p><ul><li>lower latency</li><li>offline functionality</li><li>privacy</li><li>realtime responsiveness</li></ul><p>As AI increasingly moves into physical-world systems, Edge AI will likely become even more important.</p><h3>10. Embodied AI</h3><p>Embodied AI refers to systems that can:</p><ul><li>perceive environments</li><li>reason about them</li><li>and physically interact with the world</li></ul><p>Examples include:</p><ul><li>robots</li><li>autonomous vehicles</li><li>drones</li><li>smart machines</li></ul><p>This is where multiple domains begin merging:</p><ul><li>AI</li><li>computer vision</li><li>robotics</li><li>realtime systems</li><li>spatial understanding</li></ul><p>And this is also where modern AI becomes far more than just text generation.</p><h3>11. Tool Calling</h3><p>One of the biggest shifts in AI systems is that models are no longer limited to generating text. Modern AI systems can now use tools.</p><p>This might include:</p><ul><li>searching the web</li><li>querying databases</li><li>calling APIs</li><li>executing code</li><li>interacting with external software</li></ul><p>Instead of simply responding conversationally, models can now interact with systems dynamically. This is a major reason AI agents are becoming increasingly powerful.</p><h3>12. MCP (Model Context Protocol)</h3><p>As AI systems become more connected to tools and external data, interoperability becomes important.</p><p>MCP (Model Context Protocol) is an emerging standard designed to help AI models communicate with external tools, applications, and services in a more structured way.</p><p>In simple terms, MCP aims to make AI integrations more standardized and reusable.</p><p>Instead of building custom integrations for every tool, developers can expose capabilities through a shared protocol.</p><p>This is becoming increasingly important for:</p><ul><li>AI agents</li><li>development tools</li><li>enterprise assistants</li><li>workflow automation systems</li></ul><h3>13. LangChain</h3><p>As AI applications became more complex, developers needed frameworks to connect:</p><ul><li>prompts</li><li>memory</li><li>retrieval</li><li>tools</li><li>workflows</li><li>agents</li></ul><p>LangChain became one of the earliest popular frameworks solving this problem. It helps developers build AI applications by orchestrating multiple components together.</p><p>While the ecosystem is evolving rapidly, LangChain played a major role in shaping modern AI application development.</p><h3>14. Vector Databases</h3><p>Traditional databases are optimized for exact matches. But AI systems often need semantic similarity instead. That is where vector databases become important.</p><p>They store embeddings in ways that allow systems to search by meaning rather than exact keywords.</p><p>Vector databases power:</p><ul><li>semantic search</li><li>RAG systems</li><li>recommendation engines</li><li>AI memory systems</li></ul><p>As AI assistants become more context-aware, vector databases are becoming a foundational part of the modern AI stack.</p><h3>15. AI Orchestration Frameworks</h3><p>Modern AI systems are increasingly built as workflows rather than single prompts.</p><p>This led to orchestration frameworks such as:</p><ul><li>LangGraph</li><li>CrewAI</li><li>AutoGen</li></ul><p>These frameworks help coordinate:</p><ul><li>multiple agents</li><li>tool usage</li><li>reasoning loops</li><li>memory systems</li><li>task execution</li></ul><p>This is pushing AI development closer to distributed systems engineering than traditional chatbot development.</p><p>What makes modern AI fascinating is that it is no longer just about models.</p><p>It is becoming an entire engineering ecosystem involving: retrieval systems, orchestration frameworks. tool integrations, realtime inference, multimodal understanding and increasingly, interaction with the physical world.</p><p>The future of AI will likely belong to engineers who can build intelligent systems, not just use models.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0cb82b7b725c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Writing README.md]]></title>
            <link>https://ssharanyab.medium.com/writing-readme-md-2d44a8f0352b?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d44a8f0352b</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[readme]]></category>
            <category><![CDATA[markdown]]></category>
            <category><![CDATA[github-readme]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Sun, 15 Feb 2026 07:40:28 GMT</pubDate>
            <atom:updated>2026-02-15T07:40:28.431Z</atom:updated>
            <content:encoded><![CDATA[<h4>The Ultimate Guide to</h4><p>Tips and tricks to write readme documents effectively.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*p3tHVyox2SSC7d4775hqgA.png" /></figure><p>When someone lands on your GitHub repository, the first thing they see isn’t your code.<br>It’s your <strong>README</strong>.</p><p>A well-written README can turn a random visitor into a user, contributor, or even a recruiter impressed by your work. Yet many developers either skip it or write a rushed version.</p><p>This guide will help you write README files that are clear, useful, and visually appealing.</p><h3>What is README?</h3><p><strong>README.md</strong> is a Markdown file that lives inside your repository.<br>It acts as the <strong>front page of your project</strong>.</p><p>It tells people:</p><ul><li>What the project does</li><li>Why it exists</li><li>How to run it</li><li>How to contribute</li></ul><p>Think of it as your project’s <strong>user manual + marketing page</strong> combined.</p><h3>Need for Writing README for GitHub Repos</h3><h4>📌 1. Documentation</h4><p>A README serves as the <strong>entry-level documentation</strong> for your project.<br>Without it, users must read your code to understand anything — and most won’t.</p><h4>📌 2. Better Understanding of the Project</h4><p>A good README answers key questions:</p><ul><li>What problem does this solve?</li><li>Who is it for?</li><li>What technologies are used?</li><li>How do I run it?</li></ul><p>This reduces friction and increases adoption.</p><h4>📌 3. Visual Appeal Increases Viewership</h4><p>People judge repos quickly.<br>A visually structured README with badges, screenshots, and formatting:</p><ul><li>Looks professional</li><li>Builds trust</li><li>Encourages stars ⭐ and contributions</li></ul><h3>Basic Syntax</h3><p>Markdown is simple but powerful. Here are essentials every README should use.</p><h4>🔹 Headings</h4><p>Use # for titles and structure.</p><pre># Project Title<br>## Section<br>### Subsection</pre><h4>🔹 Bold, Italics, Underline</h4><pre>**Bold text**<br>*Italic text*<br>&lt;u&gt;Underline&lt;/u&gt;</pre><h4>🔹 Code</h4><p>Inline code:</p><pre>Use `npm install`</pre><p>Code block:</p><pre>```python<br>print(&quot;Hello World&quot;)<br>```</pre><p>Use code blocks for commands, configs, or examples.</p><h3>Adding Visuals</h3><p>Visuals make your README easier to scan and more engaging.</p><h4>🖼 Images</h4><pre>![Screenshot](image-link.png)</pre><p>Use images for:</p><ul><li>UI previews</li><li>Architecture diagrams</li><li>Feature highlights</li></ul><h4>🎥 Videos</h4><p>You can embed YouTube previews using images with links:</p><pre>[![Watch Demo](thumbnail.png)](video-link)</pre><p>Great for:</p><ul><li>App walkthroughs</li><li>Demo recordings</li><li>Tutorials</li></ul><h3>🎞 GIFs</h3><p>GIFs are perfect for showing features quickly.</p><p>Use them for:</p><ul><li>UI animations</li><li>Workflow demonstrations</li><li>Before/after comparisons</li></ul><p>Short GIFs often explain more than long paragraphs.</p><h3>Some More Things You Should Include</h3><p>A great README usually contains:</p><h4>✅ Project Description</h4><p>One paragraph explaining what it does.</p><h4>✅ Features List</h4><p>Bullet points of key functionality.</p><h4>✅ Installation Steps</h4><p>Step-by-step commands.</p><h4>✅ Usage Example</h4><p>Show how to actually use it.</p><h4>✅ Tech Stack</h4><p>Mention frameworks, languages, tools.</p><h4>✅ Contribution Guide</h4><p>Tell others how to help.</p><h4>✅ License</h4><p>Clarify usage rights.</p><h3>References</h3><p>Helpful tools for writing better READMEs:</p><ul><li>Markdown Guide — https://www.markdownguide.org</li><li>Shields.io — for badges</li><li>Carbon — for code screenshots</li><li>Gifcap / ScreenToGif — for recording demos</li></ul><h3>Final Thoughts</h3><p>Your README is not just documentation.<br>It’s your project’s <strong>first impression, onboarding guide, and portfolio page</strong> all in one.</p><p>A clean, structured README:</p><ul><li>Makes your work understandable</li><li>Attracts contributors</li><li>Impresses recruiters</li><li>Builds credibility</li></ul><p>So next time you push a repo, don’t treat README as an afterthought.<br>Treat it as the <strong>homepage of your project</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d44a8f0352b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Flutter Performance Myth Nobody Talks About]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://ssharanyab.medium.com/the-flutter-performance-myth-nobody-talks-about-38a30157c3a0?source=rss-8b5359d5576c------2"><img src="https://cdn-images-1.medium.com/max/600/1*J56n2QK8QghDVTwKAOXJfw.png" width="600"></a></p><p class="medium-feed-snippet">A real-world lesson on rebuilds, state noise, and architectural mistakes.</p><p class="medium-feed-link"><a href="https://ssharanyab.medium.com/the-flutter-performance-myth-nobody-talks-about-38a30157c3a0?source=rss-8b5359d5576c------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://ssharanyab.medium.com/the-flutter-performance-myth-nobody-talks-about-38a30157c3a0?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/38a30157c3a0</guid>
            <category><![CDATA[flutter-performance]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[flutter-ui]]></category>
            <category><![CDATA[flutter-app-development]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Mon, 26 Jan 2026 06:13:40 GMT</pubDate>
            <atom:updated>2026-01-26T06:13:40.578Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[You Don’t Really Understand SOLID Principles (And That’s Why Your Code Hurts to Change)]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://ssharanyab.medium.com/you-dont-really-understand-solid-principles-and-that-s-why-your-code-hurts-to-change-1f522001c1a5?source=rss-8b5359d5576c------2"><img src="https://cdn-images-1.medium.com/max/1536/1*PfYmciJuYHIRxxU9bxN-Pg.png" width="1536"></a></p><p class="medium-feed-snippet">The difference between code that works and code that survives.</p><p class="medium-feed-link"><a href="https://ssharanyab.medium.com/you-dont-really-understand-solid-principles-and-that-s-why-your-code-hurts-to-change-1f522001c1a5?source=rss-8b5359d5576c------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://ssharanyab.medium.com/you-dont-really-understand-solid-principles-and-that-s-why-your-code-hurts-to-change-1f522001c1a5?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f522001c1a5</guid>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[clean-code]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Thu, 15 Jan 2026 07:22:51 GMT</pubDate>
            <atom:updated>2026-01-15T07:22:51.772Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Understanding Flutter’s Rendering Architecture]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://ssharanyab.medium.com/understanding-flutters-rendering-architecture-1b4beca70ecf?source=rss-8b5359d5576c------2"><img src="https://cdn-images-1.medium.com/max/600/1*vCzQhtW0W4C_qODLN1b5pA.png" width="600"></a></p><p class="medium-feed-snippet">A clear explanation of how Flutter controls UI rendering across platforms</p><p class="medium-feed-link"><a href="https://ssharanyab.medium.com/understanding-flutters-rendering-architecture-1b4beca70ecf?source=rss-8b5359d5576c------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://ssharanyab.medium.com/understanding-flutters-rendering-architecture-1b4beca70ecf?source=rss-8b5359d5576c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b4beca70ecf</guid>
            <category><![CDATA[flutter-widget]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[flutter-performance]]></category>
            <category><![CDATA[flutter-app-development]]></category>
            <category><![CDATA[flutter-ui]]></category>
            <dc:creator><![CDATA[Sharanya Bharghavi]]></dc:creator>
            <pubDate>Mon, 12 Jan 2026 07:52:47 GMT</pubDate>
            <atom:updated>2026-01-12T07:52:47.918Z</atom:updated>
        </item>
    </channel>
</rss>