<?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 Olivier Revial on Medium]]></title>
        <description><![CDATA[Stories by Olivier Revial on Medium]]></description>
        <link>https://medium.com/@olivier.revial?source=rss-46610daa9e38------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IPY30u1dLhP7qxVw3KE9Tw.png</url>
            <title>Stories by Olivier Revial on Medium</title>
            <link>https://medium.com/@olivier.revial?source=rss-46610daa9e38------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:08:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@olivier.revial/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[Enhancing Flutter/Dart code quality with pre-commit hooks]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/steeple-product/enhancing-flutter-dart-code-quality-with-pre-commit-hooks-9882e55dab6c?source=rss-46610daa9e38------2"><img src="https://cdn-images-1.medium.com/max/2372/1*Ebh-Jhi4ODVgVuxV32ejJw.png" width="2372"></a></p><p class="medium-feed-snippet">On any real-world Flutter project (but any project, really&#x2026;), you want to run an analyzer and a linter at some point to ensure your&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/steeple-product/enhancing-flutter-dart-code-quality-with-pre-commit-hooks-9882e55dab6c?source=rss-46610daa9e38------2">Continue reading on Steeple-product »</a></p></div>]]></description>
            <link>https://medium.com/steeple-product/enhancing-flutter-dart-code-quality-with-pre-commit-hooks-9882e55dab6c?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/9882e55dab6c</guid>
            <category><![CDATA[bash]]></category>
            <category><![CDATA[git-hooks]]></category>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Mon, 03 Jun 2024 13:55:01 GMT</pubDate>
            <atom:updated>2024-06-03T13:55:01.179Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Flutter Connection — Paris,  2024]]></title>
            <link>https://medium.com/steeple-product/flutter-connection-paris-2024-d85e0cab886b?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/d85e0cab886b</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[conference]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Mon, 13 May 2024 09:35:16 GMT</pubDate>
            <atom:updated>2024-05-13T09:35:16.652Z</atom:updated>
            <content:encoded><![CDATA[<h3>Flutter Connection — Paris, 2024</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*41TTmttOadv1DyOJoZ_2rw.jpeg" /><figcaption>Flutter Connection — Paris, 2024</figcaption></figure><p>Thanks to my company <a href="https://www.steeple.fr/">Steeple</a> I had the chance to participate in the second edition of <a href="https://flutterconnection.io/">Flutter Connection</a> in Paris on April 24th. For those who missed it, I will here do a quick summary of the great talks I attended 📺</p><h4>How FlutterFlow generates Flutter code</h4><p><a href="https://twitter.com/LeighaJarett">Leigha Reid</a>, DevRel at FlutterFlow, had the difficult mission of opening this 2024 Flutter Connection session. In her talk, she showed us how FlutterFlow is actually generating Flutter code and how it tries to generate code that is as close as possible to “what a developer would actually write”.</p><p>From UI to state management, Leigha showed how a developer using FlutterFlow can try and write code that is quite clean by extracting pieces of code into reusable components that can be shared and reused amongst multiple FlutterFlow elements, and so on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fpF-ctVFmJyNL-uSFjV5WA.jpeg" /></figure><p>Even though I never used FlutterFlow except for a simple demo app, I can see what the benefits of using it could be for fast prototyping or even going full-production with our apps.</p><h4>Do not choose between beautiful animations and delivery !</h4><p>Ethiel Adiassa unfortunately had to cancel his talk “<em>Replaced Level Up Your Code: Demystifying Dart 3 Pattern Matching</em>” but we still had a talk at this slot. <a href="https://twitter.com/RougieuxMaxime">Maxime Rougieux</a> and <a href="https://twitter.com/CoumauThomas">Thomas Coumau</a> from <a href="https://twitter.com/bam_lab">bam_lab</a> explained us different processes for delivering animations in real-world apps. The chain of responsibility can be summed up like this :</p><blockquote>Product Owners -&gt; Design team -&gt; Development team -&gt; Animations shipped in app</blockquote><p>They then depicted a few ways of how a feature ideation can go through, and what the best scenario was in their opinion. They shared how we should maybe shift from the Most Valuable Product to the Minimum Lovable Product. Pretty fun, and interesting too.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*alwuHjKT4yGn2_CRR29IHA.jpeg" /></figure><h4>Demystifying App Architecture: The LeanCode Guide</h4><p>In this talk, <a href="https://twitter.com/matiwojt">Mateusz Wojtczak</a>, <a href="https://twitter.com/mchudy_">Marcin Chudy</a> from Poland gave us their opionionated take on how apps could be architected, the main point probably being :</p><blockquote>Be pragmatic, not dogmatic</blockquote><p>Of course they developed this and explained that every project architecture shouldn’t be adressed in the exact same way, that we should take into account other things such as technical constraints, function requirements or business constraints in order to… well, be pragramatic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6cAXo4_dvDn6AYTzeoz0VQ.jpeg" /></figure><h4>From Touch To Code: Flutter’s Gesture Mechanics</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VBTzahhkj5BlyIl-tMVLmA.jpeg" /></figure><p><a href="https://twitter.com/esrakadah">Esra Kadah</a> then gave us a quick yet very interesting of gesture mechanics, from the device touchscreens (reactive vs capacitive) up to the Flutter implementation that make gesture recognizer fight in the “Gesture arena”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yRbCXnBTuXBQx1jcZOjc6g.jpeg" /></figure><p>It was fun and helped gain knowledge on how the gesture system work in Flutter, for example that gesture deambiguation must be made for each touch/drag/whatever event, and that this happens over a certain period of time (e.g. you have to wait for 500ms or so before you can decide that a touch is actually a long tap, and not just a short tap).</p><h4>Enabling Instant Updates in Flutter Apps with Shorebird: My Journey with Code Push</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ASS8poEB_IOiMHpyNgqDnA.jpeg" /></figure><p><a href="https://twitter.com/ma_freud">Masahiro Aoki</a> talked us through his own experience of using <a href="https://shorebird.dev/">ShoreBird</a> CodePush mechanism to quickly push updates (bugfixes or features) to our installed apps without having to go through the long and sometimes painful proccess of submitting to Google Play and Apple stores.</p><p>It was really interesting because it was an honest user feedback where he explained when you should and when you shouldn’t use CodePush instead of a regular store release (e.g. native changes, change of app goal), and the different command available (patch vs release) as well as how it works (ShoreBird has made a fork of the Flutter engine).</p><h4>Server-Driven UI with Flutter</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BOuPW39E7EBEiBeg4HLu9Q.jpeg" /></figure><p>In this first talk of the afternoon, <a href="https://twitter.com/aloisdeniel">Aloïs Deniel</a> explained us his journey around Server-Driven UI with Flutter, first exploring the existing <a href="https://pub.dev/packages/rfw">rfw</a> (remote flutter widget) package that had — for him at least — too many limitations, and then talking about the <a href="https://pub.dev/packages/swap">swap plugin</a>, a Dart package he made to help with server-side UI rendering. <a href="https://pub.dev/packages/swap">His package</a> should for example simplify how the server-side code is written to use real Dart code instead of the pseudo-Dart code that <a href="https://pub.dev/packages/rfw">rfw</a> package uses today.</p><h4>Flutter Web Laughs: Element Embedding Made Easy</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*62osPrWgfigxdH-fTMmbNw.jpeg" /></figure><p>In this talk, <a href="https://twitter.com/LucasGoldner">Lucas Goldner</a> showed us how the latest versions of Flutter (since 3.7) have introduced the notion of element embedding, where a whole app can basically be embedded into any webapp, and even how they can interact together, for example sharing the counter of our well-too-famous Flutter counter app.</p><h4>Flutter Text: From Pixels to Perfection</h4><p><a href="https://twitter.com/gayuga99">Gayathri Devi Srinivasan</a> explained us a lot of things about text handling in Flutter. From the importance of always handling overlfows for various devices sizes to the importance of handling right-to-left languages when necessary or even creating dynamic lists of shorter paragraphs for very longs texts, she went through a lot of points.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V_jbSzn48vUlvbMRf77f8A.jpeg" /></figure><h4>Bring your Flutter App to the HomeScreen — HomeScreen Widgets</h4><p><a href="https://twitter.com/ABausG">Anton Borries</a> gave us an overview of his plugin <a href="https://pub.dev/packages/home_widget">home_widget</a> that aims at displaying widgets on the native Android or Apple home screen or Apple lock sreen. Note that we are not talking about Flutter widget here, but the more generic notion of smarpthone widgets.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LlZVf8788DNLOwH7XMsjDw.jpeg" /></figure><p>This plugin seems to be a great way of abstracting some native concepts by allowing to write HomeScreen widgets with a minimal of native code (but yeah, we still need to write about 10 lines of native code for each platform 😱).</p><h4>Getting Started with GenAI in Flutter Apps</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iOvXWSlQNZxIGnGscnPvSg.jpeg" /></figure><p>In this talk, <a href="https://twitter.com/elainedbatista">Elaine Dias Batista</a> talked about the various steps of using GenAI like Gemini or OpenAI APIs. From the rookie level of just using ChatGPT to the way more advanced integration of a local LLM model inside our Flutter apps, this was a very interesting overview of how AI could be integrated into our apps to create awesome dynamic content based on the user input (through AI prompts).</p><p>Key takeaway: do NOT ship your mobile apps with your AI API key but use a backend or a cloud provider instead !</p><h4>Bringing Your Flutter App to the Web</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*68-X7RuvN5EdabbsmFmNuA.jpeg" /></figure><p><a href="https://twitter.com/EglemMaxime">Maxime Eglem</a> and <a href="https://twitter.com/mikkl">Michaël Ohayon</a> talked us through their own experience of porting a mobile Flutter app to the web. In this talk they explained what were their biggest challenges as well as what what pretty easy and worked (almost) out of the box when compiling their first web version. Very instructive for anyone wanting to take the same steps !</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pb5AP91o8UXptGlY3UjBcw.jpeg" /></figure><p>And that’s a wrap! Another great day at Flutter Connection 🗼</p><p>Unfortunately I could not assist the very last talk because I had to take my train back home, but overall this was a great day, I saw some pretty great talks and it also was a good occasion to meet some Flutter folks 💙</p><p>See you around, keep fluttering!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d85e0cab886b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/steeple-product/flutter-connection-paris-2024-d85e0cab886b">Flutter Connection — Paris,  2024</a> was originally published in <a href="https://medium.com/steeple-product">Steeple-product</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mocking time in Flutter tests]]></title>
            <link>https://medium.com/steeple-product/mocking-time-in-flutter-tests-724c42a28daf?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/724c42a28daf</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[mocking]]></category>
            <category><![CDATA[dart]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Thu, 05 Oct 2023 16:53:55 GMT</pubDate>
            <atom:updated>2023-10-05T16:54:29.438Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0nf6qIvyXGw4zQnr" /><figcaption>Photo by <a href="https://unsplash.com/@loic?utm_source=medium&amp;utm_medium=referral">Djim Loic</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Usually manipulating time is a real mess when it comes to testing… but it doesn’t have to be !</p><p>Testing long running computation, mocking DateTime.now() … in this article, we’ll try and become master of time in Dart/Flutter !</p><h3>Scenario #1: long-running tests and timeout</h3><p>Sometimes you want to test for timeouts, e.g. test that the timeout is actually triggered after ‘X’ seconds. The classical scenario for this is testing that code that make HTTP calls (that we have mocked) return the appropriate error on timeout.</p><h4>The use case</h4><p>Let’s take a simple API class that makes a network call:</p><pre>class Api {<br>  final HttpClient client;<br><br>  Api(this.client);<br><br>  Future&lt;HttpClientRequest&gt; networkCall() {<br>    return client.getUrl((Uri.parse(&#39;https://example.com&#39;)));<br>  }<br>}</pre><p>And now, in some other files, we have our business logic calling this method:</p><pre>Future&lt;void&gt; longRunningComputation() {<br>  return Api(HttpClient()).networkCall().timeout(Duration(seconds: 5));<br>}</pre><p>Now, it’s very easy to test:</p><pre>test(&quot;Future.timeout() throws an error once the timeout is up&quot;, () {<br>  // mock HttpClient here<br>  <br>  expect(<br>    longRunningComputation(),<br>    throwsA(isA&lt;TimeoutException&gt;()),<br>  );<br>});</pre><h4>The problem</h4><p>While the above test is perfectly correct, its result is below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/594/1*rEO774iTC3i_HTqvdjUdlg.png" /><figcaption>Test result, the naive way</figcaption></figure><p>Can you spot the issue ? Yes, <strong>it takes the actual timeout for the test to execute</strong>, 5 seconds in our case. While this might not seem like a big issue for this single test, imagine when you have 200 tests and 10 of thems are taking 5 seconds. And then, you want to run them on your CI/CD platform each time you commit…</p><p>Remember: unit tests should always be fast (<a href="https://www.appsdeveloperblog.com/the-first-principle-in-unit-testing/">see “FIRST” unit test rule here</a>) so you do not hesitate to run them at all time.</p><h4>The solution</h4><p>What do we do then ?</p><p>Well, fear no more, we will use a very simple yet powerful package: <a href="https://pub.dev/packages/fake_async">fake_async</a>. This package will basically allow us to use our own use of time for all asynchronous operations. Let’s add it do your pubspec.yaml:</p><pre>dev_dependencies:<br>  fake_async: ^1.3.1</pre><p>Now it’s time to rewrite our initial test. We will simply wrap the test code inside a fakeAsync callback, and after that we will be able to control the time passing by calling async.elapse as we go:</p><pre>test(&quot;Future.timeout() throws an error once the timeout is up&quot;, () {<br>    // Any code run within [fakeAsync] is run within the context of the<br>    // [FakeAsync] object passed to the callback.<br>    fakeAsync((async) {<br>      // All asynchronous features that rely on timing are automatically<br>      // controlled by [fakeAsync].<br>      expect(<br>        longRunningComputation(),<br>        throwsA(isA&lt;TimeoutException&gt;()),<br>      );<br><br>      // This will cause the timeout above to fire immediately, without waiting<br>      // 5 seconds of real time.<br>      async.elapse(const Duration(seconds: 5));<br>    });<br>  });</pre><p>Let’s now re-run the test:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/594/1*tPdBDsUL1o8qP7wG6R1YUw.png" /><figcaption>Test result, the smart way</figcaption></figure><p>🤯 Did we just run the exact same test but now it took a ridiculous 17ms to execute ? Absolutely 🤩</p><h3>Scenario #2: mocking DateTime in tests</h3><p>In this second scenario we will explore how to tests methods that manipulate DateTime.now() to create or update objects.</p><h4>The usecase</h4><p>Let’s take a very basic Message class:</p><pre>class Message {<br>  final int id;<br>  final DateTime createdAt;<br>  final String content;<br><br>  Message(this.id, this.createdAt, this.content);<br><br>  @override<br>  bool operator ==(dynamic other) {<br>    return other is Message &amp;&amp;<br>        other.id == id &amp;&amp;<br>        other.createdAt == createdAt &amp;&amp;<br>        other.content == content;<br>  }<br><br>  @override<br>  int get hashCode =&gt; id.hashCode ^ createdAt.hashCode ^ content.hashCode;<br><br>  @override<br>  String toString() {<br>    return &#39;Message(id: $id, createdAt: $createdAt, content: $content)&#39;;<br>  }<br>}</pre><p>Now in this example we will use a method to generate new messages:</p><pre>Message generateMessage(int id) {<br>  return Message(id, DateTime.now(), &#39;Message $id&#39;);<br>}</pre><p>Obviously in a real-world scenario this method would be your business logic where you would do a bunch of stuff. But it doesn’t matter: what does is that we create a new random message with an id, a createdAt date that we set to the current time, and a String content.</p><p>Let’s now add a very straightforward test:</p><pre>test(&#39;message is created with current time&#39;, () {<br>  expect(<br>    generateMessage(1),<br>    Message(1, DateTime.now(), &#39;Message 1&#39;),<br>  );<br>});</pre><h4>The problem</h4><p>Here is the result of running above test:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/948/1*WLYhwn8vm9wwJcX7Rl6_wQ.png" /><figcaption>Test output</figcaption></figure><p>Yes, it fails because the message generation uses DateTime.now() to set the createdAt , but by the time we compare this in our test, time has run, event for a few milliseconds, making our test fail miserably !</p><h4>The solution</h4><p>Actually there are two solutions:</p><p><strong><em>The dirty one</em></strong></p><p>The quick and dirty way of doing this is just to forget the date in the comparison:</p><pre>test(&#39;message is created with current time&#39;, () {<br>  final message = generateMessage(1);<br><br>  expect(message.id, 1);<br>  expect(message.content, &#39;Message 1&#39;);<br>});</pre><p>While this might work, it’s suboptimal for a few reasons:</p><ul><li>the test becomes less readable because you have to test field by field.</li><li>the test becomes less maintainable because you will probably forget to add new fields comparisons as you add them to the base class.</li><li>it might now be always possible or might become hell when you need to test nested objects.</li></ul><p><strong><em>The beautiful one</em></strong></p><p>For the beautiful solution we will use a second package named <a href="https://pub.dev/packages/clock">clock</a>.</p><p>We first need to rework our production code to use clock.now() instead of DateTime.now(). It does the same work internally but also allow to replace the default clock with a fake clock in our test. We cannot mock Dart DateTime.now() directly.</p><pre>Message generateMessage(int id) {<br>  return Message(id, clock.now(), &#39;Message $id&#39;);<br>}</pre><p>Now it’s time to update our test and wrap our call with a new withClock callback:</p><pre>void main() {<br>  final fixedDate = DateTime(2023, 10, 05, 12, 00, 00);<br><br>  test(&#39;message is created with current time&#39;, () {<br>    // We create a fake clock with a fixed date that we will use later<br>    // to compare our objects<br>    final fakeClock = Clock(() =&gt; fixedDate);<br><br>    // We wrap our test in a fakeAsync to control the time in called code<br>    withClock(fakeClock, () {<br>      expect(<br>        generateMessage(1),<br>        Message(1, fixedDate, &#39;Message 1&#39;),<br>      );<br>    });<br>  });<br>}</pre><p>And now, oh joy, our test is passing!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/592/1*bUe6dL5H_0jvo8RnbaVP3g.png" /><figcaption>Passing test with our beautiful solution</figcaption></figure><p>See how easy it gets to manipulate DateTime.now() with clock ? Amazing 🪄</p><h3>Scenario #3: combining fake_async and clock</h3><p>The great thing about the two packages presented in the first two scenarios is that they work together !</p><p>What that means is that we can:</p><ol><li>Use clock.now() in our code to access current time</li><li>Use fakeAsync() callback in our tests to control this clock</li></ol><p>Let’s see that in action, shall we ?</p><p>For this scenario we will keep the example from scenario #2 where we generated messages:</p><pre>Message generateMessage(int id) {<br>  return Message(id, clock.now(), &#39;Message $id&#39;);<br>}</pre><p>We can now generate multiple messages and make sure that the createdAt date is always set to the current date:</p><pre>test(&#39;messages are created with correct time&#39;, () {<br>  // Here we use the fakeAsync callback to control the time<br>  fakeAsync(<br>    (async) {<br>      // By default the clock is the fake clock we pass as &quot;initialTIme&quot; param<br>      expect(<br>        generateMessage(1),<br>        Message(1, fixedDate, &#39;Message 1&#39;),<br>      );<br><br>      // We can elapse time and that will affect the clock used in generator<br>      async.elapse(const Duration(days: 1));<br>      expect(<br>        generateMessage(2),<br>        Message(<br>          2,<br>          // New call to clock.now() will return the new time<br>          fixedDate.add(const Duration(days: 1)),<br>          &#39;Message 2&#39;,<br>        ),<br>      );<br><br>      // We can do that as many times as we wish...<br>      async.elapse(const Duration(hours: 4));<br>      expect(<br>        generateMessage(3),<br>        Message(<br>          3,<br>          // New call to clock.now() will return the new time<br>          fixedDate.add(const Duration(days: 1, hours: 4)),<br>          &#39;Message 3&#39;,<br>        ),<br>      );<br>    },<br>    // We can set whichever fake date we want as the initial time<br>    initialTime: fixedDate,<br>  );<br>});</pre><p>Test is a success, was pretty easy to write and our head didn’t explode with boring moving DateTime…</p><p>I hope you enjoyed this article. I only covered some basics of these two packages, if you want to go deeper please check <a href="https://pub.dev/packages/fake_async">fake_async</a> and <a href="https://pub.dev/packages/clock">clock</a> packages !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=724c42a28daf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/steeple-product/mocking-time-in-flutter-tests-724c42a28daf">Mocking time in Flutter tests</a> was originally published in <a href="https://medium.com/steeple-product">Steeple-product</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to make documentation less boring ?]]></title>
            <link>https://medium.com/steeple-product/how-to-make-documentation-less-boring-ea50fcfa56fb?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea50fcfa56fb</guid>
            <category><![CDATA[documentation]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Mon, 11 Sep 2023 15:50:14 GMT</pubDate>
            <atom:updated>2023-09-11T15:50:14.847Z</atom:updated>
            <content:encoded><![CDATA[<h3>How to make documentation less boring ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3htd0nQ5hds6Chhx" /><figcaption>Photo by <a href="https://unsplash.com/@neonbrand?utm_source=medium&amp;utm_medium=referral">Kenny Eliason</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Let’s be honest, writing documentation is usually not the funniest part of our developer job.<br>In this article I will try to go through various types of documentation that a developer can write. For each documentation I will try to say what its objective is, when and how we should write it.</p><p>By the end of this article I hope you can realize that documentation is essential and maybe, just maybe, not so boring after all 😉</p><h3>🐘 The elephant in the room</h3><p>Our time is not infinite and we could write documentation forever so it is important to establish a documentation strategy to see what’s relevant for you, your company or your project. Here are a few questions that can help you decide what you need to setup:</p><ul><li>🧑‍🦱 What audience is targeted by your documentation ?</li><li>☣️ What part of your software or project is critical ? Business wise ? Technically ?</li><li>🤔 What part of your software or concept you use is hard to grasp ?</li><li>🙋 How many times did you go to Stackoverflow to get the same help for the same piece of code ?</li><li>🤯 Will you be able to understand this piece of code in a week ? A month ? A year ?</li><li>🆕 When a newcomer is joining the team, is he or she autonomous ? Can this newcomer run your app ? Easily add a test ? Contribute to your codebase ?</li></ul><h3>🤔 Documentation, who are you ?</h3><p>Let me clear something right away: there is not such thing at “a documentation”. At least not in the sense of a single, holy documentation that would be perfect. Documentation is actually made of many pieces of various types and sizes. Technical documentation, tests, code comments, user guide, … these are all ways of documenting the code!</p><p>I will now go through various kinds of documentation and explain the goal they have, the audience they are targeting and when to use it and how it can be done efficiently. My list might no be exhaustive but it depicts when I use in real-world projects.</p><h4>⚙️ Technical documentation</h4><p><strong>WHAT</strong>: Documents that help have a better understanding of the project or software. Technical documentation can include a Readme on how to setup the project, guides on how-to get started or how-to contribute to the project, architectural schemas, etc.<br><strong>WHO</strong>: You, your colleague, yourself in one year, a new developer in your team<br><strong>WHEN</strong>: Everytime something is not written or is not obvious for everyone (including a future team’s member)<br><strong>HOW</strong>: You decide. Just remember that this documentation needs to be easily accessible (easy to find) and easy to maintain so try and keep it as close to the code as possible. Actually, the closer to the code, the better. I usually store my technical documentation as Markdown files in the Git repository of the project (e.g. in the root README and then in a docs/ folder at the same level), which can make it easy to access and maintain.</p><h4>📄 Architecture Decision Records (ADR)</h4><p><strong>WHAT</strong>: Short documents on design decisions. <a href="https://adr.github.io/">ADRs</a> help version your important decisions to keep a decision log and as such are a very interesting documentation for long-term projects to avoid losing all the decisions context as we go further with our project.<br><strong>WHO</strong>: Every developer in the project, potentially a manager<br><strong>WHEN</strong>: When you are discussing important design topics with your team. E.g.: setup of a project architecture, language rewrite of your project, CI/CD workflows decisions… or any other decision that will deeply affect the software being built.<br><strong>HOW</strong>: By writing a <a href="https://adr.github.io/">small and versioned document</a> for each decision. Don’t forget to add a new ADR when a new decision makes an old one deprecated, event two years later!</p><p>Note: ADRs were featured in <a href="https://medium.com/thoughtworks.com/en-us/radar/techniques/lightweight-architecture-decision-records">ThoughWorks radar 2018</a></p><h4>🧪Automated tests</h4><p><strong>WHAT</strong>: Unit tests, acceptance tests or any other type of tests. Automated tests help in reducing regression risks and offers a way of documenting what a piece of code or software does<br><strong>WHO</strong>: Developers of the project<br><strong>WHEN</strong>: Always 🧪<br><strong>HOW</strong>: I’m sure you know, and if you don’t I strongly suggest you learn more about testing 🙂</p><h4>💬 Code comments</h4><p><strong>WHAT</strong>: Code comments.<br><strong>WHO</strong>: Your team developers for internal projects, other developers for publicly available projects<br><strong>WHEN</strong>: When a piece of code or software is hard to grasp just by reading the code. Business algorithms are usually good candidates for code comments. ⚠️ Keep in mind that code comments should be used sparingly and that most of the times <a href="https://medium.com/codex/clean-code-comments-833e11a706dc">code can be refactored to avoid comment</a>. “Don’t comment bad code: rewrite it”<br><strong>HOW</strong>: Add a comment that actually adds value to the piece of code you are commenting, don’t just paraphrase what the code does.</p><h4>🔀 Git commits</h4><p><strong>WHAT</strong>: Git commit messages can provide a very useful history of your project if they are done correctly.<br><strong>WHO</strong>: Developers and anyone interacting with your project through ticket management<br><strong>WHEN</strong>: Everytime you commit a feature or bugfix.<br><strong>HOW</strong>: In order for your commits messages to actually carry meaning, try to make a commit for a single feature or fix. Avoid commits messages like “many fixes” or “miscellaneous”, they don’t add any value. Also, you can use <a href="https://www.conventionalcommits.org/en/v1.0.0/">conventional commits</a> to carry even more meaning in your commits messages. Finally, don’t hesitate to link the task, ticket or issue that originated your development. Most ticket system (e.g. Jira, Github, GitLab, etc) offer an integration between itself and the CVS platform you use, which is very useful when you want to quickly find a commit associated with a ticket, sometimes months after your actual development.</p><h4>🗞 ️Changelogs</h4><p><strong>WHAT</strong>: Short documents describing succinctly the changes you introduced since the previous version of your software.<br><strong>WHO</strong>: Other teams in your company (for internal projects), other developers (e.g. for a public API) or even end-users for public projects like mobile applications and software.<br><strong>WHEN</strong>: Everytime you release a new version of your software<br><strong>HOW</strong>: Try do this <a href="https://github.com/marketplace/actions/git-semantic-version">automatically using conventional changelog</a> (if you used <a href="https://www.conventionalcommits.org/en/v1.0.0/">conventional commits</a> as mentionned above) to avoid doing it manually, it’s boring and usually doesn’t add much value.</p><h4>💀 Postmortems &amp; debug pointers</h4><p><strong>WHAT</strong>: Documentation that help recover from a failure and give context on why the failure might happen, and what action can be taken to avoid the failure in the future. Postmortems are a great way for your team to learn from its failures. After an incident (e.g. failed production deployment, big database issue, etc). Debug pointers are different, they help your fellow developers debug the application in case they need to investigate an issue. Both type of documentation aims at avoiding to reproduce past errors. Debug pointers might includes solutions or workarounds already tried, tries in attempting a fix that did not work, etc. It’s very useful to avoid the frustration of encountering the same bug three times and still not remembering how to fix it.<br><strong>WHO</strong>: You and your developer team.<br><strong>WHEN</strong>: Everytime an incident happen, everytime you solve an issue by applying a method that is external to the code. Note: ideally, reproducible solutions should be either fixed in the code or automated with a script to avoid doing manual steps to fix something.<br><strong>HOW</strong>: Write a small document about the incident or add info to the technical documentation on how to debug a specific piece of code.</p><h4>👥 User guide</h4><p><strong>WHAT</strong>: A comprehensive guide on how to use your application, library or software for end-users.<br><strong>WHO</strong>: End-users. An end-user can be another developer, another company or any other people using your software.<br><strong>WHEN</strong>: Before you release your software to your end-users.<br><strong>HOW</strong>: It can be an automatically generated document if you are releasing a public API, or a manual documentation on how to use the specific features of your app.</p><h3>🧳️ Final notes</h3><p>Phew 😮‍💨</p><p>We’ve now seen quite a lot of documentation types, I hope you now have a better vision of what can be done on this topic.</p><p>I will leave you with a few key points to consider when thinking about documentation:</p><ul><li>📄 Do write documentation</li><li>⏳ Try to write the documentation as you go: it’s way easier to write small chunks from time to time than writing an entire documentation set at the end of your project (it requires a lot of courage and you will have lost a lot of context by then)</li><li>🏋️ Practice. It might not be obvious at first when to write this type or this type of documentation, but as you go it will become more natural.</li><li>🧑‍💻 The closer to the code, the better. The reason is simple: it’s way easier to keep it updated, and can even be updated automatically by an IDE refactoring, which is great! Note: “close to the code” doesn’t mean that readers must clone your repo to read the docs, see point below.</li><li>🤓 Make it easy to write and easy to read. It should be easy to write simple documentation otherwise you just won’t do it: do what you’re used to, if you’re a developer, just use Markdown. It should also be easy to read, keep in mind people reading the doc won’t always an IDE or a tool for formatting Markdown: generate an HTML version of your doc if needed (CI/CD, Gitbook, etc). Which brings us to the next point…</li><li>👨‍👦‍👦 Know your audience. If your documentation reader is a developer you might be good with a Markdown readme or even unit tests but if your end-user is an app user you probably needs to generate a neat documentation!</li><li>🔢 Version your doc. Nothing to add, just do it 🙂</li><li>🔗 Help your user: cross-reference things. Reference another part of the doc, point a related piece of code, say what the user should head to after this chapter, etc. It might be clear to you how your documentation is structured but it is probably not the case for your reader.</li><li>✏️ Maintain your documentation: try spending maybe an hour a month to check if all your doc is up to date. Include this update process in your regular ticketing process to avoid the “we don’t have time” effect 😏</li></ul><h4>References</h4><ul><li><a href="https://www.shubhro.com/2020/01/06/writing-documentation-team/">Writing documentation for your team</a></li><li><a href="https://medium.com/level-up-web/best-practices-for-creating-developer-documentation-db33b741403f">Best Practices for Creating Developer Documentation</a></li><li><a href="https://medium.com/technical-writing-is-easy/developer-documentation-best-practices-3ebcf6587c11">Developer Documentation: Best Practices</a></li><li><a href="https://medium.com/illumination/four-ways-to-improve-your-companys-developer-documentation-41e87956ef38">Four Ways to Improve Your Company’s Developer Documentation</a></li><li><a href="https://devbizops.medium.com/developer-documentation-b38b92d3467d">Developer Documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea50fcfa56fb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/steeple-product/how-to-make-documentation-less-boring-ea50fcfa56fb">How to make documentation less boring ?</a> was originally published in <a href="https://medium.com/steeple-product">Steeple-product</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flutter: should we track our generated files ?]]></title>
            <link>https://medium.com/steeple-product/flutter-should-we-track-our-generated-files-b9528b907b2?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/b9528b907b2</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[codegen]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Mon, 11 Sep 2023 15:11:11 GMT</pubDate>
            <atom:updated>2023-09-11T15:11:11.233Z</atom:updated>
            <content:encoded><![CDATA[<h3>Flutter: should we track our generated files ?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FVdMbwJvE9YmcVNu" /><figcaption>Photo by <a href="https://unsplash.com/@yancymin?utm_source=medium&amp;utm_medium=referral">Yancy Min</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Starting a new Flutter project this year, my team started to track all our generated files in our Git repository.</p><p>Why you ask ? No particular reason, that’s what I always did in my previous Flutter projects, so I did it again… (oops!)</p><p>Now I have to confess, we do use code generation. A lot. <a href="https://pub.dev/packages/freezed">freezed</a>, <a href="https://pub.dev/packages/json_serializable">json_serializable</a>, <a href="https://pub.dev/packages/flutter_gen">flutter_gen</a> (for linking images statically), <a href="https://pub.dev/packages/go_router_builder">go_router_builder</a>, <a href="https://pub.dev/packages/injectable">injectable</a>, <a href="https://pub.dev/packages/flutter_localizations">flutter_localizations</a>, <a href="https://pub.dev/packages/retrofit_generator">retrofit</a>… name a codegen package, we probably use it 😀 Not that we want to look smart, but code generation has a lot of benefits: avoid writing boilerplate code, lower the risk of introducing mistakes on maintenance, make the code more robust by generating strongly typed code, etc.</p><p>But as you can guess, as our codebase is growing, so is the number of our generated files. We now generate around 200 files in many different packages (we use a <a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-series-d71b2a61b962">packages-separated Clean Architecture</a>) so eventually my colleague raised a valid question: should we continue tracking all our generated files ?</p><p>We started to debate the pros and cons, read some references on the topic (check the links at the end of this article), and what came out pretty clearly from this is that none of the solutions (tracking or not tracking) is perfect, so we tried to check which solution is best for us, at the time of writing.</p><blockquote>Tracking or not tracking, that is the question.</blockquote><h4>In favor of tracking generated files</h4><ul><li>⌛️💸 CI will take more time because each step needs to generate the files before doing its actual task (e.g. before running the tests, the analysis, the Android build, etc.). Oh and you know what ? More time = it costs more at the end of the month.</li><li>🏁 The app is not self-contained, it cannot be run right after a checkout. We cannot execute a simple flutter run to run the initial app but we first need to generate the files locally. It can be surprising to a newcomer that the app just won’t compile before taking some actions.</li></ul><h4>In favor of not tracking generated files</h4><ul><li>👀 Generated files are not meant to be edited by developers, so there is no need to track them. Conceptually, tracked files contain the business code written by the developers while generated files only contain the framework or codegen library details, which we are not really interested in. After all, we don’t commit our build folder for this reason…</li><li>🔄 It forces developers to regenerate files on each checkout otherwise it won’t compile. This could be seen as a con but we had a lot of cases where we had the compiler complaining after a checkout because the generated files were there (from our previous branch) but were not in their latest state, which can be confusing.</li><li>🤯 Avoids bloating PRs reviews: generated files are not meant to be reviewed so they should not appear in PRs. Some <a href="https://support.atlassian.com/bitbucket-cloud/docs/exclude-files-from-pull-request-diffs/">PR tooling</a> might be smart enough to exclude file patterns from any Pull Request review, but we are currently using Github and it <a href="https://stackoverflow.com/a/28703636/12138397">seems like it’s not possible</a> (yet?), unfortunately…</li></ul><p>In the end, we chose to untrack all of our generated files from our Git repository.</p><p>The main argument against untracking generated files is that it will slow down our CI, but with a better codegen configuration we can limit the build times and as our CI actions run in parallel the overall waiting time is not much longer.</p><p>Here is an example of a complete test / analyze / build with <strong>generated files tracked</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*clnzP3EkImklArdVQ50OOw.png" /></figure><p>And the same sequence where <strong>generated files are not tracked</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*pvvLaB1QY-u2lgw5cT8YsA.png" /></figure><p>While these two builds might not be fully representative of the average build time, you can see that even if each job takes longer, the overall build time is not that much longer because jobs are run in parallel.</p><h3>Final notes</h3><h4>Configuring the codegen</h4><p>We use build.yaml files in each of our packages to configure build_runner plugin for our codegen. Basically we try to tell the codegen in what folders and what files to look for a plugin codegen. Folders or files that do not match these patterns are excluded from the codegen, and it makes codegen much much faster 🏎️ Try it!</p><p>Here is an example of one of our build.yaml:</p><pre>targets:<br>  $default:<br>    builders:<br>      freezed:<br>        generate_for:<br>          - lib/models/*.entity.dart<br>        options:<br>          copyWith: false<br>          equal: false<br>          map: false<br>          when: false<br>      json_serializable:<br>        generate_for:<br>          - lib/models/*.entity.dart<br>      retrofit_generator:<br>        generate_for:<br>          - lib/api/*.dart</pre><h4>About the cost</h4><p>You might be telling yourself that we only take the time in consideration and not the cost. Actually I must confess, since we untracked the files our CI does consume more minutes (minutes are counted for each individual job), which costs more. Now a few things:</p><ol><li>Github minutes do not cost that much, in particular for a company</li><li>We optimized our CI to run only for submitted PRs when a review is asked (a feature branch does not generate CI builds if it’s in draft state or if a review has not been required yet)</li><li>If you are worried for the additional 20$/month cost of your CI, ask yourself what is the cost of a frustrated developer that has to review 3 PR a day that are all bloated with pointless generated files.</li></ol><h4>Documentation is key</h4><p>The last argument against untracking generated files is that it will be harder for newcomers to understand. To make sure they still have the info, we have documented this choice in an <a href="https://adr.github.io/">Architecture Decision Record</a> and we added a chapter on codegen in our “how to get started” guide.</p><h4>🔗 References</h4><p>To take our decision, we read the following articles or discussions:</p><ul><li>�<a href="https://pub.dev/packages/build_runner#source-control">� build_runner official recommendation</a></li><li>🧵<a href="https://www.reddit.com/r/FlutterDev/comments/kazxo0/do_you_add_gdart_files_to_gitignore/"> Reddit thread: Do your add generated Dart files to gitignore ?</a></li><li>�<a href="https://twitter.com/danlampl/status/1420659090557177859">� Twitter thread</a></li><li>📚 <a href="https://stackoverflow.com/questions/56110386/should-i-commit-generated-code-in-flutter-dart-to-vcs">Stack Overflow: Should I commit generated code in Flutter/Dart to VCS ?</a></li><li><a href="https://stackoverflow.com/questions/893913/should-i-store-generated-code-in-source-control">📚 Stack Overflow: Should I store generated code in source control ?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b9528b907b2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/steeple-product/flutter-should-we-track-our-generated-files-b9528b907b2">Flutter: should we track our generated files ?</a> was originally published in <a href="https://medium.com/steeple-product">Steeple-product</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Multi-packages Clean Architecture in Flutter — Why]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-why-fcc6d0238e72?source=rss-46610daa9e38------2"><img src="https://cdn-images-1.medium.com/max/2600/0*iz09uHQIOvvJ74IQ" width="5184"></a></p><p class="medium-feed-snippet">When I started a new project from scratch six months ago with my team, we took a few days to think how we wanted to code, how we wanted to&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-why-fcc6d0238e72?source=rss-46610daa9e38------2">Continue reading on Steeple-product »</a></p></div>]]></description>
            <link>https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-why-fcc6d0238e72?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/fcc6d0238e72</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Tue, 25 Jul 2023 11:24:31 GMT</pubDate>
            <atom:updated>2023-07-25T11:24:31.573Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Multi-packages Clean Architecture in Flutter — Presentation layer]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-presentation-layer-928ab42248fb?source=rss-46610daa9e38------2"><img src="https://cdn-images-1.medium.com/max/2600/0*vs54R9vBoG4lBhUH" width="3999"></a></p><p class="medium-feed-snippet">In the previous article, we&#x2019;ve seen an overview of our app, which looks like this:</p><p class="medium-feed-link"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-presentation-layer-928ab42248fb?source=rss-46610daa9e38------2">Continue reading on Steeple-product »</a></p></div>]]></description>
            <link>https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-presentation-layer-928ab42248fb?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/928ab42248fb</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Tue, 25 Jul 2023 11:24:23 GMT</pubDate>
            <atom:updated>2023-07-25T11:24:23.152Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Multi-packages Clean Architecture in Flutter — Domain layer]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-domain-layer-a5666b85291d?source=rss-46610daa9e38------2"><img src="https://cdn-images-1.medium.com/max/2600/0*iwaqFPuI6K9gBVb7" width="3000"></a></p><p class="medium-feed-snippet">This article is part of a series on implementing a Clean Architecture with separated packages.</p><p class="medium-feed-link"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-domain-layer-a5666b85291d?source=rss-46610daa9e38------2">Continue reading on Steeple-product »</a></p></div>]]></description>
            <link>https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-domain-layer-a5666b85291d?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5666b85291d</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Tue, 25 Jul 2023 11:24:16 GMT</pubDate>
            <atom:updated>2023-07-25T11:24:16.109Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Multi-packages Clean Architecture in Flutter — Data layer]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-data-layer-555b02243f57?source=rss-46610daa9e38------2"><img src="https://cdn-images-1.medium.com/max/2600/0*UbbGrhfivH--BcHL" width="5760"></a></p><p class="medium-feed-snippet">This article is part of a series on implementing a Clean Architecture with separated packages.</p><p class="medium-feed-link"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-data-layer-555b02243f57?source=rss-46610daa9e38------2">Continue reading on Steeple-product »</a></p></div>]]></description>
            <link>https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-data-layer-555b02243f57?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/555b02243f57</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Tue, 25 Jul 2023 11:24:08 GMT</pubDate>
            <atom:updated>2023-07-25T11:24:08.858Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Multi-packages Clean Architecture in Flutter — Orchestrating everything ]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-orchestrating-everything-f002cadf7ce?source=rss-46610daa9e38------2"><img src="https://cdn-images-1.medium.com/max/2600/0*M2TmucR14gD7lC6Z" width="5472"></a></p><p class="medium-feed-snippet">This article is part of a series on implementing a Clean Architecture with separated packages.</p><p class="medium-feed-link"><a href="https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-orchestrating-everything-f002cadf7ce?source=rss-46610daa9e38------2">Continue reading on Steeple-product »</a></p></div>]]></description>
            <link>https://medium.com/steeple-product/multi-packages-clean-architecture-in-flutter-orchestrating-everything-f002cadf7ce?source=rss-46610daa9e38------2</link>
            <guid isPermaLink="false">https://medium.com/p/f002cadf7ce</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[clean-architecture]]></category>
            <dc:creator><![CDATA[Olivier Revial]]></dc:creator>
            <pubDate>Tue, 25 Jul 2023 11:23:55 GMT</pubDate>
            <atom:updated>2023-07-25T11:23:55.233Z</atom:updated>
        </item>
    </channel>
</rss>