<?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 Martin Moizard on Medium]]></title>
        <description><![CDATA[Stories by Martin Moizard on Medium]]></description>
        <link>https://medium.com/@martinmoizard?source=rss-c7cfb459cdb7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*JipFDQieAiQciP3G0BCf5g.png</url>
            <title>Stories by Martin Moizard on Medium</title>
            <link>https://medium.com/@martinmoizard?source=rss-c7cfb459cdb7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 13:48:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@martinmoizard/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[Scaling the Internationalization Process]]></title>
            <link>https://medium.com/zenlyapp/scaling-the-internationalization-process-53e6d2ebf361?source=rss-c7cfb459cdb7------2</link>
            <guid isPermaLink="false">https://medium.com/p/53e6d2ebf361</guid>
            <category><![CDATA[i18n]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[localization]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Martin Moizard]]></dc:creator>
            <pubDate>Thu, 19 Nov 2020 12:27:47 GMT</pubDate>
            <atom:updated>2020-11-19T12:29:02.204Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Lessons from localizing Zenly for users around the world</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XlKCTpcTJghhNjxDLlZw9g.png" /></figure><p>Internationalization (i18n), the process of adapting your app to support multiple languages and regions, can be a really time-consuming process involving many different people (engineers, copywriters, translators, etc.). At Zenly, we’ve developed a number of workflows to enable us to support 30+ languages for our users all over the world. This blog post sets out the issues we faced as Zenly grew, and the tools and processes we developed along the way to help us scale our internationalization process.</p><p>If the project you’re working on grows and attracts users across many different languages, chances are you will face some of the following issues:</p><ul><li>Adding a new language/region becomes tedious: Zenly is supporting 30+ locales. As such adding/editing a translation implies editing 30+ files. 😅</li><li>Hard to know if everything in the app is translated in all of the supported languages.</li><li>Impossible to know if some translations are unused and still packaged.</li><li>Need to maintain enormous .xml (Android) or .strings (iOS) files.</li></ul><p>This post will go into detail on how we addressed each issue and built processes around it.</p><h3>Filling the gaps of the iOS platform</h3><p>Android provides a built-in way to statically reference translations keys using R.string.someKey. Out of the box, it provides a bunch of advantages:</p><ul><li>It’s impossible to point to a translation that does not exist, the compiler will output an error if you did a typo.</li><li>The IDE offers code completion even for translation keys.</li><li>And most of all, since the IDE warns you about unused symbols, you can know if one of your translation key is not used.</li></ul><p>On iOS, this is exactly the opposite. Natively, a key is referenced using a string: NSLocalizedString(&quot;someKey&quot;). As such, you can’t distinguish between a string used as a log from one used as a translation key. To fill in the gap between the Android and iOS platform, we decided to use <a href="https://github.com/mac-cain13/R.swift">R.swift</a> in our iOS project to get strong typed and autocompleted translations.</p><p>This plays perfectly well with our home made tool, let’s see how!</p><h3>Introducing Babbler</h3><p>Babbler is our internal tool that we use when dealing with Localization. It downloads all translations from PhraseApp (the external tool used to deal with translations), to create strings.xml files on Android and Localizable.strings files on iOS.</p><h3>Translated vs Untranslated</h3><p>Our project is organised in different modules, each of them containing these two files:</p><ul><li>strings_untranslated.xml (Android) or Untranslated.strings (iOS): list of keys that are not yet translated, but already used in the project.</li><li>.babbler: list of keys used in this module.</li></ul><p>Bundling those 2 files in each module allows each of our feature team to make all modules atomic and encapsulated. For instance, the “chat” module eventually contains only chat-related translations. Same for the “profile” module. In other words, it lets teams have full control and complete ownership of the translation a module contains.</p><h4>Untranslated</h4><p>Relying on an Untranslated file to define untranslated strings has many benefits:</p><ul><li>The i18n team just have to look at this file to know what’s left to be translated.</li><li>Software engineers are never blocked by the i18n team in case a translation is not ready. They can add entries to the Untranslated file whenever they want without the approval of the i18 team. This is crucial to avoid any friction and preserve developers’ velocity.</li><li>Translation strings are always referenced statically in the code source (even when not translated): with the compiler’s help, it makes it impossible to use a string that does not exist.</li></ul><p>Here is how the Untranslated file looks like in the iOS project 👇</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cfa1688f1005c71dfc33f62d9f61b586/href">https://medium.com/media/cfa1688f1005c71dfc33f62d9f61b586/href</a></iframe><h4>Translated</h4><p>Later in the process, when the i18n team is done with translating the necessary strings, only two simple things are required:</p><ul><li>Moving the key from the Untranslated file to .babbler</li><li>Running ./babbler</li></ul><p>And voilà! New translations are downloaded, linted, and dispatched to the appropriate module in the Android/iOS project.</p><h3><strong>What we love about Babbler ️♥</strong></h3><p>Babbler is a fairly lightweight tool and comes with a lot of benefits.<strong>️</strong></p><h4><strong>🔗 Ease up the translation process</strong></h4><p>Software engineers and the localization team have different processes, challenges and goals, which can make it hard for them to work together frictionlessly. To fix that, Babbler introduces a single point of contact between those two entities: the Untranslated files.</p><p>Software engineers simply add an entry in this file and, just like that, they’re done for the i18n part and can focus on other important aspects (architecture, UI design, performance, etc.). They don’t even have to agree on the new key name since the key name can easily be changed when the i18 team moves it to the .babbler file.</p><h4><strong>🦺 Safety net before the release</strong></h4><p>Checking the Untranslated files before a release is ✨golden✨. In a matter of seconds, Babbler is able to extract what is yet to be translated. The way to go is to have this step automated in the release pipeline of the CI and make the build fail if Babbler finds untranslated elements.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1eadd5982772d9fc1667aa9540da7f59/href">https://medium.com/media/1eadd5982772d9fc1667aa9540da7f59/href</a></iframe><h4><strong>📱Use the platform</strong></h4><p>We’re not reinventing the wheel: Babbler creates files that are natively supported by Android and iOS. The heavy work (resource switching based on the locale — language, region, variant — or pluralization) is consequently done by the platform.</p><h4><strong>☀️ Maintenance does not have to be painful</strong></h4><p>An application always evolves over time, so do the translations. Babbler really helps a lot to keep things simple, clean and tidy.</p><p><strong>Edition</strong>: when adding/removing a translation, only one line has to be changed in the .babbler file, then Babbler automatically updates 30+ files with the intended change.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c0a35d884b525501e544923380a3124d/href">https://medium.com/media/c0a35d884b525501e544923380a3124d/href</a></iframe><p><strong>Clean up</strong>: Since we’re not doing Over The Air translations, we don’t have to worry about breaking things in old app versions. This makes it possible to clean things up on PhraseApp side. Babbler includes a helper for the i18 team to easily know what is exported by PhraseApp but not used in the project.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8dbea5a033df44bae7fbb8d605f524b/href">https://medium.com/media/b8dbea5a033df44bae7fbb8d605f524b/href</a></iframe><p><strong>Catch recurring mistakes</strong>: Babbler analyzes the downloaded translations and runs a series of checks to catch common mistakes. This really helps us to improve the overall quality of the translations we ship. As an example, we always make sure to replace ... with the ellipsis character …. Or in French, we replace &#39; with curly apostrophe character ’.</p><p>Thanks for reading ♥️! This is some insight into our process, but it can always be improved. If you have tips on how to scale the i18n of a mobile project, we’d love to hear from you!</p><p>🍦 PS — if you love building and improving technical processes that will impact millions of users around the world, please consider checking out our current <a href="https://zen.ly/jobs">job openings</a>.</p><blockquote>Martin is an iOS Developer at Zenly. He is part of the Conversation Team, bringing joy and lots of ice cream into the chat experience for Zenly users around the world every day.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53e6d2ebf361" width="1" height="1" alt=""><hr><p><a href="https://medium.com/zenlyapp/scaling-the-internationalization-process-53e6d2ebf361">Scaling the Internationalization Process</a> was originally published in <a href="https://medium.com/zenlyapp">zenly blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hey RxSwift Observable, are you loading?]]></title>
            <link>https://medium.com/blablacar/hey-rxswift-observable-are-you-loading-cee3fb8f5440?source=rss-c7cfb459cdb7------2</link>
            <guid isPermaLink="false">https://medium.com/p/cee3fb8f5440</guid>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[reactive-programming]]></category>
            <category><![CDATA[rxswift]]></category>
            <category><![CDATA[swift]]></category>
            <dc:creator><![CDATA[Martin Moizard]]></dc:creator>
            <pubDate>Thu, 21 Jun 2018 11:39:16 GMT</pubDate>
            <atom:updated>2018-06-21T11:39:16.542Z</atom:updated>
            <content:encoded><![CDATA[<h4>Adding loading information to your RxSwift streams</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t-2ZIz86jBAiHXEB8ouYQA.png" /></figure><p>Sometimes you know a given operation is going to take a while, it can be a network call (especially on mobile, with bad network conditions), heavy image processing, or even when getting the user’s location with Core Location.</p><p>In that case, most of the time, a loader needs to be displayed somewhere on the screen.</p><p>It’s easy to design how we would displaying the loader in an imperative programming world:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a3eca52fb4f66148ef5df351aa65180/href">https://medium.com/media/4a3eca52fb4f66148ef5df351aa65180/href</a></iframe><p>However, things might be different if we try to stick with the philosophy of reactive programming:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/07a198136d94a5522863d922d9d22008/href">https://medium.com/media/07a198136d94a5522863d922d9d22008/href</a></iframe><p>How would you create an Observable&lt;Bool&gt; that emits true when the network request is in progress, and false when it finishes, just using the getMe() function?</p><h4>The Dø approach</h4><p>A first naive approach would be to use the .do() operator and hack your way into building the desired Observable&lt;Bool&gt; stream.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b38deb0899527809c38fd796e501989c/href">https://medium.com/media/b38deb0899527809c38fd796e501989c/href</a></iframe><p>Since it’s modifying the state of an external resource (here rx_isLoading), the .do() operator has a side effect. It works just fine, but wouldn’t it be better to get rid of side effects and keep working with pure streams? Yes it would!</p><h3>Introducing `.monitorLoading()`</h3><p>Recently, I thought about how to avoid any side effects from the Dø approach.</p><p>I ended up writing an extension that adds a monitorLoading() function to any ObservableType. With it, developers can compute 3 different streams by calling:</p><ul><li>.data() to return a stream emitting the final result of the operation.</li><li>.loading() to return a stream emitting a Bool to know if the operation loads or not.</li><li>.error() to return a stream emitting an Error when the operation fails.</li></ul><p>The result is elegant, and simple to use:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e8d3f779cd2e1c3fa3c3552c74e11ad/href">https://medium.com/media/1e8d3f779cd2e1c3fa3c3552c74e11ad/href</a></iframe><p>From there, its easy to know when the request loads enabling you to show or hide the loader as needed:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4a750751ea5821e808c8d34357c7dc2f/href">https://medium.com/media/4a750751ea5821e808c8d34357c7dc2f/href</a></iframe><p>Plus, the extension provides an API in case the network call failed with an error. It’s accessible by calling .error() on the result of .monitorLoading().</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b8cfbd0d85642ec510ce2248830f0f6e/href">https://medium.com/media/b8cfbd0d85642ec510ce2248830f0f6e/href</a></iframe><p>I won’t spend time on the implementation details of the .monitorLoading() extension, but here are the <a href="https://gist.github.com/MartinMoizard/c39e8d84b58fda5e7e845ca3eec385ac">results</a>, feel free to use and improve it!</p><p>Thanks for reading! If you liked what you read, feel free to share or leave a comment. You can also <a href="https://twitter.com/MartinMoizard">follow me</a> on Twitter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cee3fb8f5440" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blablacar/hey-rxswift-observable-are-you-loading-cee3fb8f5440">Hey RxSwift Observable, are you loading?</a> was originally published in <a href="https://medium.com/blablacar">BlaBlaCar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RxSwift + MVVM: how to feed ViewModels]]></title>
            <link>https://medium.com/blablacar/rxswift-mvvm-66827b8b3f10?source=rss-c7cfb459cdb7------2</link>
            <guid isPermaLink="false">https://medium.com/p/66827b8b3f10</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[mvvm]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[rxswift]]></category>
            <dc:creator><![CDATA[Martin Moizard]]></dc:creator>
            <pubDate>Wed, 27 Sep 2017 12:44:48 GMT</pubDate>
            <atom:updated>2017-09-28T09:39:48.577Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FJ1C9aXd-lo-v_c7--FEGg.png" /></figure><h3>Introduction</h3><p>It’s been almost a year since we started using RxSwift along the Model-View-ViewModel (MVVM) architecture at BlaBlaCar. We’re thrilled with the results. The code we’re writing with this approach is much easier to understand, maintain, test and scale. However, the first weeks were not a piece of cake: we had to iterate on some aspects of our MVVM+RxSwift architecture to get things right. One of them is the way Inputs are provided to ViewModels.</p><p>Let’s go through two different approaches to providing inputs (Rx Events) to ViewModels.</p><p>But first, let’s quickly talk about ViewModels.</p><h4>ViewModels</h4><p>The public contract of a ViewModel is very important. You have to get it right (for more than one reason):</p><ul><li>It should be pluggable on any View, i.e. it is not the way a View is built that is going to define the public contract of a ViewModel. As a reminder, it’s the View that owns the ViewModel. In other words, the View is aware of the ViewModel, not the other way around.</li><li>It should be testable. In the end, one of the biggest benefits of the MVVM architecture is to make the business logic testable.</li><li>MVVM is 💪 with binding mechanisms so let’s leverage that with RxSwift.</li></ul><p>A rule of thumb when designing a ViewModel contract is to always try to conceive the ViewModel as a simple black box that accepts inputs in order to produce outputs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*iaqAvfM04KSIYyEe2UyODw.png" /></figure><p>Talking Rx, it means the ViewModel consumes Events (inputs) from some Streams (most of the time provided by the View) to compute output Streams (for the View).</p><p>From there, a simple protocol can be written to express that any ViewModel should have Inputs and Outputs.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ec3f022232deef91d585717f51ffe912/href">https://medium.com/media/ec3f022232deef91d585717f51ffe912/href</a></iframe><p>Next up, 2 different implementations of this protocol, each with their own pros and cons.</p><h3>Providing inputs to ViewModels</h3><p>Erik Meijer, creator of Rx, likes to think in a purely functional way. From there, and considering that Subjects are the mutable parts of Rx, it’s no surprise to find <a href="http://davesexton.com/blog/post/To-Use-Subject-Or-Not-To-Use-Subject.aspx">resources</a> quoting E. Meijer saying that using them could be wrong, and that in most cases it’s possible to avoid them.</p><p>This is why we started by avoiding using Subjects when designing ViewModels.</p><h4>First approach — without Subjects</h4><p>Like I said, ViewModels are all about transforming Inputs into Outputs. Let’s add that to our ViewModelType protocol:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/309c8f7988b50ee28da2edbbf593a9de/href">https://medium.com/media/309c8f7988b50ee28da2edbbf593a9de/href</a></iframe><p>This makes it clear that at some point, the View has to provide all the Inputs (at the same time, we’ll get back to that) to the ViewModel to let it compute the Outputs.</p><p>Using this pattern, let’s try to build a simple View that requests the user to type in his name, and hit a button in order to display some greetings:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*SqFWbQ0oAXv0ZSJip2rR5w.gif" /></figure><p>Now let’s think about the Inputs and Outputs of the ViewModel. This ViewModel, let’s call it SayHelloViewModel needs to know when the user presses on the “Validate” button, and also what the user entered in the UITextField. Those 2 things are going to be the Inputs.</p><p>Concerning Outputs, we’ll only have one, the one that tells what to display to greet the user.</p><p>Here’s the implementation:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/05e8361b06629aa2caf865e9011d7aa5/href">https://medium.com/media/05e8361b06629aa2caf865e9011d7aa5/href</a></iframe><p>The greeting output stream is computed as follows: when “Validate” is hit, we take the last value of the input text field to create the Hello \(name) string.</p><p>Now let’s see how the View (here a UIViewController to make things simpler) plays with this ViewModel.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0daef12b6e3d662cf2fe709782758417/href">https://medium.com/media/0daef12b6e3d662cf2fe709782758417/href</a></iframe><p>We rely on RxCocoa to get the stream of what’s being entered in the UITextField<em> </em>name<em> </em>and to know when the button is tapped. With those two streams it’s easy to create a SayHelloViewModel.Input instance, pass it on to the ViewModel, and get the outputs. From there, the View is working as expected 💪!</p><p>Earlier, we mentioned the fact that a ViewModel “should be pluggable on any View”. Let’s see if we can use SayHelloViewModel with another View. This time we’ll build a view using a UITableView.</p><p>The same view based on a UITableView looks like this:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9aba5d69c2ed5cd23abd47ac5f7edcc1/href">https://medium.com/media/9aba5d69c2ed5cd23abd47ac5f7edcc1/href</a></iframe><p>Now that the View is based on a UITableView, we have 3 custom UITableViewCells: one for the text field, one for the validate button and the last one for the label.</p><p>At this point, and after conforming to UITableViewDataSource, it should just take a few minutes to write bindViewModel() and be iso with the previous version.</p><p>But wait! Now that we’re using a UITableView, the content of the view is lazily loaded and displayed. There’s no way to synchronously get (at the same time) a reference on the text field and the button. In other words, we can’t create an instance of SayHelloViewModel.Input<em> </em>😢.</p><p>Using a func transform(input: Input) -&gt; Output function is simple, clean and there’s no need to use Subjects but it also has limitations. A ViewModel with such an interface will only work with Views that are able to gather <strong>at the same time</strong> all the resources needed to create the ViewModel’s Input.</p><p>That’s when, in my opinion, it’s totally acceptable to start using Subjects to design ViewModels that are compatible with any View.</p><h4>Second approach — with Subjects</h4><p>Now that we know it’s not always possible to provide all ViewModel’s inputs at a given time, we need to modify the ViewModelType protocol to make it more flexible. Let’s just expose 2 properties, one for Inputs, the other for Outputs.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b39c9b555e222305e754aa0a3b917ee4/href">https://medium.com/media/b39c9b555e222305e754aa0a3b917ee4/href</a></iframe><p>This way, the View is completely free to decide when to provide Inputs, and when to subscribe for Outputs.</p><p>In the first half of this article, we used the transform function to create the link between Inputs and Outputs. We still need to create that link, and that’s where Subjects come into play.</p><p>A Subject<em> </em>is a kind of bridge that acts both as an Observer and an Observable<em>.</em> It is a good solution to move from the imperative programming world into the functional world of Rx.</p><p>Knowing that our ViewModel has 2 inputs (the name text field and the validate button), we’ll need 2 Subjects. From there, it is easy to migrate the ViewModel implementation of the previous chapter to conform to the new ViewModelType protocol.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4587932756c459c2c20754e2a719b8fb/href">https://medium.com/media/4587932756c459c2c20754e2a719b8fb/href</a></iframe><p>A few interesting things to note here:</p><ul><li>The complex part of the ViewModel (computing Outputs), does not change.</li><li>Subjects are private. There’s no way to hack the ViewModel, the only way to interact with the ViewModel is through the public input<em> </em>and output properties.</li><li>This implementation respects all requirements listed at the beginning of the article: it is pluggable on any view, easily unit testable and compatible with Rx bindings.</li></ul><p>You can check out the <a href="https://gist.github.com/MartinMoizard/449be0d30920010210988f1773a2ca90">final implementation</a> of the View based on a UITableView<em> </em>that uses this ViewModel.</p><h3>Wrapping up</h3><p>The two approaches described in this article are compatible with each other and can both be used in the same project. However, it’s clear that sometimes the first approach does not work with some kinds of views. This limitation is not always clear when getting familiar with MVVM and Reactive programming, and I hope this article is going to help you in your upcoming projects.</p><p>You can also <a href="https://github.com/kickstarter/ios-oss/tree/master/Library/ViewModels">check out</a> how Kickstarter design their ViewModels. They create a bridge between Inputs and Outputs using ReactiveSwift’s Property. It’s very similar to what we did at BlaBlaCar using Subjects: they keep this Property private and build all the Outputs in the ViewModel’s initializer.</p><p>Thanks for reading! If you liked what you read, feel free to share or leave a comment. You can also <a href="https://twitter.com/MartinMoizard">follow me on Twitter.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=66827b8b3f10" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blablacar/rxswift-mvvm-66827b8b3f10">RxSwift + MVVM: how to feed ViewModels</a> was originally published in <a href="https://medium.com/blablacar">BlaBlaCar</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>