<?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 Benjamin Coenen on Medium]]></title>
        <description><![CDATA[Stories by Benjamin Coenen on Medium]]></description>
        <link>https://medium.com/@bnjjj?source=rss-5174be4b20dc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*je2iMNxzUX8n-u0VHBrSvg.jpeg</url>
            <title>Stories by Benjamin Coenen on Medium</title>
            <link>https://medium.com/@bnjjj?source=rss-5174be4b20dc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:57:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bnjjj/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why and how we wrote a compiler in Rust (blog post series 2/X): the stack]]></title>
            <link>https://bnjjj.medium.com/why-and-how-we-wrote-a-compiler-in-rust-blog-post-series-2-x-the-stack-548dad1919d0?source=rss-5174be4b20dc------2</link>
            <guid isPermaLink="false">https://medium.com/p/548dad1919d0</guid>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[rust]]></category>
            <category><![CDATA[webassembly]]></category>
            <category><![CDATA[crypto]]></category>
            <category><![CDATA[compilers]]></category>
            <dc:creator><![CDATA[Benjamin Coenen]]></dc:creator>
            <pubDate>Wed, 07 Jul 2021 12:51:25 GMT</pubDate>
            <atom:updated>2021-07-07T12:51:25.775Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*cb0oTIqVJsoSV4WYEmivtQ.png" /></figure><blockquote>This post is the second post of the series about how we wrote a compiler in Rust at <a href="https://cosmian.com/">Cosmian</a> for the <a href="https://cosmian.com/products/#ciphercompute">CipherCompute</a> product. If you missed the first one <a href="https://bnjjj.medium.com/why-and-how-we-wrote-a-compiler-in-rust-blog-post-series-1-x-the-context-e2f83b10edb9">here is the link</a>, I recommend you to read it to really understand what we’re trying to achieve and know the context.</blockquote><p>As a reminder, the previous article explains our objective is to be able to execute a <a href="https://en.wikipedia.org/wiki/Secure_multi-party_computation">sMPC (secure multi party computation)</a> program in a widespread and known language, <a href="https://www.rust-lang.org/">Rust</a> in our case. To achieve this, we developed a compiler named <a href="https://github.com/KULeuven-COSIC/SCALE-MAMBA/tree/master/WebAssembly">WaSca</a> which takes Wasm (<a href="https://webassembly.org/">WebAssembly</a>) and compiles it to bytecode understandable by the <a href="https://github.com/KULeuven-COSIC/SCALE-MAMBA">Scale virtual machine</a> to run sMPC computations.</p><p>In this post I’m going to explain a concept developed in the <a href="https://github.com/KULeuven-COSIC/SCALE-MAMBA">WaSca</a> compiler called the WaSca stack. Indeed there is a fundamental difference between the 2 assembly codes we are dealing with. They have a distinct way of dealing with function calls, memory management and variable types. Wasm is a stack based assembly language. As such, its memory does not contain registers. Instead, all instruction arguments are pushed and popped on a shared stack. Scale asm on the other hand, uses a register based assembly language. Therefore, all arguments and return values are passed with registers. Let’s explain in a more detailed way how each one works.</p><h3>Wasm instructions</h3><p>If we take a very simple program, for example a simple addition of 2 numbers (5 + 2).</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/83af2159d52e463c0536a510a4cc6a62/href">https://medium.com/media/83af2159d52e463c0536a510a4cc6a62/href</a></iframe><p>Representing this program in Wasm is pretty simple, it’s only 3 lines with 2 different kinds of instruction. The first one is i32.const which takes 1 constant as parameter in order to push an i32 constant on the Wasm stack. The other one isi32.add which takes no parameter but instead reads the last 2 elements on the Wasm stack, makes the addition between them and pushes the result on the stack. Here’s an animation to see exactly what happens when running this small program.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YGW5c9wnkj_D9bLFPOPrXA.gif" /><figcaption>How Wasm works</figcaption></figure><h3>Scale asm instructions</h3><p>Now let’s see the same program but written in Scale asm. It’s also only 3 lines with 2 different kinds of instructions.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7fe0e65a9953b7ec849671809391c974/href">https://medium.com/media/7fe0e65a9953b7ec849671809391c974/href</a></iframe><p>The first one is anldint instruction which takes 2 parameters: the first one is the target register to store the constant value located as the second parameter. The second one is theaddint instruction which takes 3 parameters: the first one is the target register to save the result of the addition and the 2 last parameters are registers that will be added together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2uJhH8mWU8vX7nElRf-vQg.gif" /><figcaption>How Scale asm works</figcaption></figure><p>So the main difference is that in Wasm almost all instructions use the Wasm stack which will be filled and emptied depending on the function arguments, the instructions, etc. At the end of the execution the Wasm stack is supposed to be empty as all values should be consumed by the instructions, while in Scale asm the arguments or instruction parameters are passed on registers. Registers are memory allocated in some memory zones which keep the value assigned until another value is set for this specific register. In Scale asm when an instruction produces value it goes in a register and not in a global stack.</p><h3>The WaSca stack</h3><p>We can easily understand that these two behaviors are very different. To generate our bytecode in Scale we generate Scale asm and then the way we transform Wasm to Scale asm is very different from just doing 1:1 for each instruction. We also have an available stack in Scale by using push and pop instructions but it would be very inefficient to try to use it as it is done in Wasm. By doing this we would have performance issues because a lot more instructions than needed would be used but also we would have less optimizations than we have today.</p><p>Those are the reasons why we implemented what we call the “<a href="https://medium.com/@bnjjj/why-and-how-we-wrote-a-compiler-in-rust-blog-post-series-1-x-the-context-e2f83b10edb9">WaSca</a> stack” (to differentiate from the other ones) which only lives in the compiler, this stack doesn’t exist anymore at runtime. This gives us the ability to easily switch from the stack paradigm to the register paradigm. This WaSca stack is basically a stack used in the compiler to reproduce the same behavior as the Wasm stack. Unlike the Wasm stack which lives at runtime, the WaSca stack is only useful for us to compile to the Scale asm. Instead of pushing and popping values as in Wasm stack we push either constant values or registers. Thanks to this behavior we are also able to add some optimizations into our generated code.</p><p>But sometimes a stack based approach makes some codes very complex or nearly impossible to write. For this reason Wasm has function-local variables. Every function declares at the start which local variables it has and of which type they are. These local variables are allocated in registers on Scale. The attribution of registers is simply made by incrementing a global counter in the compiler. In addition we have a global hashmap to save which register corresponds to which local variable in Wasm, in order to re-use them. The key of this hashmap is the unique local variable identifier and the value is the register itself. As the registers are suffixed by a number it’s pretty easy to use this global counter to assign new ones.</p><p>Here is an illustration to help you understand how WaSca works, following by a written explanation:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hA9XvlWQdnCweW3DmQZAow.gif" /><figcaption>How WaSca stack works</figcaption></figure><p>So if we take back our previous example program and try to emulate the behavior of the WaSca stack, here is how it works (<em>so basically when we mention a stack in this explanation we talk about the WaSca stack</em>) :</p><ul><li>We allocate the constant value <em>5</em> on the stack</li><li>We pop this constant value from the stack and create the asm instruction to load the constant into a register. In the meantime a new register is assigned for this instruction.</li><li>The new assigned register is now pushed on the stack</li><li>We repeat the same behavior for another constant value <em>2</em></li><li>Then when we have the i32.add instruction in Wasm. We pop the two last elements from the WaSca stack. They are not constant <em>5</em> and <em>2</em>, but the registers where the value <em>5</em> and <em>2</em> are stored. We can now generate the correct Scale instruction addint r3, r0, r1, r0 and r1 are registers popped from the stack and created when we assigned constant values <em>5</em> and <em>2</em>. Andr3 is a new register assigned to receive the response of the add operation.</li><li>Finally we push the target register r3 into the stack to be able to use it in the next instruction.</li></ul><h3>Types</h3><p>When introducing the local variables we talked about types. Unfortunately Wasm only has i32, i64, f32, f64 and v128 types available to us. Technically there is also an <a href="https://reviews.llvm.org/D66035">externref</a> meta-type that allows the code to create its own types, but <a href="https://llvm.org/">LLVM</a> (and thus Rust) does not support this yet. This means that we have five Wasm types that could map to the five Scale register types. The Wasm types have no relation with the types used in Rust, beyond that i64 in Rust is also i64 in Wasm. Unfortunately u64 in Rust is also i64 in Wasm, and the only way to notice this in Wasm is through unsigned operations on i64. To make secure multi-party computation (sMPC) we need some specific types. We therefore encode all operations on <a href="https://github.com/KULeuven-COSIC/SCALE-MAMBA/blob/master/RustDocumentation/Types.tex">types</a> as ClearModp, SecretModp, i64 and SecretI64 in Rust as operations on <a href="https://doc.rust-lang.org/core/arch/wasm32/struct.v128.html">v128</a>, f32, i64, f64 respectively in Wasm, without ever using them as such.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OnOkjBEGIPsu5PsLC3qM1w@2x.png" /><figcaption>How Wasm types are translated to Scale types</figcaption></figure><p>The reason why it works is that we do not translate operations on these types to Wasm operations, but instead translate them to external function calls which we will lower directly in WaSca to the appropriate Scale asm instructions.</p><h3><strong>To be continued…</strong></h3><p>Here is the second blog post in this series just to show you a first look at our compiler internals. The next post will be more focused about how we manage memory allocations in the WaSca compiler. We’ll see that we have encrypted memory zones in addition to the classical heap and stack, and explore together what we have already done and what we plan for the future. If you want to be notified when it’s out, feel free to follow <a href="https://twitter.com/CosmianOfficial">Cosmian’s twitter account</a>.</p><h4>Credits</h4><ul><li><a href="https://twitter.com/coding_grrrl">Laetitia</a> for the amazing illustrations</li><li><a href="https://twitter.com/oli_obk">oli_obk</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=548dad1919d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why and how we wrote a compiler in Rust (blog post series 1/X): the context]]></title>
            <link>https://bnjjj.medium.com/why-and-how-we-wrote-a-compiler-in-rust-blog-post-series-1-x-the-context-e2f83b10edb9?source=rss-5174be4b20dc------2</link>
            <guid isPermaLink="false">https://medium.com/p/e2f83b10edb9</guid>
            <category><![CDATA[compilers]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[multi-party-computation]]></category>
            <category><![CDATA[webassembly]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Benjamin Coenen]]></dc:creator>
            <pubDate>Tue, 18 May 2021 12:59:36 GMT</pubDate>
            <atom:updated>2021-07-07T13:05:02.647Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jpxc9VslR8e8lH2ZK2VVKw.png" /></figure><p>This blog post is the first one of a series, it will give you more context to understand why we decided to write our own compiler, as well as where and how it is used in our use case. At <a href="http://cosmian.com/">Cosmian</a> we are continuously striving to build the most comprehensive and reliable technological stack based on state-of-the-art cryptographic techniques. We are using them to open new horizons for companies, new possibilities to run computation together without making compromises on data security. That’s why we created <a href="https://cosmian.com/products/#ciphercompute">CipherCompute</a>, one of our products to run collaborative computation over sensitive data between different entities/companies. To provide this ability we made the known cryptographic technique named Secure Multi Party Computation (sMPC) easy to use for data scientists.</p><h3>Secure Multi Party Computation</h3><p>Let’s start with a small introduction to sMPC. Secure Multi Party Computation (sMPC) is a cryptographic protocol for performing computation between participants who do not or can not (legally) trust each other with their raw data. The goal of sMPC is to achieve the same result as if the computation was performed by a central third party but in a distributed manner between the participants without any of the participants having to reveal their input data in clear text to any other participant.</p><p>There are various forms of sMPC with different security models; the most useful is the one achieving passive security with up to <em>n-1</em> corrupt participants. In this model (which is the one provided by Cipher Compute ) participating attackers follow the protocol but try to learn more than they are entitled to.</p><p>Multiple recent cryptographic techniques have been developed to achieve sMPC. The main 4 are based on <a href="https://en.wikipedia.org/wiki/Oblivious_transfer">Oblivious Transfers</a> and <a href="https://en.wikipedia.org/wiki/Garbled_circuit">Garbled Circuits</a> to achieve 2-party computation and <a href="https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing">Shamir Secret Sharing (SSS)</a> or <a href="https://en.wikipedia.org/wiki/Homomorphic_encryption">Fully Homomorphic Encryption (FHE)</a> for multi party computation. Using SSS, participants can share secrets using a property of polynomials that n points are enough to uniquely determine a polynomial of degree <em>n-1</em> (using Lagrange interpolation). To share a secret between <em>n</em> participants, one of them will generate a random polynomial of degree<em> n-1</em> where <em>f(0)</em> is the secret and share <em>n-1</em> points <em>(x, f(x))</em> to the other participants. Recombining all the shares will allow them to recover the polynomial using interpolation and hence recover the secret by computing <em>f(0)</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LUXGYz5vtx5jk0tKNbqu3w.png" /><figcaption>Very simplified schema about a sMPC computation between 3 participants</figcaption></figure><h3>The compiler</h3><p>We are working in collaboration with <a href="https://www.esat.kuleuven.be/cosic/">COSIC from KU Leuven</a> and <a href="https://www.esat.kuleuven.be/cosic/people/nigel-smart/">Nigel Smart</a> (a member of the <a href="https://cosmian.com/about-us">scientific advisor board of Cosmian</a>) who created <a href="https://github.com/KULeuven-COSIC/SCALE-MAMBA">Scale (Secure Computation Algorithms from LEuven)</a>. It’s a virtual machine who takes bytecode to run sMPC computations. Under the hood, Scale is developed in C++ and is in charge of making all the cryptographic work and exchanges between players during the computation. <em>If you need more information about how it’s done under the hood and how the Scale VM works I suggest to browse </em><a href="https://github.com/KULeuven-COSIC/SCALE-MAMBA"><em>this mirrored git repository on GitHub</em></a><em> including the official documentation.</em> When we tried Scale at this time we spotted a big drawback. To be able to write a sMPC program and to execute it on the Scale VM we needed to learn a new language which was neither widespread nor standard. This language is called Scale Mamba, it’s like essentially a code generator written in python, with some convenience libraries on top that make it mostly a DSL on top of python. It’s quite convenient but our goal at Cosmian is to bring advanced cryptographic techniques to the enterprise world with standards coming from software engineering in order to open new possibilities and allow for a wider audience. Learning a new specific programming language to write a simple program was a kind of entry barrier we don’t want to have. That’s one of the reasons we decided to write a <a href="https://www.rust-lang.org/">Rust</a> compiler to compile Rust programs into bytecode understandable by the Scale VM. Why Rust? Because at Cosmian we love Rust, our technical stack is already written in Rust and we are pretty happy and confident thanks to this language. It’s also a well-known language and could be used in another context than only Scale. As Rust is a pretty low level language we were able to develop our own memory allocator and our own standard library. So the main goal to develop this compiler is to let developers write their own sMPC algorithm entirely written in Rust.</p><p>At Cosmian we decided to go further in order to bring secure multi party computation in companies by adding a step in our compilation flow. Indeed instead of compiling Rust directly to Scale assembly and then bytecode we compile Rust to <a href="https://webassembly.org/">WebAssembly (WASM)</a> then use the WASM bytecode and compile it into Scale assembly. Why? Because we wanted to benefit from all the existing WASM implementations in other languages, for example today many languages are able to compile to WebAssembly bytecode. Then, thanks to this we will be able later to add a new language than just Rust to write sMPC programs. We could think about Golang for example and then we theoretically will need to just provide a standard library for Golang to run on Scale virtual machine. Our compiler is called <em>WASCA</em> because it takes <strong>WA</strong>SM and compiles it to <strong>Sc</strong>ale <strong>A</strong>ssembly. So the step to compile Rust to WASM is not our job at all, it’s already existing and has good support thanks to the LLVM backend compiler. Here is the full steps of our compilation pipeline (some steps about optimisations are intentionally omitted):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qoMRxS-kLuW7ofqSc9stnA@2x.png" /><figcaption>The full compiler flow</figcaption></figure><p>As explained before, with the ability to write sMPC programs in Rust we provide the WASCA compiler and the standard library for Rust. Indeed during this blog post series we will see that it’s very similar to an embedded environment without a standard library (in a <em>no_std </em>environment) because we execute our code on a specific VM. The Scale standard library provides helpers for developers to iterate over input data, send data to a specific player/participant but also is in charge of handling heap allocations. Memory allocation will be a big part of the next blog post in this series because we have a not so common memory mapping in the Scale VM. Then in our standard library we redefined some data structures such as slices and arrays to be able to allocate memory on the heap as we wish. Here is a little illustration to recap what are responsibilities of the Rust core lib and the Scale standard library in a secure multi party computing program.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IBhlErkHauxO4bDbEVgUeA@2x.png" /><figcaption>Rust core and Scale std lib interactions with Scale VM</figcaption></figure><h3>Next posts</h3><ul><li><a href="https://bnjjj.medium.com/why-and-how-we-wrote-a-compiler-in-rust-blog-post-series-2-x-the-stack-548dad1919d0"><em>Why</em> <em>and</em> <em>how</em> <em>we</em> <em>wrote</em> <em>a</em> <em>compiler</em> in <em>Rust</em> (blog post series 2/X): <em>the</em> <em>stack</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2f83b10edb9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Les hackathons: le bon, la brute et le truand]]></title>
            <link>https://bnjjj.medium.com/les-hackathons-le-bon-la-brute-et-le-truand-5f6d998e4a90?source=rss-5174be4b20dc------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f6d998e4a90</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[hackathons]]></category>
            <category><![CDATA[francai]]></category>
            <dc:creator><![CDATA[Benjamin Coenen]]></dc:creator>
            <pubDate>Sun, 01 Nov 2015 13:09:45 GMT</pubDate>
            <atom:updated>2021-05-18T13:34:56.919Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*DO2klwOYh7JJSW4GLP8LGw.jpeg" /></figure><p><strong>Les hackathons</strong>, ces concours qui font rêver les développeurs et qui deviennent de plus en plus courant. Plus un week-end ne se passe sans qu’il y en ait un. Aujourd’hui après avoir participé à une dizaine de ces concours et dans différents pays je pense qu’il peut être intéressant de faire un petit retour d’expérience les concernant.</p><p><strong>Commençons par le positif</strong>, à la base quand je me suis lancé à la conquête de mon premier hackathon c’était clairement un saut dans le vide, je n’avais jamais fait de développement web ou mobile. J’étais plutôt dev système du coup j’étais vraiment novice dans ce domaine, tout comme mes amis.On a donc commencé à se lancer à la conquête du dev web pour arriver à la fin de notre weekend hackathon avec une application web fonctionnelle, c’était déjà une super victoire. Bref à l’heure du bilan de ce premier hackathon j’avais fait mes premiers pas dans le dev web et j’adorais ça ! Je tenais à raconter cette anecdote pour mettre en avant une de mes principales motivations de participer à un hackathon, l’apprentissage. Car oui si on veut apprendre, aller en hackathon nous permet d’apprendre énormément, en peu de temps et pas que sur le développement. J’ai aussi énormément appris sur la répartition des tâches entre membres du groupe, comment faire un bon pitch, et j’en passe…</p><p><strong>Ce qui est génial </strong>aussi c’est qu’on a l’occasion de passer un geek-end avec des passionnés, faire de nouvelles rencontres, échanger sur nos pratiques, échanger nos connaissances et ça c’est vraiment plaisant ! Pour certaines personnes n’ayant pas l’occasion de travailler dans ce domaine je pense aussi que ça peut être un vrai changement et l’occasion d’approfondir un domaine qui nous tient à cœur.</p><p><strong>Parlons un peu du négatif</strong>, dans le mot hackathon il y a le mot hack qui est généralement plus destinés aux personnes de la technique. Malheureusement les hackathons misent de moins en moins sur la technique je trouve. Les développeurs sont la plupart du temps peu mis en avant et je trouve ça dommage. Chaque fois que je propose à quelqu’un qui n’est pas de la technique de venir participer à un hackathon sa réaction est toujours la même : «<em>je ne sais pas coder je vais servir à rien</em>». Et pourtant c’est tout à fait le contraire, dans les hackathons ce sont surtout les commerciaux, marketeux et tout ces domaines là qui sont de plus en plus mis en avant. En aucun cas je ne critique ces métiers, simplement ils ont déjà pléthore de concours qui leur sont destiné. Comme les startups weekend par exemple. Forcément je le cite dans mes points négatifs car j’en parle de mon point de vue mais ça n’en est pas un pour tout le monde.</p><p><strong>Au niveau technique</strong> il y a quand même des inconvénients. Celui auquel je pense le plus souvent est que l’on doit développer une idée fonctionnelle en un peu moins de 48h, du coup on doit développer très rapidement. Et généralement rapidement ne va pas de paire avec correctement. On se concentre juste sur le fond et pas sur la forme. Du coup l’avantage d’apprendre certaines connaissances techniques en hackathons peut aussi être un piège puisque ce n’est pas toujours très «clean» et c’est vrai que c’est gênant à force. C’est triste à dire mais généralement au bout du weekend notre application est fonctionnelle mais pas du tout maintenable.</p><p><strong>Bref pour conclure</strong>, je continuerai à faire des hackathons mais moins fréquemment. Je me rends compte que mes amis les plus passionnés par la technique sont aussi de plus en plus lassés de ces concours. Peut être que ce terme “hackathon” n’a plus rien à voir en rapport avec le hack mais que c’est en réalité devenu un nom fourre tout pour attirer en même temps les développeurs, makers et esprits d’entrepreneuriat. Cela dit, ça m’a permis de faire énormément de rencontres, d’apprendre beaucoup et de souvent me retrouver pendant un week-end avec des passionnés comme moi et ça, ça n’a pas de prix. En aucun cas ces participations n’ont été une perte de temps pour moi. J’espère que cet article vous aura inspiré et que si vous n’avez jamais fait ce genre de concours vous savez désormais un peu plus à quoi vous attendre. Sachant qu’il ne faut jamais faire de généralité. N’hésitez pas vous aussi à me faire vos retours d’expériences à ce propos. Pour lire plus mes prochains articles n’hésitez pas à visiter mon <a href="http://benjamincoenen.ovh/">blog.</a></p><p><strong>Bnjjj</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f6d998e4a90" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>