<?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 Rodrigue Alcazar on Medium]]></title>
        <description><![CDATA[Stories by Rodrigue Alcazar on Medium]]></description>
        <link>https://medium.com/@rodriguealcazar?source=rss-350d9660b566------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ie7GSvS-eN0raRjCUC0bHg.jpeg</url>
            <title>Stories by Rodrigue Alcazar on Medium</title>
            <link>https://medium.com/@rodriguealcazar?source=rss-350d9660b566------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 09:55:03 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rodriguealcazar/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[San Silvestre Vallecana 2024]]></title>
            <link>https://medium.com/@rodriguealcazar/san-silvestre-vallecana-2024-6f3fa1e161f9?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/6f3fa1e161f9</guid>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Wed, 01 Jan 2025 14:21:04 GMT</pubDate>
            <atom:updated>2025-01-01T20:51:39.371Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*JI6jd_uVnCE6SUUOT0zUOQ.png" /></figure><p>J’éponge mon front puis lève le regard. Devant moi s’etale une marée jaune qui coule le long de l’avenue. Encadrée d’une foule de spectateurs, la masse des coureurs s’étire en frémissant le long de la chaussée qui monte en ligne droite, jusqu’à se perdre au loin. Me voila au pied de l’Albufera. “Ralenti. Garde des forces pour la montée.”: elle occupe mes pensées depuis le départ. Depuis que je suis sorti de chez moi même.</p><p>C’était il y a une heure environ. Les participants se reconnaissaient facilement dans le métro: chaussures de course aux pieds et maillot jaune officiel sur le dos. Aux abords du stade c’était la cohue. On cherche un ami, on s’échauffe, on s’alimente, on s’encourage. Puis on se dirige vers son enclos. Il ne reste que quelques minutes avant que les 8000 coureurs de notre vague ne soient libérés. Quelques derniers sautillements pour rester chaud. Une pensée pour ce ciel bleu et ce soleil dont les rayons effacent la froideur de l’air. Puis enfin on s’élance.</p><p>Sur Concha Espina ça monte dès les premiers mètres. Comme souvent au départ, il faut se frayer un passage à travers la foule, changer de couloir, de direction, de vitesse, accélérer, décélérer à la recherche d’un peu d’espace. Et garder un œil sur le lièvre, pour être dans les temps. Un premier virage, quelques passages étroits fermés par des barrières et une première descente. Je me rends compte qu’il y a plus de monde devant moi que ce que je pensais. J’aurais dû m’approcher plus de la ligne de départ mais c’est trop tard. “C’est comme ça. Profite.”</p><p>Finalement, assez d’espace pour pouvoir garder un rythme régulier. Maintenant il faut gérer. Les encouragements de la foule autour de nous; le battement frénétique de centaines de pas sur l’asphalte; l’excitation: difficile de ne pas aller trop vite. Il faut se caler sur sa respiration, lever les pieds, se tenir droit. Après quelques kilomètres, le souffle se fait court. Le lièvre est proche. A la prochaine descente, récupérer. Sur Serrano, la foule est dense. On descend vers Cibeles sous le bruit des encouragements. Je passe le lièvre. Ne pas aller trop vite. Savoir jusqu’où se faire mal.</p><p>On passe Atocha vers la dernière vraie descente. La foule est là aussi alors qu’on entre dans mon quartier. C’est dur mais le cœur est léger. La flamme des 7km est passée. La dernière fois, je m’étais arrêté là, boitillant, pour ménager une blessure. Quelle chance de pouvoir continuer cette année. Plus qu’un obstacle.</p><p>Environ 1km de montée. Je ralentit. Je cherche mon souffle. Des coureurs que j’ai dépassé me dépassent à leur tour. Mais feu après feu on s’approche — “Plus que 4” j’entends crier. Autour les visages souffrent. On est seul mais ensemble. On voudrait s’encourager mais c’est dur. Maintenant, ça se joue dans la tête. “Saloperie d’Albufera.”. Ne pas s’arrêter. Le lièvre est toujours derrière.</p><p>Enfin on tourne à droite, quitte l’avenue et ça redevient plat. Et voilà le dernier kilomètre. Impossible d’accélérer, il faut juste terminer. Un dernier virage et c’est la ligne d’arrivée. On vérifie le chrono: objectif atteint. Et alors que le soleil se couche dans un ciel orangé typique de Madrid, on se dit que ça valait le coup. C’est vraiment une belle course.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f3fa1e161f9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Green Software for practitioners]]></title>
            <link>https://medium.com/@rodriguealcazar/green-software-for-practitioners-342c8d87ef5?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/342c8d87ef5</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[green-software]]></category>
            <category><![CDATA[green-software-foundation]]></category>
            <category><![CDATA[climate-change]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Mon, 06 Mar 2023 21:44:16 GMT</pubDate>
            <atom:updated>2023-03-07T10:00:39.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M9nSmsiVG4FekyXeAc3jcg.png" /></figure><p>In the last few months I have been looking closely into the <em>Green Software </em>movement. While still in its early days, common concepts, practices, and tools are starting to consolidate and some people are already using those “in real life”. The concept has even travelled beyond the sphere of engineering to reach that of business, as evidenced by <a href="https://www.forbes.com/sites/sylvainduranton/2023/02/27/green-it-is-no-longer-an-option-for-the-tech-sector/">a recent opinion piece in Forbes</a>.</p><p>The largest and better organised champion behind the sustainable software approach is probably <a href="https://greensoftware.foundation/">the Green Software Foundation</a> (GSF). Curious about their approach I decided to take their <a href="https://trainingportal.linuxfoundation.org/courses/green-software-for-practitioners-lfc131">Green Software For Practitioners course</a> a few weeks ago. Here, I wanted to write down a summary of a course I found, overall, fairly well designed.</p><h4>Green software you say?</h4><p>To start with, the course explains what the GSF means by <em>Green Software</em>:</p><blockquote>Green software is carbon-efficient software, meaning it emits the least carbon possible.</blockquote><p>and</p><blockquote>Green software is an emerging discipline at the intersection of climate science, software design, electricity markets, hardware, and data center design.</blockquote><p>In essence, the whole premise of <em>Green Software</em> is to reduce the amount of greenhouse gas emissions that software generates. This makes a lot of sense to me and is something that I think should be much higher on any organisation’s priority list.</p><p>The rest of the course then dives into each of the 6 core principles of <em>Green Software</em>, namely:</p><ol><li><strong>Carbon Efficiency</strong>: Emit the least amount of carbon possible.</li><li><strong>Energy Efficiency</strong>: Use the least amount of energy possible.</li><li><strong>Carbon Awareness</strong>: Do more when the electricity is cleaner and do less when the electricity is dirtier.</li><li><strong>Hardware Efficiency</strong>: Use the least amount of embodied carbon possible.</li><li><strong>Measurement</strong>: What you can’t measure, you can’t improve.</li><li><strong>Climate Commitments</strong>: Understand the exact mechanism of carbon reduction.</li></ol><p>I won’t go into more details as the course itself is easy and quick to read and digest. I wanted, however, to highlight a few points that I found quite positive about this course.</p><p>First, they make no assumptions on the level of knowledge about climate change that the reader might have. They present, clearly and succintly, basic concepts like climate vs. weather, the greenhouse effect, or the IPCC and its work. It gives a clear framework within which to think about the impact of software on climate change.</p><p>Second, they also talk about more advanced topics like marginal carbon intensity, the GHG protocol and energy markets. While probably quite new to most readers, these concepts are central to corporate ESG efforts and important if you want to approach emissions reduction in a profesional context.</p><p>Last, but certainly not least, they do not shy away from the reality of the problem and avoid advocating any greenwashing approach. The goal is to reduce the CO2eq emissions of software, for real.</p><p>This is clear from <a href="https://github.com/Green-Software-Foundation/sci/blob/main/Software_Carbon_Intensity/Software_Carbon_Intensity_Specification.md">the Software Carbon Intensity specification</a> (SCI) that the GSF have defined. It was designed so that the SCI score can only be improved by reducing emissions. In other terms, if you follow the specification, no amount of compensation or removal, a.k.a. offset, can make your software green.</p><h4>How do I do it?</h4><p>It is important to note that while the course does a great job at explaining what <em>Green Software</em> is, it stays at a high level and doesn’t explain how we can apply those principles in our day to day work. There is no list of tools or practices that we can use to measure or reduce the carbon intensity of a piece of code. Some tools exists out there but the reality is that measuring the carbon intensity of an application is still complex and often approximate.</p><p>Still, the GSF provides two case studies of organisations that are actually using some of the principles presented in the course. First, UBS in collaboration with Microsoft have started implementing <a href="https://greensoftware.foundation/articles/carbon-aware-computing-whitepaper-how-ubs-succeeded-in-measuring-and-reducing-car">a carbon-aware solution on one of their risk platforms</a>. Then Accenture who have <a href="https://greensoftware.foundation/articles/how-accenture-implemented-the-sci-specification-score-to-track-software-emissions">implemented the SCI specification for an application stack of reference</a> (a microservices backend for a mobile and web application).</p><h4>So?</h4><p>I would definitely recommend spending a couple of hours to go through that course as it gives a great overview of how to reason about GHG emissions from software. It also gives a very structured and coherent approach to the problem of reducing them. It should set people up effectively for starting their journey towards <em>Green Software</em>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=342c8d87ef5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Green software engineering and cognitive disonance]]></title>
            <link>https://medium.com/@rodriguealcazar/when-i-came-across-sustainable-software-engineering-c4b92b9e162a?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4b92b9e162a</guid>
            <category><![CDATA[green-software]]></category>
            <category><![CDATA[sustainable-software]]></category>
            <category><![CDATA[limits-to-growth]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Sun, 20 Nov 2022 18:54:40 GMT</pubDate>
            <atom:updated>2022-11-21T10:18:50.971Z</atom:updated>
            <content:encoded><![CDATA[<p>I recently discovered that a <em>sustainable software </em>movement (for lack of a better word) has been slowly developing in the tech industry. More and more people are aware of the disastrous consequences of climate change — in part because of the intense and dramatic examples we’ve already been faced with. From my experience, however, not many technology workers (software engineers, data scientists, product managers, CPOs/CTOs, …) are aware of the impact our industry has on global emissions. It is then no surprise that the drivers and measures of improvement are usually “more”, “faster”, “cheaper” rather than “sustainable”. Yet some individuals have started developing and advocating ways for software engineering to reduce its carbon footprint. And it seems that a few (large) companies have started to join the initiative.</p><p>One of them is Thoughtworks. I was recently browsing their content on the topic and came across <a href="https://www.thoughtworks.com/insights/podcasts/technology-podcasts/green-software-engineering">an interesting episode of their technology podcast on green software engineering</a>. The discussion does not focus on how to run your software in a “green” way (something they call <a href="https://www.thoughtworks.com/insights/podcasts/technology-podcasts/how-green-cloud"><em>green cloud</em></a>) but rather on how to write it with energy efficiency in mind. There are some interesting ideas and points being discussed during the conversation. Yet towards the end I was suddenly hit with strong cognitive dissonance with what was being said.</p><p>I fully agreed as “doing the right thing” was mentioned several times as a motivation in itself for building sustainable software. Then, at the end of the conversation, they ask themselves:</p><blockquote>…, if and when we get to this carbon neutral net zero future, will we still even care about this?</blockquote><p>This is where I started feeling a bit disheartened.</p><p>To me the answer is a resounding “of course”. Asking this suggests to me that the speakers are falling prey to what I think are two common misconceptions about our situation. First, that this is a crisis we need to solve before going back to some normality. Second, that the world we’ve been building is sustainable —if only in terms of energy and natural resources consumption.</p><p>Thinking that there is, around the corner, a future of continued growth where energy efficiency will be mostly driven by cost reduction is, in my opinion, mislead — and not only in software. The idea here seems to be that we need to make our software energy efficient while we transition our energy production and that once we’re carbon neutral globally it won’t matter because all the extra energy we use will be green. Unfortunately, I believe that this widespread view ignores the physical reality of our planet.</p><p>Realistic energy transition scenarios include a reduction in the overall energy consumption globally. Why? Because producing as much energy as we currently consume (a quantity that has yet to stop growing) with renewables only is physically impossible: not enough natural resources, not enough land, not enough time, not enough money, not enough qualified profesionals, … . Even if we didn’t care about the climate, fossil fuels will not be available for ever which would inevitably affect our ability to “build stuff”. And finally, we know that <a href="https://en.wikipedia.org/wiki/The_Limits_to_Growth">we can’t be growing indefinitely in a world that has limits</a>, regardless of whether our energy affects the climate.</p><p>Overall, I’m happy that initiatives like sustainable software have appeared and that a company like Thoughtworks dedicates people to the topic. The radical (or realist) in me would argue that we should simply stop building unnecessary technological products simply because we can. Indeed, there is no cleaner energy than the one we don’t use. Yet, the pragmatist in me knows that we are far away from that paradigm shift and that we therefore need to start with improving the existing model.</p><p>As the emissions from IT keep on growing, any reduction we can gain in the area of software will be useful and engineers need to become aware of this topic, even if it is still immature. And those interested in the bigger problem need to also play the long game and keep disseminating the ideas that will support a sustainable humanity.</p><p>Some very interesting points are being discussed in the podcast: motivation in the first place; difficulty of measuring improvements; counter-intuitive relation between energy efficiency and performance; tradeoffs between energy spent optimising and energy gained. Food for thought as I continue my exploration of those topics.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4b92b9e162a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Pragmatic Programmer, 20th Anniversary Edition]]></title>
            <link>https://medium.com/@rodriguealcazar/the-pragmatic-programmer-20th-anniversary-edition-6e6659df8111?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/6e6659df8111</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[pragmatic-programming]]></category>
            <category><![CDATA[book-recommendations]]></category>
            <category><![CDATA[book-review]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Sun, 07 Jun 2020 13:38:16 GMT</pubDate>
            <atom:updated>2020-06-07T13:38:55.448Z</atom:updated>
            <content:encoded><![CDATA[<p>Just before the confinement, I read the <a href="https://pragprog.com/book/tpp20/the-pragmatic-programmer-20th-anniversary-edition">20th Anniversary edition of The Pragmatic Programmer</a> and wanted to write down some notes and impressions. I really enjoyed reading it, the same way I enjoyed reading the original edition, at the beginning of my software engineer career, sometime in 2007. At the time, I found the content and tone really engaging, and the topics have since proved really relevant to everyday life as a professional developer - I wasn’t surprised to see it recently feature at #1 in a <a href="https://threadreaderapp.com/thread/1229731043332231169.html">“meta” list of most recommended programming books</a>.</p><p>So, when I heard about the new edition I asked <a href="https://www.lingokids.com/">at work</a> if we could get a copy for the office. I was excited not only to refresh my memory but also to discover all the updates that Andy and Dave had made to the original material. And an updated edition it certainly is, as stated in the preface:</p><blockquote>Roughly one third of the topics in the book are brand new. Of the rest, the majority have been rewritten, either partially or totally. Our intent was to make things clearer, more relevant, and hopefully somewhat timeless.</blockquote><p>The book is divided in 9 parts. It starts with laying down the foundational ideas in part 1 and ends with applying them to an entire team in part 9. Each part is then broken down in several self-contained topics each of which contains an explanation, some examples of how it applies (illustrative or real) and short exercises/challenges. The sections are not necessarily intended to be read in order from beginning to end (which is how I read them though). Some topics also come with a short tip that emphasizes the point being made. These are very valuable in their own right and are even available as a pull-out card at the end of the book.</p><p>The preface already sets the tone with the first two simple tips which are at the core of the Pragmatic approach described afterwards:</p><blockquote>Care about your craft.</blockquote><p>and</p><blockquote>Think about your work.</blockquote><p>And to help you do that every day, they advise you to be:</p><ul><li>an early adopter / fast adapter</li><li>inquisitive</li><li>a critical thinker</li><li>realistic</li><li>a jack of all trades</li></ul><p>These principles form the basis of the Pragmatic Philosophy which to me can be summarized as approaching software development as a craft: with professionalism, diligence (this is not a hobby) and pragmatism (this is not art). You are personally responsible for performing the best job you can, for constantly trying to improve yourself, for being a dependable collaborator, and for fostering quality around you (in software and in people).</p><p>The rest of the book touches on a wide variety of subject: mastering your everyday tools (which back in 2007 motivated me to learn touch typing); design — Easy To Change (ETC) being the foundation of good design; prototyping and iterating; debugging; the dangers of inheritance; refactoring — and software rot as an earlier and more accurate analogy for technical debt; communication; concurrency; requirements; estimation; …</p><p>Every section and tip is to the point and clearly applicable with a clear rationale for why it matters — at least from the point of view of the authors. 13 years later, following a lot of evolution in the software development world and a lot of personal evolution as a software developer, I have really enjoyed the refresher — some valuable principles I feel I need to remember applying again — and the new material. I would definitely recommend this book to current junior developers around me as well as to more seasoned ones.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6e6659df8111" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running in Google Code Jam 2020 — Qualification round]]></title>
            <link>https://medium.com/@rodriguealcazar/running-in-google-code-jam-2020-qualification-round-dc98187e2891?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc98187e2891</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[google-code-jam]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Sun, 05 Apr 2020 17:26:20 GMT</pubDate>
            <atom:updated>2020-04-06T08:09:03.107Z</atom:updated>
            <content:encoded><![CDATA[<h3>Running in Google Code Jam 2020 — Qualification round</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-Go3xEFpxdTZgC9T" /><figcaption>Photo by <a href="https://unsplash.com/@codestorm?utm_source=medium&amp;utm_medium=referral">Safar Safarov</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>The context</h3><p>This year, I have finally managed to take part in <a href="https://codingcompetitions.withgoogle.com/codejam/">Google Code Jam</a> again, after a 4 years hiatus. After running a few years in a row, I had then missed it for either forgetting to sign up, signing up but forgetting the date, or signing up and having other obligations on the day. And this year I got very close to missing it again: while I thought the qualification round lasted 48 hours, I realised yesterday at 9pm that it actually runs for 24 hours only. With about 6 hours left, I decided to give it a go anyway.</p><p>I am not by any means a specialist of this type of competitions and algorithmic problems. Google Code Jam is the only one I have ever tried and I have always failed at either the qualification round or the 1st round. Still, the problem statements are usually original and entertaining and I find it fun to spend a few hours thinking about algorithms and data structures. Also, I always participate using Python and given it hasn’t been my main professional languages for several years, it is also a chance to write a bit of Python — and to browse <a href="https://docs.python.org/3.5/">the online documentation</a> for embarrassingly trivial things.</p><h3>The problems</h3><p>This year, <a href="https://codingcompetitions.withgoogle.com/codejam/round/000000000019fd27">the qualification round</a> had 5 problems that awarded a total of 100 points from which you needed to earn at least 30 points to qualify for the next round. I solved the first three problems and got 42 points, submitting my last answer about 20 minutes before the deadline.</p><h4><a href="https://codingcompetitions.withgoogle.com/codejam/round/000000000019fd27/000000000020993c">Vestigium</a></h4><p>Given a square matrix of natural integers, you had to calculate its trace, i.e. the sum of the numbers in its diagonal, and the number of rows and columns with duplicates.</p><p>From my experience, Google Code Jam made you run your solution through a small and then a large input and you had a limited amount of time to submit the output — more on this later. A couple of times in the past, my solution worked for the small input but was too slow for the large input. With that in mind, I spent a bit of time trying to come up with a way of avoiding iterating through every cell of the matrix. However, what I could think of would require complicated logic so I decided to go for <a href="https://github.com/rodriguealcazar/google-code-jam/blob/master/2020/qualification/vestigium/Solution.py">a simple solution that looks at one cell after the other, row after row</a>.</p><p>Calculating the trace is fairly simple while iterating that way. To figure whether there are duplicates, for each row I add the elements to a set and at the end of the row I check if the length of the set is smaller than the length of the row. In a dictionary I also keep a set for every column, sets that I populate as I’m iterating through the cells so that I only need a single pass through the matrix. At the end of the iteration, I check the size of all the column sets to see which had duplicates.</p><h4><a href="https://codingcompetitions.withgoogle.com/codejam/round/000000000019fd27/0000000000209a9f">Nesting Depth</a></h4><p>Given a list of integers, you have to wrap them in opening and closing parentheses in such a way that all parentheses are balanced and that each digit d is enclosed in exactly d parentheses.</p><p><a href="https://github.com/rodriguealcazar/google-code-jam/blob/master/2020/qualification/nestingDepths/Solution.py">The solution that quickly came to my mind</a> was to start iterating the integers while keeping track of the number of unmatched open parentheses (starting at 0). If the number of open parentheses is smaller than the current digit, we add the number required and increase the counter; if the number of open parentheses is greater than the current digit, we add the number of required closing parentheses and decrease the counter. At the end we add as many closing parentheses as the final value of the counter.</p><h4><a href="https://codingcompetitions.withgoogle.com/codejam/round/000000000019fd27/000000000020bdf9">Parenting Partnering Returns</a></h4><p>Given a list of tasks represented by their start and end time, and two people Cameron and Jamie, you have to assign each task to one or the other given that each can only be assigned to one task at a time. It could be that assigning all tasks without overlap isn’t possible.</p><p><a href="https://github.com/rodriguealcazar/google-code-jam/blob/master/2020/qualification/parenting/solution.py">The approach I thought of</a> was to sort the tasks by increasing start time, iterate over them, and assign each to Cameron or Jamie if one of them is free. Assigning a task means marking the person as busy until the end time of the task. If neither is free for the current task then the assignment is impossible.</p><h3>Approach</h3><p>From this qualification round and my previous experience, I can see a pattern emerging in the way I approach and try to solve these problems.</p><p>First, I read carefully the problem statement. Aside from the story telling is a lot of information you need to take into account: assumptions, potential edge cases, ranges of input values, … . Often, a detail in the requirements will make an approach invalid, or the opposite.</p><p>After that, I look at the input/ouput sample provided. Beside helping me verify my understanding of the input format, they are the first test cases that drive my reasoning and help me verify my solution. Usually, there is a simple test case and I usually try solving it with pen and paper. This helps me think and understand what information I need to keep track of and whether my approach works. Starting with a single test case also helps me organize the code: I usually create a simple function that takes the parsed test case (usually some sort of collection) as parameter and returns what is required to print the output.</p><p>The other test cases are usually a bit more complex and/or illustrate an edge case. They are very useful to verify that my solution works for less trivial cases. Finally, I want to test that the output my solution returns is in the right format as the submission will fail if you do not respect the described output format. The sample output is useful for that.</p><p>At that point, I try to think of edge cases that I haven’t covered yet with the goal of testing my logic and the complexity of my solution. This is where I might try to optimize my logic if I have ended up with something that I see will very quickly become too slow.</p><p>Finally, I test my end-to-end solution with the full sample input to make sure the whole program works: parsing of input, logic, printing of solution.</p><h3>Lessons</h3><p>From yesterday’s session, I have come up with a few simple lessons that I hope I will keep in mind for future sessions.</p><p>The first one is obvious and embarrassing but something I should have really done first: read the instructions. I started writing a solution that took a file path as parameter and read the input from the file. In previous versions of Google Code Jam, it made sense as you had to download input from their website. However, it turned out that <a href="https://codingcompetitions.withgoogle.com/codejam/faq#coding">in 2017 they changed the format and your solution now needs to read input from STDIN</a>. It is only when I first tried to submit my solution that I realized something was different and had to go read the instructions.</p><p>The next lesson is related and is to know how your solution will be executed. I almost gave up on the first problem after receiving <a href="https://codingcompetitions.withgoogle.com/codejam/faq#submitting">Runtime Errors</a> to all my test submissions while my program worked locally. After digging more into the instructions, I learnt that <a href="https://codingcompetitions.withgoogle.com/codejam/faq#platform">the platform was running Python 3.5</a>. Given that locally I was running 3.6, a quick look through <a href="https://www.python.org/downloads/release/python-360/">the release notes</a> revealed that <a href="https://www.python.org/dev/peps/pep-0498/">f-strings</a> were new in that version: I was using them to format my output. A simple fix and my submission was working.</p><p>Once working on the actual logic, a good advice is to start with a simple approach without thinking about performance optimizations. Such optimization would make the code more complex and easier to break even though I don’t even have a solution that works for the simple case yet. Once I have that solution and it is tested (see below), I can optimize if necessary. Here I am talking about optimizing a given algorithm, not about choosing a simpler or more efficient algorithm altogether.</p><p>The next lesson is to follow my intuition. Often, I lack the practice or theoretical knowledge to be able to prove that my approach works for all cases. However, I know it works given my understanding of the problem and I can see it working for the sample test case and the other tests cases I have came up with. This is usually enough to submit the solution. Besides, it adds a little bit of excitement when you submit as you are not entirely sure Google doesn’t have an test input that will break the approach.</p><p>The final lesson is to forget a bit of best practices when it comes to testing and clean code. Competitions like these are time bound (next rounds will only last 2.5 hours) so there is no time to waste writing abstractions, proper unit tests or worrying about invalid input format (that won’t happen). Instead, you only have to focus on: parsing the input into some data structure that makes sense; implementing your algorithm; printing out the results.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc98187e2891" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Weekly readings — 09/07/2018]]></title>
            <link>https://medium.com/@rodriguealcazar/weekly-readings-09-07-2018-eb41092830a0?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb41092830a0</guid>
            <category><![CDATA[soa]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[caching]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Mon, 23 Jul 2018 17:50:45 GMT</pubDate>
            <atom:updated>2018-07-23T17:50:45.914Z</atom:updated>
            <content:encoded><![CDATA[<h4>Netflix 2nd generation caching architecture and one of Pat Helland’s classics.</h4><p>A selection of papers, articles, blog posts that I read during the week of July 9th 2018. I might have been unable to focus much due to the <a href="https://www.fifa.com/worldcup/">FIFA World Cup</a>.</p><h3>Application data caching using SSDs</h3><p>This is a 2 years old <a href="https://medium.com/netflix-techblog/application-data-caching-using-ssds-5bf25df851ef">post from the Netflix engineering blog</a> that describes the Moneta project aimed at using SSDs and optimizing for data access patterns in order to reduce the cost of their memory based caching infrastructure (<a href="https://medium.com/netflix-techblog/announcing-evcache-distributed-in-memory-datastore-for-cloud-c26a698c27f7">EVCache</a> used for <a href="https://medium.com/netflix-techblog/caching-for-a-global-netflix-7bcc457012f1">global replication</a>).</p><p>Before that project, Netflix were caching the personalisation of all their members in all their AWS regions. Storing those billions of key-value pairs in RAM had a significant cost that was only increasing with their user base. They realised that users rarely changed the region they accessed from and that using a different family of EC2 instances with less RAM but much larger SSDs could make substantial cost saving, they decided to move to a two-level caching approach with RAM (L1) and disk (L2).</p><p>From using a single <a href="https://www.memcached.org/">Memcached</a> process on their EVCache instances, they added two new parts: Mnemonic and Rend. Mnemonic is the disk based part of the cache, based on RocksDB. Rend is a Golang proxy responsible for reading and writing data in L1 and L2 and for managing data storage scheme in Memcached. It is modular so that different servers can be used for different access use cases, e.g. online and batch.</p><p>At the time of writing, the new architecture was in the process of being incrementally deployed to different datasets.</p><h3>Data on the Outside versus Data on the Inside</h3><p><a href="http://cidrdb.org/cidr2005/papers/P12.pdf">A classic from 2005</a> by <a href="https://twitter.com/PatHelland">Pat Helland</a> that had been on my reading list for a while. In this paper, he takes a close look at Service Oriented Architectures (SOA) and states that:</p><blockquote>there are a number of semianl differences between data inside a service and data sent into the space outside of the service boundaries.</blockquote><p>Here, a service comprise both code and private data, is independent and interconnected and communicates exclusively via messages. These messages have well defined schemas and semantics which clearly define what the service offers and how to interact with it (think <a href="https://www.w3.org/TR/wsdl/">W3C WSDL</a>). This allows strong encapsulation of changes to the data (writes) and also of reads - data within a service is not accessed by another service and usually not allowed to go outside. Finally, the paper only considers services that do not participate in cross-service ACID transactions (see Pat Helland also famous paper <a href="http://www-db.cs.wisc.edu/cidr/cidr2007/papers/cidr07p15.pdf">on how to survive without distributed transactions</a>).</p><p>In this context, Inside Data refers to data that is private to a service, the sort of data we are used to work with and that is usually stored in a SQL database (of course, the paper predates the NoSQL era). Outside Data then refers to the data that flows between services, contained in messages.</p><p>The first difference between the two is their temporality and it is caused by the lack of transactions across services. For Inside Data, there exist a strong meaning of <em>now</em> given that ACID does apply inside a service. However, Ouside Data when it reaches a target service comes from the past and may well have changed already within the original service. Besides, from the point of view of a service sending a message, the operators contained in those messages — the business functions that a service offers — represent actions to be performed in the future by the target service. This means that data in between services is either past of future but never now and that services must be designed to deal with this.</p><p>A characteristic of Outside Data is that it is immutable: once written it is given an identifier and then it cannot be changed aside from being deleted. It can be versioned where different versions have different values but the same version will always refers to the same contents. Messages as well need to be immutable so as to allow consistency in case of retries. And their schemas must be immutable as well so as to be able to understand an old message even if the schema has changed.</p><p>To avoid confusion, on top of being immutable, Outside Data also needs to be <em>stable</em> which mean “unambiguous across space and time”. Timestamps, versioning and unique identifiers are techniques that help ensuring the stability of data.</p><p>Finally, when Outside Data references other data, it is necessary that the identifiers used for the reference specify immutable and stable data as well.</p><p>The paper then looks at reference data which is Outside Data managed and published by a single service and used by others. When published, reference data needs to have a version independent identifier and it needs to be considered as coming from the past. Reference data can be used as operands to operators, e.g. a product catalog or shipping-cost list. It can also represent historic artefacts, e.g. quarterly results, monthly bank statement. The most complex use though are shared collections, e.g. customer database. In this case, a special service has full authority over that shared data: it will publish versions of the collection and accept message to update the data with full control over how the actual data is updated, e.g. enforcing business constraints.</p><p>The paper then looks at Inside Data. First, it explains that SQL and its Data Definition Language (DDL) lives in the same Now since DDL is transactional which means that SQL statements only have meaning in the context of the schema defined by the preceding transactions.</p><p>Then, it explains how Outside Data that reaches a service is usually stored locally. However, inside a service, data is not immutable yet often an exact binary copy of messages is kept, for instance for auditing. It is also usually converted and stored in a more convenient way or used to update Inside Data.</p><p>The last aspect of Inside Data that is discussed constrasts extensibily with shredding. Outside Data (in the context of the paper) is most often represented with XML which supports extensibility which means that other services can add information to a message that was not expected when the schema was defined. In contrast, shredding — the process of converting hierarchical data into a relational representation — makes it hard to extend the data.</p><p>The last part of the paper looks at three different representations of data, their differences and when to use them: XML, SQL and Objects. XML is designed for representing hierarchical collections. It offers a way of defining schemas for the enclosed data and those schemas are composable by using URIs to refer to other schemas. SQL, on the other hand, represents data by its value and binds it to a specific schema.</p><p>The author then lists in a table the various characteristics of Inside and Outside data already discussed and then compares the three representation models in terms of support for arbitrary queries, independent definition of shared data and encapsulation and control of data. He states that each representation is strong in one aspect which makes it weak in another and concludes that there is a need for using all three: XML for Outside Data, Objects for business logic and SQL for storing Inside Data.</p><p>Even though the paper is less than 15 years old, you can see that the technology landscape has evolved yet it still feels very relevant and applicable to today’s microservices world. Formally differentiating the data as seen inside a service with the data that lives between services and looking at their sometimes opposing characteristics and needs makes a lot of sense. I also found it nicely ironic to be reminded how SOA was originally based around messaging while microservices which I see as its evolution, only came to that approach after first thriving as synchronous.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb41092830a0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Weekly readings — 02/07/18]]></title>
            <link>https://medium.com/@rodriguealcazar/weekly-readings-02-07-18-d0f9cfcffb7f?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0f9cfcffb7f</guid>
            <category><![CDATA[a-b-testing]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[weekly-reading]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Mon, 09 Jul 2018 09:19:18 GMT</pubDate>
            <atom:updated>2018-07-10T07:54:37.521Z</atom:updated>
            <content:encoded><![CDATA[<h4>Large scale data migration at Facebook, microservices decomposition and Grab’s experimentation platform.</h4><h4>Migrating Messenger storage to optimize performance</h4><p>An article describing <a href="https://code.fb.com/data-infrastructure/migrating-messenger-storage-to-optimize-performance/">how Facebook migrated the storage layer of their Messenger app</a>. They moved from <a href="https://hbase.apache.org/">HBase</a> to <a href="http://myrocks.io/">MyRocks</a> (MySQL with RocksDB storage).</p><p>The most impressive part if that they migrated one by one every single of they more than 1 billion Messenger accounts — petabytes of data — without any service interruption. They migrated 99.9% of accounts on the assumption that no data was written during the migration. If that didn’t hold true, the account was marked as failed, rolled back and tried again at a later point. They also defined a second scenario for the 0.1% of account that are constantly writing or are very large. To do so they relied on an internal service called <a href="https://code.fb.com/production-engineering/building-mobile-first-infrastructure-for-messenger/">Iris</a> that can queue and hold messages.</p><p>With a lot of custom monitoring and data quality checks, along with a custom accounting job they were able to successfully migrate all the data for 100% of the accounts. Using the <a href="https://facebook.github.io/bistro/">Bistro framework</a> to paralellize, schedule, monitor and throttle jobs, they were able to perform that task in 4 weeks.</p><p>They saw several different benefits from their storage migration:</p><ul><li>90% storage space reduction thanks to schema redesign, less replication and <a href="https://github.com/facebook/zstd">Zstandard compression</a></li><li>50 times lower read latency due to the move to <a href="https://code.fb.com/data-center-engineering/introducing-lightning-a-flexible-nvme-jbof/">NVMe based SSD storage</a></li><li>More mature and automated Disaster Recovery using existing internal MyRocks infrastructure</li><li>Ease of adding new features, e.g. search which was not possible on HBase</li></ul><p>This reminded me of a similar large data migration one of the teams <a href="https://code.fb.com/data-center-engineering/introducing-lightning-a-flexible-nvme-jbof/">at work</a> recently finished. We had to upgrade our main data store from a old version of Cassandra (1.2) to the latest (3.x). To ensure no data was lost and no service interruption was required was no small feat and took a lot of time and effort.</p><h4>Services by lifecycle</h4><p>A post by Michael Nigard I had read already but came across again this week on a <a href="http://www.michaelnygard.com/blog/2018/01/services-by-lifecycle/">strategy for breaking down micro-services responsibilities</a>. It is a sequel to a previous post where he explained what he calls the <a href="http://www.michaelnygard.com/blog/2017/12/the-entity-service-antipattern/">Entity Service Antipattern</a> There, he argued that the extra coupling created by CRUD type services is not a good design idea. Here, he proposes an alternative.</p><p>The idea is that instead of designing services around the full lifecycle of a business entity (essentially CRUD) and having to manage its State Machine internally, we can treat each state of the lifecycle as a different “thing”. Looking at the problem that way leads to building a separate service to manage each state the entity goes through during the business process.</p><p>With this approach, services send document (or events) to each other where the next service in the process can chose to consume and update only the data points that are relevant to it, essentially making part of the entity immutable. The coupling to a single entity service is also gone and since the state machine is now distributed and explicit as opposed to centralized and internal, it is easier to update or extend the business process.</p><p>For me, this is a really interesting and fresh way of looking at how to break down microservices. As Micheal puts it: “this style offers a nice degree of alignment between the technology and the business”. This is something that is often lost when talking about microservices as people start thinking about a technical/technological break down rather than focusing on designing services that fulfill business value, i.e. can your stakeholder understand why a particular service exists?</p><p>Michael mentioned at the start that he will write more on other patterns that avoid entity services. I am looking forward to reading more.</p><h4>Grab experimentation platform</h4><p><a href="https://www.techinasia.com/talk/grab-experimentation-platform">An article</a> describing the Grab Experimentation Platform (ExP) that they built to be able to easily design and run controlled experiments to test new features. This effort stemmed from the approach they previously had that required custom work for each experiment and was time consuming and costly.</p><p>They had several well defined goals when they started designing their experimentation platform:</p><ul><li>a uniform platform for engineers and data scientists</li><li>preventing interference between multiple experiments</li><li>automated population selection</li><li>fully automated and extensible</li><li>automated data pipeline for later analysis</li><li>alerting on key business metrics to identify adverse effect</li><li>a centralized UI for defining and managing experiments</li></ul><p>They also identified two issues when doing experiments at scale that they had to address: network effects and control and treatment assignment strategy.</p><p>Finally, they have also introduced warnings and explicit user suggestions to avoid experiment interference.</p><p>ExP is built around a few key concepts:</p><ul><li>a variable which is something that can change</li><li>a metric which is something the experiment wants to improve</li><li>a rollout which is the fact of applying the feature to a gradually larger portion of users</li><li>a group which is a set of identifiers used to logically put a set of “things”, e.g. users, areas, … together</li><li>an experiment which is a time bound change to one or multiple variables split into control and treatment(s)</li></ul><p>The experiement is defined in JSON so that it is machine readable and can ensure easier communication.</p><p>Then they built SDKs for iOS, Android and Golang that are able to apply experiments defined in that JSON format. The SDKs know how to apply different split strategies, mainly random and time-sliced.</p><p>They present a use case where they gradually rolled out automated GrabChat messages based on iterative experiments that suggested it helped reduce cancellations.</p><p>This article shows another example where live experimentation is an essential tool for a tech business. As stated in the article, building a platform that scales and is easily accessible to non engineers is not easy. The analytics and reporting part, not presented here, is also something usually complex to build. Despite some common concerns, custom architecture and business logic means that it’s not easy to define a generic platform to support that and is probably an explanation for why no widely adopted open-source solution exist yet (that I am aware of).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0f9cfcffb7f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Elections présidentielles: pourquoi s’emmerder.]]></title>
            <link>https://medium.com/@rodriguealcazar/elections-pr%C3%A9sidentielles-pourquoi-semmerder-b2336f828df6?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2336f828df6</guid>
            <category><![CDATA[france]]></category>
            <category><![CDATA[présidentielle-2017]]></category>
            <category><![CDATA[politique]]></category>
            <category><![CDATA[elections]]></category>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Sat, 22 Apr 2017 15:45:27 GMT</pubDate>
            <atom:updated>2017-04-22T20:06:16.543Z</atom:updated>
            <content:encoded><![CDATA[<p>Ça y est, la campagne présidentielle du premier tour est achevée et il est finalement temps pour les électeurs Français de voter. Cette campagne aura duré plus d’un an pour certain candidats (<a href="http://www.lefigaro.fr/politique/le-scan/citations/2016/02/08/25002-20160208ARTFIG00342-marine-le-pen-officialise-sa-candidature-a-l-election-presidentielle.php">Le Pen</a>, <a href="https://twitter.com/jlmelenchon/status/697499673859387393">Melenchon</a>, <a href="http://www.francetvinfo.fr/politique/emmanuel-macron-cree-son-mouvement-politique-transpartisan-en-marche_1712693.html">Macron</a>, …) et depuis les primaires du parti Les Républicains en Novembre dernier, les médias, traditionnels comme nouveaux, vibrent principalement au rythme de la politique — rythme dont ils sont d’ailleurs tout autant témoins qu’orchestrateurs.</p><p>Pourtant, pour nombre d’entre nous la foire quinquennale ne présente pas grand intérêt, si ce n’est celui de nous dégoûter encore un peu plus de ces hommes et femmes politiques déconnectés, intrigants, magouilleurs, incompétents et principalement intéressés à leur enrichissement personnel. Et par extension, le dégoût s’étend parfois en un sentiment de rejet du “système”, cette complexe et insaisissable entité politico-économique dans laquelle certains se complaisent quand d’autres souffrent, et qui semble tout diriger, sans aucun contrôle populaire.</p><p>La conclusion logique en est alors de se dire que non, voter ne sert à rien ou alors à bien peu. Cette conclusion semble alors générer trois types d’électeurs: ceux qui ne savent pas encore s’ils iront voter et encore moins pour qui; ceux qui se déplaceront mais voteront blanc; ceux qui n’iront tous simplement pas voter du tout.</p><p>Pour ma part, toutes ces options me parlent. En effet, je ne me souviens pas avoir jamais été vraiment enthousiasmé par un(e) candidat(e) mais plutôt avoir toujours voté par défaut, contre, voire blanc. A tel point que lorsque mon inscription sur les listes électorales du être renouvelée, je ne le fis pas et voilà maintenant 10 ans que je n’ai plus voté. 10 ans que je suis d’un regard plus ou moins attentif la vie politique française et internationale mais sans y prendre part. Pourtant, cette année quelque chose s’est réveillé dans ma conscience citoyenne et voila qu’au mois de Décembre dernier je me suis inscrit à nouveau sur les listes électorales. Et ce dimanche 23 Avril, j’irai donc voter.</p><p>Pourquoi vous dire tout cela? Par ce que j’ai peur, tout simplement. Peur de voire ce scrutin accoucher d’un résultat funeste qui ne fasse qu’enfoncer un peu plus la population dans le marasme dans lequel nous croupissons déjà. Et quand je parle de population, je pense a celle de la France, de l’Europe et même du monde.</p><p>“N’aie pas peur voyons, tu sais bien que les politiques ne servent à rien et qu’élection après élection rien ne change!” me direz vous. Seulement voila, je me suis mis dans la tête que la politique, hé bien oui ça sert à quelque chose, et si ce n’est pas à rendre la vie des gens meilleure c‘est peut être par ce que malheureusement ça sert bien souvent à la rendre pire. Je me suis mis dans la tête que l’interminable crise sociale et écologique dans laquelle nous vivons est née et s’est développée a l’aide de politiques nocives qui n’ont cessées de pousser nos sociétés dans la mauvaise direction. Plus important encore, je me suis mis dans la tête que si l’on ne changeait pas de politiques (hommes et idées) très vite, les dommages seraient irréparables: comme la grenouille qu’on a mise dans l’eau froide à chauffer sur le feu, nous baignons tout entiers dans cette politique néfaste qui ne sert soit disant à rien mais dont la température ne fait que monter; et si l’on n’y prend pas garde il pourrait être bientôt trop tard pour pouvoir sauter vivant hors de l’eau.</p><p>Voila pourquoi j’ai peur de voir cette élection se transformer en une chance perdue de commencer à changer les choses. Par ce que ne nous y trompons pas, la catastrophe est imminente pour la France mais aussi bien au delà. Nous vivons une période critique de l’histoire humaine qui appelle à des décisions graves et drastiques car il en va tout simplement de la survie de nos sociétés, accablées par la <a href="https://www.ipcc.ch/pdf/assessment-report/ar5/wg2/WGIIAR5-IntegrationBrochure_fr.pdf">crise écologique</a> et <a href="https://pabloservigne.com/comment-tout-peut-seffondrer/">l’aboutissement dramatique de nos modèles de production et de consommation</a>. Rien de moins.</p><p>Il est urgent de repenser nos modes de vie et en particulier d’en finir avec le néo-libéralisme malsain qui a généré en 40 ans plus d’inégalités, de misère, de destruction, de guerres, de pollution et d’extinctions qu’aucun autre système politico-économique durant les 200000 ans d’existence de l’homme.</p><p>Alors voila pourquoi j’ai décidé de voter: pour essayer d’écarter les candidat nuisibles et, si possible, en soutenir un(e) qui défende des idées progressistes et mette au cœur de son programme le temps long, organisé autour de la survie et du bien être de tous. J’ai décidé de voter par ce que voter blanc dans notre modèle électoral est inutile et s’abstenir ouvre souvent la voie à ceux qui ont les militants les plus assidus (le <a href="http://www.lemonde.fr/les-decodeurs/article/2017/03/30/l-abstention-en-hausse-depuis-1958-la-presidentielle-toujours-mobilisatrice_5103297_4355770.html?xtmc=abstention&amp;xtcr=67">taux d’abstention record à la présidentielle a été atteint en 2002</a>, élection qui a vu Jean-Marie Le Pen atteindre le second tour).</p><p>J’ai décidé de voter et j’espère sincèrement que beaucoup d’indécis en feront de même pour aider à éviter que la France ne continue à se fourvoyer et à appliquer année après année les mêmes variations de ces idéologies dangereuses qui ne font que refermer petit a petit le couvercle sur la marmite alors que déjà l’eau commence à frémir. Sautons, ceux qui le veulent, hors de l’eau et essayons d’éteindre le feu.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2336f828df6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Virage à gauche]]></title>
            <link>https://medium.com/@rodriguealcazar/virage-%C3%A0-gauche-5de855911eea?source=rss-350d9660b566------2</link>
            <guid isPermaLink="false">https://medium.com/p/5de855911eea</guid>
            <dc:creator><![CDATA[Rodrigue Alcazar]]></dc:creator>
            <pubDate>Sat, 21 Jan 2017 18:20:48 GMT</pubDate>
            <atom:updated>2017-01-21T18:20:48.386Z</atom:updated>
            <content:encoded><![CDATA[<p>Triste passation de pouvoir hier aux Etats-Unis. Malheureusement, la France aussi a un Trump qui rode et menace. Nous avons d’importantes élections cette année et l’on ne peut pas faire la même erreur. Cela passe par sa propre réflexion et éducation mais aussi par un peu de prosélytisme dans son entourage. Voter contre ceux qui nous enlisent aujourd’hui ou nous ont faillis hier est primordial mais voter pour quelque chose de pire serait absurde. 2017 ne sera peut être pas l’année du grand changement mais elle peut être une chance de faire un pas dans la bonne direction. Et cette direction, ne nous y trompons pas, c’est à gauche toute!</p><p>Des idées inspirantes il y en a chez <a href="https://poutou2017.org/">les petits</a>, les <a href="http://www.jlm2017.fr/">plus établis</a> et même les <a href="https://laprimaire.org/">totalement indépendants</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5de855911eea" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>