<?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 Zain on Medium]]></title>
        <description><![CDATA[Stories by Zain on Medium]]></description>
        <link>https://medium.com/@pseudozain?source=rss-e003f21c893f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*SIogP_XpKYhFHzZYSsTODQ.jpeg</url>
            <title>Stories by Zain on Medium</title>
            <link>https://medium.com/@pseudozain?source=rss-e003f21c893f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 20:11:40 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@pseudozain/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[The Cross-Platform Bargain Just Expired]]></title>
            <link>https://pseudozain.medium.com/the-cross-platform-bargain-just-expired-de66928e8b75?source=rss-e003f21c893f------2</link>
            <guid isPermaLink="false">https://medium.com/p/de66928e8b75</guid>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[ai-driven-development]]></category>
            <category><![CDATA[android-development]]></category>
            <dc:creator><![CDATA[Zain]]></dc:creator>
            <pubDate>Sat, 12 Sep 2026 12:17:48 GMT</pubDate>
            <atom:updated>2026-09-12T12:40:44.431Z</atom:updated>
            <content:encoded><![CDATA[<p>Every cross-platform framework sells the same deal, and on paper it’s a good one: <strong>one codebase instead of two, at roughly half the cost.</strong> Maintainability and Economics. Everything else in the pitch — the hot reload, the widget catalogs, the single hiring pipeline — is a supporting argument for those two claims.</p><p>I’ve spent a meaningful stretch of my career taking cross-platform applications apart and rebuilding them as native iOS and Android apps. Not as an ideological exercise, because the products needed things the frameworks made expensive. What I didn’t expect was how badly both halves of the bargain held up once I was standing on the other side of the migration.</p><p>The maintainability promise was never true. It was the <em>cost</em> of cross-platform, sold as its benefit.</p><p>The cost promise was true, right up until LLMs turned the one slice of work it was saving into the cheapest part of building software.</p><h3>What you are actually maintaining</h3><p>The pitch counts repositories. One codebase, not two. It’s a compelling unit of measurement and it’s the wrong one.</p><p>What makes software expensive to maintain isn’t how many files you have. It’s how many independent things each change has to satisfy, and how far a mistake can travel.</p><p>A native Android codebase answers to one platform. One compiler, one set of OS behaviours, one release train, one set of release notes each autumn. When you fix an Android bug, you fix it in Android code and it ships to Android users. Nothing you did can break iOS, because there is no mechanism by which it could.</p><p>A cross-platform codebase answers to three: iOS, Android, and the framework, which is itself chasing the other two and is always slightly behind. You did not remove a maintenance target. You added one, and then you coupled the other two together through it.</p><p>That coupling is the part nobody prices in. In a shared codebase, an Android-only bug gets fixed in shared code. Which means review from someone who can reason about both platforms, regression testing on both platforms, and a release on both platforms — for a defect that only ever existed on one. You halved the line count and doubled the blast radius of every change. Anyone who has maintained a large system knows which of those two numbers actually governs velocity.</p><p>Then there’s conditional rot. Platform divergence doesn’t disappear because you decided to write one codebase; the two operating systems did not agree to converge just because your build system did. So the divergence moves <em>inside your files</em>. Platform.OS checks. defaultTargetPlatform branches. Two permission flows. Two notification models. Two background-execution stories. Two sets of navigation gestures that have to feel right to two sets of users with different muscle memory. Eighteen months in, a busy cross-platform codebase is two codebases interleaved line by line into the same files you kept all of the divergence and gave up the separation that made it manageable. Native keeps that same divergence in two different buildings, which is where it belongs.</p><h3>The tax on the layer</h3><p>Beyond coupling, four costs come with putting a framework between your product and the platforms. None of them are visible in a proof of concept.</p><p><strong>Every autumn, the platform moves. </strong>This is the cost I had underweighted most, and it’s structural rather than occasional: Apple and Google ship a major OS release every year, and each one arrives with a set of APIs you are expected to adopt.</p><p>Last year’s was the clearest case I’ve seen. iOS 26 introduced Liquid Glass, a new system design language, with new materials, new corner treatments, and new behavior for standard controls. A native app rebuilt against the new SDK inherits most of that on its standard controls, because those controls belong to the operating system. Flutter’s don’t. Flutter draws its own widgets in its own engine, and its Cupertino set is a <em>copy</em> of Apple’s design language maintained by Google, so there is nothing to inherit. Someone at a second company has to reproduce a first company’s new design language, ship it in a framework release, and then you upgrade to receive it. You aren’t late because your team is slow. You’re late because you’re third in a queue you don’t manage.</p><p>This year is the harder version of the same problem. Apple announced iPhone Duo on September 9th a foldable, 5.4 inches closed and 7.6 inches open. New form factor, new API surface. Apple’s guidance to developers is specific: stop checking interface orientation and use size classes; handle safe-area insets that are now asymmetric, per side; adopt the concentricity APIs so your corners match the hardware&#39;s; use the new ReservedRegion to claim screen space without colliding with system UI.</p><p>To be fair about it: native teams don’t get foldable support for free either. Apple’s list above is real work, and retrofitting size classes across an existing app is a project. The difference isn’t work versus no work. It’s that a native team could start in September, and a cross-platform team starts whenever its framework and its plugin graph get there.</p><p><strong>You still don’t control your upgrade schedule. </strong>That was the adoption gap. There’s a defensive version of it too. Native teams read the release notes and upgrade. Cross-platform teams wait, first for the framework, then for every plugin in the dependency graph, in dependency order, much of it maintained by people doing it in their spare time. And periodically the framework itself asks you for a migration: React Native’s new architecture, a major Flutter release with breaking changes. That’s a quarter of engineering work that ends with the app doing exactly what it did before. Native has upgrade work too. It has one layer of it, not two, and nobody in the chain is a volunteer.</p><p><strong>The escape hatches are not edge cases. </strong>The pitch treats native code as something you drop into occasionally. In a mature product it’s most of what’s interesting.</p><p>Take widgets, and note this holds regardless of which framework you picked. On iOS, a widget is a WidgetKit extension: it runs in its own process, it’s rendered ahead of time, and it must be SwiftUI. There is no Flutter engine in there and no JavaScript runtime. On Android, an app widget is RemoteViews or Jetpack Glance, which compiles down to RemoteViews, hosted by the launcher’s process rather than yours. Same conclusion.</p><p>So a cross-platform team shipping widgets writes SwiftUI, writes Kotlin, and then writes the part nobody budgets for: the widget cannot call into your Dart or your JavaScript, so anything it displays has to be handed across to native storage first. App Groups and a shared container on iOS, DataStore or SharedPreferences on Android, and kept in sync from then on. Two native implementations plus a data bridge, to ship the kind of feature the framework was supposed to make unnecessary.</p><p>Widgets aren’t special. They’re one instance of something larger: an app is no longer one screen. It’s a widget, a Live Activity and a Dynamic Island presentation, a watch app, a tile, CarPlay and Android Auto, a share extension, a notification with custom UI. Cross-platform frameworks cover the main window very well. Nearly every surface the platforms have added in the last decade sits outside it.</p><p>Hardware is the same story from the other direction. Anything past “open the camera and take a photo” manual focus and exposure, multi-camera, depth, RAW, processing frames on the preview stream, is AVFoundation and CameraX, and you write both. Worse, it’s the one place where the boundary itself becomes the bottleneck: moving pixel buffers across a platform channel thirty or sixty times a second is the most expensive thing you can ask that boundary to do. Bluetooth, NFC, biometrics and the secure enclave, background location, health data, each is a plugin and each plugin is a package sitting between your product and an OS API that changes every year.</p><p>Count it honestly and you are not writing fewer platforms than a native team. <strong>You’re writing iOS, Android, and the glue between them.</strong></p><p><strong>Diagnosis always starts one step further from the answer.</strong> When a native app is janky or crashing, the stack trace lands in your code and you open Instruments, the Android Studio profiler, or Perfetto. First-party tools built by the people who built the runtime, with full symbols. When a cross-platform app is janky, the trace terminates at a boundary and you’re left with a three-way question: is this my code, the framework’s mapping of my code, or the platform underneath? Every incident carries an extra hypothesis, and the tooling that would eliminate it is exactly the tooling you gave up. Across a year of production operation, that compounds into real weeks.</p><p>Add it up, and the honest description of cross-platform maintainability is: fewer lines, more coupling, more dependencies, slower diagnosis, and a release cadence you don’t own.</p><p><strong>Some teams should still take that trade.</strong></p><blockquote><strong>But it is a trade, not a saving — and it should stop being sold as the easy half of the decision.</strong></blockquote><h3>The cost argument, and what AI did to it</h3><p>Here’s the part that’s genuinely new.</p><p>Cross-platform’s economic case was never about the whole project. It was about one slice of it. Look at where the money in a mobile app actually goes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kGQcBUQG7omXcSgBa-L9MA.png" /></figure><p>What’s left, the part cross-platform genuinely saved is the second implementation pass: writing the same screens and the same client-side logic a second time in a second language. It was never half the project. It was one meaningful slice, and “50% cheaper” was always marketing.</p><p>That slice is precisely the work AI-driven development has compressed hardest, and the <em>second</em> rendition of it is the easiest case there is. You aren’t asking a model to invent anything. The product decisions are made, the API contract exists, the design is final, and the edge cases were already discovered during the first implementation. You <strong><em>plan once and execute twice</em></strong>. That is the cheapest possible kind of work to hand to a model, and it is the <em>only</em> kind cross-platform was saving you.</p><p>The obvious objection is that AI helps cross-platform teams too. It does. That’s exactly the problem. Symmetric help applied to an asymmetric advantage erases the asymmetry. Cross-platform’s advantage was specifically implementation volume; when implementation volume gets cheap for everyone, the advantage shrinks toward nothing while the costs, the coupling, the extra dependency layer, the diagnosis tax, the upgrade treadmill, stay exactly where they were. Those aren’t authoring problems. They’re coordination and diagnosis problems inside a system you don’t control, and no coding assistant fixes them, because there’s nothing to type.</p><blockquote><strong>The bargain didn’t go bad because native got better. It went bad because the thing it was selling got cheap.</strong></blockquote><h3>What you get back</h3><p>Native’s performance advantage is usually argued with benchmarks, which just invites an argument about benchmarks. The structural version is more convincing: cross-platform apps carry something extra at runtime, and you cannot optimize away a thing’s existence.</p><p>React Native runs a JavaScript runtime alongside your app. The new architecture removed the old asynchronous JSON bridge, and that was a real improvement, but a second runtime and a language boundary are still there, and they still cost you at startup and at every crossing.</p><p>Flutter takes the opposite approach, compiling to native ARM code, which removes that problem and introduces a different one: it brings its own rendering engine and its own re-implementation of both platforms’ widget layers. It’s genuinely impressive engineering. It also means you ship a renderer inside your binary, and your Material and Cupertino widgets are <em>copies</em> of the real design languages, maintained by a different company, drifting from the originals every time Apple or Google changes something.</p><p>Concretely, here’s what you get back when you remove that layer:</p><ol><li><strong>Cold start</strong>. Process start plus your code, no runtime initialization, no bundle parse, no engine warm-up, no plugin registration before first frame. That’s a fixed tax on every single launch that you can shave but never delete.</li><li><strong>Memory and binary size. </strong>Both drop, because the second runtime and the duplicated widget layer are gone. On flagship hardware nobody notices. On the mid-range Android devices that constitute the actual market across most of the world, it’s the difference between a smooth app and one that gets evicted from memory the moment it’s backgrounded.</li><li><strong>Scroll and animation under load. </strong>Image-heavy feeds, maps, camera preview, long heterogeneous lists, this is where the abstraction is thinnest and platform-tuned view recycling and compositing win outright.</li><li><strong>Observability at full fidelity. </strong>Real symbols, no source maps, no deobfuscation layer, first-party profilers, Play Vitals and Xcode Organizer telling you the truth about your own code. Faster diagnosis means faster fixes, which is, if we’re being precise about the word, <em>maintainability</em>.</li><li><strong>Accessibility and platform behavior for free. </strong>Dynamic Type, VoiceOver and TalkBack semantics, text selection, keyboard handling, haptics, predictive back. Frameworks approximate all of this. Approximations produce exactly the class of bug that never makes it above the line on a roadmap, and that permanently makes an app feel slightly wrong in a way users report as “slow” even when your metrics are clean.</li></ol><h3>Where cross-platform still wins</h3><p>I’d be arguing dishonestly if I claimed there’s no case left:</p><ul><li><strong>The app might not exist in eighteen months.</strong> Pre-product-market-fit, a prototype, a pilot. Time-to-first-ship has real option value, and taking on debt you may never have to repay is a legitimate strategy.</li><li><strong>The product barely touches the OS.</strong> Content-driven apps, internal tools, event apps, CMS-backed catalogs, straightforward CRUD over an API. If your roadmap never reaches the camera, background execution, or the home screen, you never hit the escape hatches that generate most of the cost.</li><li><strong>You have one mobile developer and no plausible path to a second.</strong> That’s an organizational constraint rather than a technical argument, and it’s a completely valid reason.</li><li><strong>Web is the real product.</strong> If the mobile app is a companion to a large React web app, the code-sharing story is genuine and the arithmetic changes.</li></ul><p>And one thing worth saying plainly:</p><blockquote><strong>If you have a healthy cross-platform app in production that ships features on schedule, this article is not a reason to rewrite it.</strong> Rewrites have their own catastrophic failure modes. The argument here is about what you choose next and about the teams already paying this tax every sprint who have started calling it the cost of doing business.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de66928e8b75" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Are ‘Best Practices’ always best?]]></title>
            <link>https://pseudozain.medium.com/are-best-practices-always-best-71ba0bfb5536?source=rss-e003f21c893f------2</link>
            <guid isPermaLink="false">https://medium.com/p/71ba0bfb5536</guid>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[prodcutivity]]></category>
            <category><![CDATA[growth]]></category>
            <dc:creator><![CDATA[Zain]]></dc:creator>
            <pubDate>Fri, 19 Mar 2021 12:54:32 GMT</pubDate>
            <atom:updated>2024-07-26T03:04:34.226Z</atom:updated>
            <content:encoded><![CDATA[<p>Being a software engineering professional I’ve to deal with the best practices a lot. First thing first: Do they really work? Yes, for the most part, they do. Before I jump into it, let me present to you a case study.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*G73PguUovhlCY2RDo8EUGQ.jpeg" /></figure><p>In 2010, Michael Housman, a labour economist was working on a project to figure out why some of the call centre workers perform better than the others. After looking at all the dynamics and variables, from data of 50,000 people, he and his team couldn’t establish a relationship, an equation to determine what better performers are doing different that the worse performers. His team examined every aspect of the assessment to see if it held clues about longevity and performance. No matter how hard they tried they were failing.</p><p>One of his research assistant started looking at the data of web browsers, the candidates used to fill out the assessment form. Some candidates had used Safari, other Google Chrome, some used Firefox and some had used Internet Explorer. At first it looked unrelated, surely, it was only matter of personal preference. Yet the results were astonishing. People who used Google Chrome and Firefox stayed in their job 15 percent longer than those who used Safari and Internet Explorer. People who were using Safari and Internet Explorer had 19 percent more absents than those who were using Firefox and Google Chrome. People who used Firefox and Google Chrome had higher productivity, higher sales, and happier customers.</p><p>Now these are totally unrelated numbers, how use of a certain web browser could effect performance and longevity? What does a call centre employee had to do with web browsers? Well, good news! there is nothing wrong with the web browsers. Now let’s look at a different aspect. Internet Explorer and Safari come pre-installed, Internet Explorer with PCs and Safari with Macs. You just turn on your PC or Mac and you’re ready to go. But, if you want to use Google Chrome or Firefox you have to install them.</p><p>Have you ever wonder what drives humans to want a different thing even when they have something equivalent? It’s CURIOSITY. It’s the desire to have something better. People who have this desire they become wonderers, they always try to find a better option. They are the EXPLORERS. They do not make themselves at peace with standards set by someone else. They always try to find something new and become innovators.</p><p>People who were using Firefox and Google Chrome had explorer mindset, they did not go with the standard, they explored something better (for themselves). Everyone knows Internet Explorer and Safari work ‘best’ with their respective Operating Systems, while Google Chrome and Firefox consume more memory, and might make your computer slow sometimes. But people who had explorer mindset explored better options for themselves. When you have this mindset you are always ready to coupe out of the box situations. In a call centre usually you don’t have to deal with out of the box situations a lot because most of the time customer’s queries are same. But when there is an unexpected query you might not answer it correctly but you might be able to handle it better than a non-explorer mind.</p><p>Now let’s come back to the questions. Should we follow the best practices? Definitely, we should. Should we stick to them? Never, you should never let the standards set by others become hindrance in your innovation. In my opinion best practices are only best until you find a better solution. And believe me there is always a better solution. Keep digging!</p><p>Ref: <em>Case study taken from: Rebel Ideas by Matthew Syed</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71ba0bfb5536" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>