<?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 Nathan Fallet on Medium]]></title>
        <description><![CDATA[Stories by Nathan Fallet on Medium]]></description>
        <link>https://medium.com/@nathanfallet?source=rss-404a540f77b0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*1SgVtWnZOGQDwgSmqTDYeQ.jpeg</url>
            <title>Stories by Nathan Fallet on Medium</title>
            <link>https://medium.com/@nathanfallet?source=rss-404a540f77b0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 06:29:01 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@nathanfallet/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[Why We Don’t Need Libraries in Kotlin Multiplatform]]></title>
            <link>https://nathanfallet.medium.com/why-we-dont-need-libraries-in-kotlin-multiplatform-298053c79a77?source=rss-404a540f77b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/298053c79a77</guid>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Nathan Fallet]]></dc:creator>
            <pubDate>Thu, 06 Nov 2025 13:56:47 GMT</pubDate>
            <atom:updated>2025-11-06T13:56:47.027Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’ve spent any time browsing the React Native or Flutter package repositories, you’ve probably noticed something curious: there are libraries for <em>everything</em>. Want to get the device’s battery level? There’s a library. Need to trigger haptic feedback? There’s a library. Want to check network connectivity? You guessed it, there’s a library.</p><p>Tell a native Android or iOS developer that you’re using a third-party library to check the battery level, and they’ll look at you like you’ve lost your mind. In native development, these are trivial system API calls — a few lines of code at most. No developer would dream of adding a dependency for something so fundamental.</p><p>But here’s the question: why do cross-platform frameworks need third-party dependencies for simple native API calls that native developers handle directly?</p><p>The answer isn’t that these frameworks attract lazy developers. It’s that calling native code in React Native and Flutter is painful enough that most developers would rather add a dependency than deal with it themselves. Kotlin Multiplatform (KMP) takes a fundamentally different approach: one that makes native interop so straightforward that you’ll wonder why you ever tolerated the complexity of bridges and channels.</p><p>Let me show you what I mean with a concrete example: getting the device’s battery level.</p><h3>The React Native Way: Welcome to Bridge Hell</h3><p>React Native uses a JavaScript-to-native bridge for all platform communication. This means your JavaScript code can’t directly call native APIs, everything must be serialized, sent across the bridge, executed on the native side, and then the result serialized back.</p><p>Here’s what you need to do to get the battery level in React Native:</p><h3>Step 1: Create the Native Module (iOS — Objective-C/Swift)</h3><p><strong>BatteryModule.h</strong></p><pre>#import &lt;React/RCTBridgeModule.h&gt;<br><br>@interface BatteryModule : NSObject &lt;RCTBridgeModule&gt;<br>@end</pre><p><strong>BatteryModule.m</strong></p><pre>#import &quot;BatteryModule.h&quot;<br>#import &lt;UIKit/UIKit.h&gt;<br><br>@implementation BatteryModule<br><br>RCT_EXPORT_MODULE();<br><br>RCT_EXPORT_METHOD(getBatteryLevel:(RCTPromiseResolveBlock)resolve<br>                  rejecter:(RCTPromiseRejectBlock)reject)<br>{<br>  UIDevice *device = [UIDevice currentDevice];<br>  device.batteryMonitoringEnabled = YES;<br>  float batteryLevel = device.batteryLevel;<br>  if (batteryLevel &lt; 0) {<br>    reject(@&quot;battery_error&quot;, @&quot;Battery level not available&quot;, nil);<br>  } else {<br>    resolve(@(batteryLevel * 100));<br>  }<br>}<br><br>@end</pre><h3>Step 2: Create the Native Module (Android — Kotlin/Java)</h3><p><strong>BatteryModule.kt</strong></p><pre>package com.yourapp<br><br>import android.content.Context<br>import android.content.Intent<br>import android.content.IntentFilter<br>import android.os.BatteryManager<br>import com.facebook.react.bridge.*<br><br>class BatteryModule(reactContext: ReactApplicationContext) : <br>    ReactContextBaseJavaModule(reactContext) {<br><br>    override fun getName() = &quot;BatteryModule&quot;<br>    <br>    @ReactMethod<br>    fun getBatteryLevel(promise: Promise) {<br>        try {<br>            val batteryStatus: Intent? = IntentFilter(<br>                Intent.ACTION_BATTERY_CHANGED<br>            ).let { filter -&gt;<br>                reactApplicationContext.registerReceiver(null, filter)<br>            }<br><br>            val level = batteryStatus?.getIntExtra(BatteryManager.EXTRA_LEVEL, -1) ?: -1<br>            val scale = batteryStatus?.getIntExtra(BatteryManager.EXTRA_SCALE, -1) ?: -1<br><br>            val batteryPct = level / scale.toFloat() * 100<br>            promise.resolve(batteryPct.toDouble())<br>        } catch (e: Exception) {<br>            promise.reject(&quot;battery_error&quot;, &quot;Could not get battery level&quot;, e)<br>        }<br>    }<br>}</pre><h3>Step 3: Register the Module (Android)</h3><p><strong>MainApplication.kt</strong></p><pre>override fun getPackages(): List&lt;ReactPackage&gt; {<br>    return PackageList(this).packages.apply {<br>        add(BatteryPackage()) // You also need to create this PackageList wrapper<br>    }<br>}</pre><h3>Step 4: Finally, Use It in JavaScript</h3><p><strong>App.js</strong></p><pre>import { NativeModules } from &#39;react-native&#39;;<br><br>const { BatteryModule } = NativeModules;<br><br>async function checkBattery() {<br>  try {<br>    const level = await BatteryModule.getBatteryLevel();<br>    console.log(`Battery level: ${level}%`);<br>  } catch (error) {<br>    console.error(error);<br>  }<br>}</pre><p><strong>Total:</strong> Multiple files, platform-specific code in three languages (JavaScript, Objective-C/Swift, Kotlin/Java), boilerplate for promise handling, module registration… and that’s just for a single system API call.</p><p>Now you understand why react-native-device-info has over 6,000 stars on GitHub. Nobody wants to go through this every time they need a simple native API.</p><h3>Flutter: Better, But Still Complex</h3><p>Flutter improves on React Native’s bridge by using platform channels with binary serialization, which is faster. But the developer experience? Still painful.</p><h3>Step 1: Set Up the Dart Side</h3><p><strong>battery_level.dart</strong></p><pre>import &#39;package:flutter/services.dart&#39;;<br><br>class BatteryLevel {<br>  static const platform = MethodChannel(&#39;com.example.battery&#39;);<br>  Future&lt;int&gt; getBatteryLevel() async {<br>    try {<br>      final int result = await platform.invokeMethod(&#39;getBatteryLevel&#39;);<br>      return result;<br>    } on PlatformException catch (e) {<br>      print(&quot;Failed to get battery level: &#39;${e.message}&#39;.&quot;);<br>      return -1;<br>    }<br>  }<br>}</pre><h3>Step 2: Android Implementation</h3><p><strong>MainActivity.kt</strong></p><pre>import android.content.Context<br>import android.content.Intent<br>import android.content.IntentFilter<br>import android.os.BatteryManager<br>import io.flutter.embedding.android.FlutterActivity<br>import io.flutter.embedding.engine.FlutterEngine<br>import io.flutter.plugin.common.MethodChannel<br><br>class MainActivity: FlutterActivity() {<br>    private val CHANNEL = &quot;com.example.battery&quot;<br>    <br>    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {<br>        super.configureFlutterEngine(flutterEngine)<br>        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL)<br>            .setMethodCallHandler { call, result -&gt;<br>                if (call.method == &quot;getBatteryLevel&quot;) {<br>                    val batteryLevel = getBatteryLevel()<br>                    if (batteryLevel != -1) {<br>                        result.success(batteryLevel)<br>                    } else {<br>                        result.error(&quot;UNAVAILABLE&quot;, &quot;Battery level not available.&quot;, null)<br>                    }<br>                } else {<br>                    result.notImplemented()<br>                }<br>            }<br>    }<br><br>    private fun getBatteryLevel(): Int {<br>        val batteryLevel: Int<br>        val batteryManager = getSystemService(Context.BATTERY_SERVICE) as BatteryManager<br>        batteryLevel = batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)<br>        return batteryLevel<br>    }<br>}</pre><h3>Step 3: iOS Implementation</h3><p><strong>AppDelegate.swift</strong></p><pre>import UIKit<br>import Flutter<br><br>@UIApplicationMain<br>@objc class AppDelegate: FlutterAppDelegate {<br>  override func application(<br>    _ application: UIApplication,<br>    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?<br>  ) -&gt; Bool {<br>    let controller : FlutterViewController = window?.rootViewController as! FlutterViewController<br>    let batteryChannel = FlutterMethodChannel(<br>        name: &quot;com.example.battery&quot;,<br>        binaryMessenger: controller.binaryMessenger)<br><br>    batteryChannel.setMethodCallHandler({<br>      [weak self] (call: FlutterMethodCall, result: @escaping FlutterResult) -&gt; Void in<br>      guard call.method == &quot;getBatteryLevel&quot; else {<br>        result(FlutterMethodNotImplemented)<br>        return<br>      }<br>      self?.receiveBatteryLevel(result: result)<br>    })<br><br>    GeneratedPluginRegistrant.register(with: self)<br>    return super.application(application, didFinishLaunchingWithOptions: launchOptions)<br>  }<br><br>  private func receiveBatteryLevel(result: FlutterResult) {<br>    let device = UIDevice.current<br>    device.isBatteryMonitoringEnabled = true<br>    if device.batteryState == UIDevice.BatteryState.unknown {<br>      result(FlutterError(code: &quot;UNAVAILABLE&quot;,<br>                         message: &quot;Battery level not available.&quot;,<br>                         details: nil))<br>    } else {<br>      result(Int(device.batteryLevel * 100))<br>    }<br>  }<br>}</pre><p>Again, multiple files, manual channel registration, serialization concerns, and error handling boilerplate. This is why battery_plus exists with over 500,000 downloads. For a single system API call.</p><h3>Kotlin Multiplatform: Just Write the Code</h3><p>Now, watch this. Here’s the entire implementation in KMP:</p><h3>Common Code</h3><p><strong>BatteryLevel.kt</strong> (commonMain)</p><pre>expect fun getBatteryLevel(): Int</pre><p>That’s it. One line. An expect declaration that says &quot;each platform will provide this.&quot;</p><h3>Android Implementation</h3><p><strong>BatteryLevel.android.kt</strong> (androidMain)</p><pre>import android.content.Context<br>import android.os.BatteryManager<br><br>actual fun getBatteryLevel(): Int {<br>    val context = // your application context<br>    val batteryManager = context.getSystemService(Context.BATTERY_SERVICE) as BatteryManager<br>    return batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)<br>}</pre><h3>iOS Implementation</h3><p><strong>BatteryLevel.ios.kt</strong> (iosMain)</p><pre>import platform.UIKit.UIDevice<br><br>actual fun getBatteryLevel(): Int {<br>    val device = UIDevice.currentDevice<br>    device.batteryMonitoringEnabled = true<br>    return (device.batteryLevel * 100).toInt()<br>}</pre><h3>Usage</h3><p><strong>App.kt</strong> (commonMain)</p><pre>fun displayBatteryStatus() {<br>    val level = getBatteryLevel()<br>    println(&quot;Battery level: $level%&quot;)<br>}</pre><p><strong>Total:</strong> Three simple files with crystal-clear intent. No bridges. No serialization. No channels. No registration boilerplate. No third-party library needed.</p><p>The common code declares what you need. Each platform implements it with direct API access. You call it like any other function. Done.</p><h3>Why This Difference Matters</h3><h3>The Dependency Proliferation Problem</h3><p>Browse any mature React Native or Flutter app and you’ll find dozens of dependencies that exist solely to wrap native APIs:</p><ul><li>react-native-device-info</li><li>react-native-haptic-feedback</li><li>react-native-permissions</li><li>battery_plus</li><li>connectivity_plus</li><li>device_info_plus</li></ul><p>Each one adds:</p><ul><li><strong>Bundle size</strong>: Additional code in your app</li><li><strong>Maintenance burden</strong>: You’re dependent on library authors for updates</li><li><strong>Version conflicts</strong>: Dependency hell when libraries require different versions</li><li><strong>Supply chain risk</strong>: You trust library maintainers with your app’s security</li><li><strong>Debugging complexity</strong>: Issues buried in third-party code</li></ul><p>In KMP, you write these 10–20 lines yourself. You understand exactly what’s happening. You control when and how it updates. You have zero external dependencies for simple platform calls.</p><h3>The “Wait for Someone Else” Problem</h3><p>In React Native and Flutter, there’s a cultural pattern:</p><ol><li>Developer needs native functionality</li><li>Sees the bridge/channel complexity</li><li>Thinks “someone must have already wrapped this”</li><li>Searches npm/pub.dev</li><li>Either finds a library (adds dependency) or gives up</li></ol><p>This creates an innovation bottleneck. Developers avoid platform APIs because the interop tax is too high. They wait for library authors to do the dirty work.</p><p>In KMP, the pattern is different:</p><ol><li>Developer needs native functionality</li><li>Writes expect fun in common code</li><li>Implements actual in platform source sets</li><li>Takes 5 minutes, zero dependencies</li></ol><p>This empowers developers to directly leverage platform capabilities. No waiting, no dependencies, no complexity.</p><h3>The Learning Curve Paradox</h3><p>Here’s something counterintuitive: KMP’s approach is <em>easier to learn</em>.</p><p>New React Native developers must understand:</p><ul><li>The bridge architecture</li><li>Native module creation</li><li>Promise-based async patterns</li><li>Platform-specific registration</li><li>Build system integration</li></ul><p>New Flutter developers must learn:</p><ul><li>Method channels vs event channels</li><li>Binary serialization</li><li>Platform channel registration</li><li>Codec configuration</li></ul><p>New KMP developers learn:</p><ul><li>expect and actual</li></ul><p>That’s it. It’s just a marker that says “this is implemented per-platform.” The actual platform code is just… platform code. If you know Android, you write Android code. If you know iOS, you write iOS code. There’s no special RN/Flutter-specific knowledge layer.</p><h3>When Libraries Still Make Sense</h3><p>To be fair, not everything should be written in-house:</p><p><strong>Complex integrations benefit from libraries:</strong></p><ul><li>Payment SDKs (Stripe, PayPal)</li><li>Analytics platforms (Firebase, Mixpanel)</li><li>Authentication providers (Auth0, OAuth)</li><li>Complex UI components</li><li>Platform-specific features with significant logic</li></ul><p>These libraries provide value beyond simple API wrapping — they handle edge cases, manage state, provide testing, and abstract away genuinely complex functionality.</p><p>But here’s the key difference: in React Native and Flutter, you need libraries for <em>trivial</em> operations because the framework makes them painful. In KMP, you only add libraries when they genuinely provide value beyond what you could easily write yourself.</p><h3>The Bottom Line</h3><p>React Native and Flutter created ecosystems where thousands of libraries exist to wrap single lines of native code. Not because developers are lazy, but because these frameworks made native interop complex enough that adding a dependency became the path of least resistance.</p><p>Think about it: a native Android developer would never use a library to check the battery level — they’d just call BatteryManagerdirectly. An iOS developer would laugh at the idea of adding a dependency to access UIDevice.batteryLevel. These are basic platform APIs that take seconds to implement.</p><p>Kotlin Multiplatform brings that same simplicity to multiplatform development. The expect/actual mechanism gives you direct platform access without bridges, channels, serialization overhead, or boilerplate. You write platform code the same way native developers do—because you <em>are</em> writing native code, just organized in a way that works across platforms.</p><p>The result? Leaner codebases, fewer dependencies, faster development, and developers who actually understand what their code is doing at the platform level.</p><p>So next time you’re building a multiplatform app and reach for a library to get the battery level, check network status, or trigger haptic feedback, ask yourself: would a native developer use a library for this? Would this be a five-line expect/actual in KMP?</p><p>The answer is probably yes. And that’s why we don’t need libraries in Kotlin Multiplatform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=298053c79a77" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Python to Kotlin: Why We Rewrote Our Scraping Framework in Kotlin]]></title>
            <link>https://nathanfallet.medium.com/from-python-to-kotlin-why-we-rewrote-our-scraping-framework-in-kotlin-aebfd69d5838?source=rss-404a540f77b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/aebfd69d5838</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-scraping]]></category>
            <dc:creator><![CDATA[Nathan Fallet]]></dc:creator>
            <pubDate>Mon, 22 Sep 2025 09:02:28 GMT</pubDate>
            <atom:updated>2025-09-22T09:02:28.365Z</atom:updated>
            <content:encoded><![CDATA[<p>When it comes to web scraping or browser automation, most people think of <strong>Python</strong>. We did too. It’s the go-to choice: widely adopted, quick to write, and supported by tons of libraries.</p><p>But using Python for a large scraping project turned out to be a mistake.</p><p><strong>What Went Wrong With Python?</strong></p><p>Although Python seems easy to write, <strong>maintaining a large codebase</strong> in it was a mess. We constantly ran into issues with typing, like the infamous:</p><p>. ‘NoneType’ object has no attribute ‘xxx’</p><p>The most painful issue, however, was related to <strong>asyncio and event loops</strong>. Part of our code needed to run on <strong>Windows </strong>(which may sound like a strange choice, but it actually helped us bypass bot detection — something far trickier on Linux).</p><p>That’s where Python’s <strong>Proactor event loop </strong>on Windows became a problem. Some system calls, even when used with async, would <strong>block the event loop entirely</strong>, tanking performance.</p><p>After spending countless hours debugging, we started questioning our choice of language.</p><p>Why not switch to something we actually <em>enjoy working with</em>? Something we already used elsewhere.</p><p><strong>Why Kotlin?</strong></p><p>All our backends and most other components were already written in <strong>Kotlin</strong>. We had even created <a href="https://github.com/guimauvedigital/zodable">zodable, a library that exports Kotlin models to Python using Pydantic</a>. But it wasn’t enough.</p><p>Typing and concurrency <strong>feel way more natural and robust</strong> in Kotlin.</p><p>Personally, I love Kotlin because it’s a language designed with <strong>safety in mind</strong>. With static typing, null safety, and now upcoming <strong>rich compile-time errors</strong>, it catches problems <em>before</em> they reach production. Most bugs are surfaced at compile time. A massive win for developer productivity and app stability.</p><p>Compare that to Python or TypeScript, where you often don’t discover issues until the code is already running (if you’re lucky enough to catch them at all).</p><p>That’s why Kotlin is now my <strong>first choice </strong>for any new project, whether it’s a backend service, mobile app, or even… a web scraper.</p><p><strong>Rewriting the Project in Kotlin</strong></p><p>So, we went all in: we <strong>rewrote everything from scratch</strong> in Kotlin.</p><p>In just <strong>five days</strong>, we ported the entire library we had in Python. The result? No more concurrency headaches, and we caught a bunch of <strong>hidden bugs</strong> thanks to Kotlin’s type safety. Bugs that were silently lurking in the Python code and would’ve only surfaced at runtime.</p><p>It was such a success that we decided to <strong>open-source</strong> the core framework: <a href="https://github.com/cdpdriver/kdriver">kdriver, a browser automation and scraping library</a>, written entirely in Kotlin.</p><p><strong>Kotlin Beyond Mobile &amp; Backend</strong></p><p>Kotlin is growing fast. It started with Android, then spread to backends with Ktor, serialization, coroutines. And now we’re seeing it expand to new domains like: <strong>AI</strong> with Koog, <strong>scraping and automation</strong> with kdriver, and much more!</p><p>I dream of a world where Kotlin is the default for every serious project, not just mobile apps. A world without JavaScript outside of browsers. A world where you don’t need to worry about NoneType errors or untyped chaos.</p><p>Just Kotlin. Clean, safe, and multiplatform.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aebfd69d5838" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I changed the way I study]]></title>
            <link>https://nathanfallet.medium.com/i-changed-the-way-i-study-317a15aff10c?source=rss-404a540f77b0------2</link>
            <guid isPermaLink="false">https://medium.com/p/317a15aff10c</guid>
            <category><![CDATA[physics]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[school-management-system]]></category>
            <category><![CDATA[application]]></category>
            <category><![CDATA[mathematics]]></category>
            <dc:creator><![CDATA[Nathan Fallet]]></dc:creator>
            <pubDate>Fri, 01 Jul 2022 12:13:43 GMT</pubDate>
            <atom:updated>2022-07-01T12:13:43.549Z</atom:updated>
            <content:encoded><![CDATA[<p>Making an app to create flashcards really helped me to learn my lessons. Discover why:</p><figure><img alt="A flashcard shown in the app" src="https://cdn-images-1.medium.com/max/1024/1*flYkayeHBw1Ac5oGaZyETw.jpeg" /></figure><h3><strong>My motivations</strong></h3><p>I am in my second year of preparatory class for the grandes écoles, MP section. The curriculum is huge, and the amount of knowledge to learn is monstrous. In particular, I had trouble with some theorems of analysis, and their hypotheses : double limit, dominated convergence theorem, term to term integration theorem, continuity of an integral with parameters, … I needed a solution in order to finally remember these theorems and their hypotheses, without which a part of the analysis exercises is unfeasible !</p><h3><strong>Different solutions which did not work</strong></h3><p>I tried different solutions in order to learn these theorems (and other definitions or formulas): revision cards on bristol sheets, as well as posters on the walls of my room, but without success. The problem was this: the theorems were right in front of me; I couldn’t tell if I knew them, and when I saw them, they were there, and they didn’t give me time to think. So I needed a way to ask myself about them, with easy access to the answer. That’s how I came up with the idea that I eventually adopted.</p><h3><strong>I imagined my own solution</strong></h3><p>I understood at that moment that the solution I needed was to learn with the help of flashcards; little cards that you turn over, with the name of the theorem on one side, and the theorem itself on the other side (hypotheses and conclusions). Being a computer and programming fan, I started to develop a small mobile application to answer this need. The first version simply contained a system to create cards and scroll to learn them. The use of the LaTeX standard allowed to format the mathematical expressions. Since then, the project has evolved a lot, the design has been refined, and practical features, such as sharing cards from one person to another, have appeared.</p><h3>Summary</h3><p>After having developed my solution to learn my lessons, I used it until the end of preparatory class, creating more than 500 flashcards covering the majority of the MP curriculum. These flashcards allowed me to constantly review my lessons, and keep the complete curriculum in mind until the end.</p><h3>On your cards, get set, go!</h3><p>After that, I published the application on the App Store in order to give access to this solution to all those who need it. I also published all my cards, although anyone can make their own.</p><p><a href="https://apps.apple.com/app/latex-cards/id1598813588">Download from the App Store</a></p><p><a href="https://play.google.com/store/apps/details?id=me.nathanfallet.latexcards">Download from the Play Store</a></p><p><a href="https://www.latexcards.app/user/Z6rqwGgWI8T3LmbjxV8g7zo59cr1">Get my cards</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=317a15aff10c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>