<?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 Julien Janvier on Medium]]></title>
        <description><![CDATA[Stories by Julien Janvier on Medium]]></description>
        <link>https://medium.com/@jjanvier?source=rss-8eb5d94a1dea------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*w8cHk9IBrZ1ocJaX9KdToQ.jpeg</url>
            <title>Stories by Julien Janvier on Medium</title>
            <link>https://medium.com/@jjanvier?source=rss-8eb5d94a1dea------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 14:46:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jjanvier/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[Akeneo PIM 3.0, let’s tidy up!]]></title>
            <link>https://medium.com/akeneo-labs/akeneo-pim-3-0-lets-tidy-up-a91d986bf5bb?source=rss-8eb5d94a1dea------2</link>
            <guid isPermaLink="false">https://medium.com/p/a91d986bf5bb</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[team-collaboration]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Julien Janvier]]></dc:creator>
            <pubDate>Mon, 17 Dec 2018 16:17:41 GMT</pubDate>
            <atom:updated>2018-12-18T09:21:18.015Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uGBCzl--J7rYFAKd2yuKLA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/photos/vpR0oc4X8Mk?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Samuel Zeller</a> on <a href="https://unsplash.com/search/photos/tidy?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Since its creation in 2013, Akeneo has been continuously growing and evolving. The product, the team, the offices, the code, everything has changed. Every single time, changes were never introduced just for the sake of it. It has rather been a necessity, an adaptation aimed to try to solve a new problem, to catch a dawning opportunity or to better answer a problem we better fathom.</p><p>This post will be about the latest “big” change of the code base for the upcoming PIM 3.0: its reorganization by business concerns. As usual, we’ll provide the tools to handle this change smoothly in your projects. The public API didn’t change, we just tidied up all the classes in different namespaces. Actually, that change is not <em>that</em> “big” for <em>you</em>, even it’s crucial for us.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ju8datKby_zVEAlW3Psl9A.png" /><figcaption>Akeneo PIM 2.3 on the left vs Akeneo PIM 3.0 on the right</figcaption></figure><h3>We’ve been growing…</h3><p>What do you think the following figures relate to: 5 in 2013, 9 in 2014, 13 in 2015, 23 in 2016, 39 in 2017 and 50 in 2018? Our number of customers? Our number of partners? No, actually, it’s the headcount of people working in the product team. At the time of this post being written, more than 30 of them work on our main product: the PIM.</p><p>Now let’s take a look at the number of lines of PHP in the PIM per version: 90k in 1.0, 190k in 1.4, 390k in 1.7, 460k in 2.0 and 510k in 2.3. Yes, it’s constantly growing. Of course it comes to the fact that for each release, we ship new features.</p><blockquote>In a matter of 5 years, code base is 5 times larger and headcount has been multiplied by 10.</blockquote><p>Building a product is an extremely pleasant and exciting journey. It’s a never ending trip, with more and more cities to visit (aka features or products to build), luggage to carry (aka code base to maintain) and friends to meet (aka teammates to onboard). However, an enterprise seminar gathering 150 people does not require the same logistics and organization than a trip with 3 friends. It goes exactly the same for our product and our product team.</p><h3>How do we work at Akeneo?</h3><p>Before digging into the problems we are currently facing, and the reasons why we believe a code reorganization will be the stepping-stone to solve them, we have to understand how we built the PIM so far, from an organizational, business and technical point of view.</p><p>As you may know, our product team is divided into squads. Each squad is an independent cross functional small group which is made of developers, a product owner, a UX designer and a devops. They have to take care of a specific subject and lead their mission successfully, whichever way they deem appropriate. We are happy with this way of working and organization since we introduced it, mid 2015. It answered a lot of problems we encountered in the past.</p><p>Understanding what hundreds of customers need and imagining which features could serve them best is already a tough exercice. But if you also take into account the cost of delay, the schedule of the squads, the risks, the financial aspects, the sales pipeline, the Community and Enterprise editions, the on-premise and SAAS versions, the support and maintenance, the improvements, the new features and the market targets, it becomes a headache. This strategic management is complex by nature. There is no one-size-fits-all type of answer that would match all criteria. There is no one-size-fits-all type of answer that would please all the persons impacted by those decisions. That’s why, sometimes, in the past, we had to leave some existing features aside to be able to ship a brand new product or component. For instance, a squad could give birth to a feature and then move on to something else. Once shipped, the feature becomes the responsibility of all the different squads. This kind of project management is not a problem per se. With a small team owning the whole product, it’s totally viable. But it becomes harder with a larger organization and a far bigger product.</p><p>Most of the bundles that exist in the PIM 2.3 were already there at the release of the 1.0. To be more precise, 11 bundles out of the 20 existing in PIM 2.3 Community Edition originally comes from the version 1.0. Some internal parts have been totally revamped, the storage has evolved twice, the business code has been decoupled from the infrastructure, but still, from a purely macro perspective, the code organization has not changed that much over the last 5 years. The only noteworthy change on that side appeared on the Enterprise Edition; each squad created its own folder dedicated to the feature they were in charge of and tried to isolate the most possible its code from the rest of the code base.</p><p>All of that worked well. Well, that <em>works</em> well.</p><h3>So, everything sounds good, why such a change?</h3><p>Apart from this idealistic depiction, the squads working on the PIM face mostly two important challenges:</p><ol><li>We feel it’s getting more and more difficult to ship a new feature promptly (or to improve an existing one). There is no reason to panic now, but the sooner we act, the easier and cheaper it will be.</li><li>We feel it’s getting more and more difficult to onboard a new teammate in the PIM. The application is so huge that it’s now impossible to understand and master all the functional and technical aspects.</li></ol><p>Both difficulties are rooted in the technical debt as well as in the current squad organization and the project portfolio management. On a daily basis, this translates into:</p><ul><li>Some parts of the code are too tightly coupled: changing a class here can cause a piece there to break.</li><li>Some features are not open-closed proof: from a functional point of view, some features modify an existing behavior, instead of extending it.</li><li>Builds are too long: regarding our tests, we chose quantity over quality by a lack of experience.</li><li>Maintenance is sometimes complex: as each developer joins the maintenance squad once in a while, on occasions, you may have to fix something you never heard about before.</li><li>Collective code ownership is hard to maintain: when a group become too numerous it’s a natural tendency that “the responsibility of everybody” turns slowly into “the responsibility of nobody”.</li></ul><p>Absolutely none of these problems is serious. Some may take time, some may require work, but none of them is insurmountable or out of control. We just try to pay close attention to early warning signs.</p><h3>This is not <em>just</em> a code reorganization</h3><p>We believe we can solve the problems listed above by giving squads more autonomy. We believe that with guidance, nurturing and autonomy, squads will deliver more value more frequently to our customers. We believe we would be more efficient if each squad had a smaller and well defined perimeter. How to achieve that? More or less, the squad α would officially be responsible of the features B, D and E while the squad β would officially take care of A and C. In that case, a squad could:</p><ul><li>Capitalize on its functional knowledge.</li><li>Make strong choices that impact them, and only them.</li><li>Regularly deliver functional improvements on their expertise scope.</li><li>Prioritize their own functional debt.</li><li>Prioritize their own technical debt.</li><li>Take care of their own maintenance.</li><li>Take care of their own tests.</li></ul><p>To achieve that, we need three different and complementary things:</p><ol><li>Reorganize the code base so that we effectively see and understand what are the features A, B, C, D and E. As of today, the code base does not reflect the existing functional parts of our business.</li><li>Minimise the impacts between features so that the squad α can’t easily break the work of the squad β (and vice versa).</li><li>Carefully map squads to features. This is for sure the most complex part, as it may eventually impact the way we prioritize the functional roadmap. For instance, it’s easy to prioritize D over B and E, but it becomes more difficult to prioritize A over B, D and E.</li></ol><p>We are confident it’s the right path to follow. During the last months, two squads worked this way on two different upcoming Enterprise features. Their code base is isolated, their tests and builds are independent from the rest of the PIM. They are more autonomous, happy and efficient. They feel more productive and the feedback loop between the squad and the stakeholders is shorter. They feel more confident about their code base, to maintain it and to make it evolve and change.</p><p>This blog post comes to an end. It focused mainly on the reasons why we <em>needed</em> to reorganize the code base. The next one will detail how we achieved this reorganization and what are the impacts on a project. It will be more technical and concrete. Stay tuned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a91d986bf5bb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/akeneo-labs/akeneo-pim-3-0-lets-tidy-up-a91d986bf5bb">Akeneo PIM 3.0, let’s tidy up!</a> was originally published in <a href="https://medium.com/akeneo-labs">Akeneo Labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Top3 Talks at NewCrafts Conference]]></title>
            <link>https://medium.com/jjanvier/my-top3-talks-at-newcrafts-conference-d48aef1a0064?source=rss-8eb5d94a1dea------2</link>
            <guid isPermaLink="false">https://medium.com/p/d48aef1a0064</guid>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[craft]]></category>
            <category><![CDATA[bdd]]></category>
            <category><![CDATA[software-design]]></category>
            <dc:creator><![CDATA[Julien Janvier]]></dc:creator>
            <pubDate>Wed, 06 Jun 2018 11:08:19 GMT</pubDate>
            <atom:updated>2018-06-06T11:08:19.740Z</atom:updated>
            <content:encoded><![CDATA[<p>Three weeks ago I attended the <a href="http://ncrafts.io/agenda">NewCrafts Conference</a> which took place in Paris. Here is my very short feedback about this amazing event, with the 3 talks I enjoyed the most before closing with my general impressions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7JQMPak8nxJLtyZD8UnirA.jpeg" /><figcaption>Paul Rayner at NewCrafts Conference</figcaption></figure><h4>#3. Sandro Mancuso — A Case for Outside-In Design</h4><p>In this talk, the author of “The Software Craftsman” describes outside-in development: “an approach that focuses on building just enough well-engineered code to satisfy an external need, reducing accidental complexity by removing speculative work”.</p><p>Sandro Mancuso starts by telling a hard truth: we, as developers, all have design biases. Whether they are structural (procedural, object, functional…), architectural (ports and adapters, CQRS, performances, micro services…) or directional (domain first, persistence first…), we are all concerned. When the “domain first” bias reaches its height, it can for instance lead to building a complete backend system without having started the frontend, or to code a brilliant domain model that turns out to be useless. The inside-out design, as every method, is not a recipe to follow blindly.</p><p>Then, Sandro Mancuso advocates for outside-in development by explaining each practice he uses and what problem it aims to solve:</p><ol><li><a href="https://www.innovationgames.com/product-box/">Product box</a> helps to identify the main areas and features of the system.</li><li><a href="https://www.impactmapping.org/">Impact mapping</a> allows to agree on what to be built according to their value.</li><li><a href="https://en.wikipedia.org/wiki/User_journey">User journey mapping</a> helps to understand the business flow of each feature.</li><li><em>Mockups</em> define a contract between presentation and application layers according to the presentation needs.</li><li><em>Outside-in TDD</em> builds well designed and tested features according to a well defined contract.</li></ol><p>Every practice should be used at different frequencies. From every 6 to 12 months for the <em>product box</em>, to a daily usage for <em>outside-in TDD</em>.</p><p>If you want to know more about outside-in design, you can take a look to the <a href="https://speakerdeck.com/sandromancuso/ncrafts-a-case-for-outside-in-design">slides</a> and to the original <a href="https://codurance.com/2017/10/23/outside-in-design/">blog post</a>.</p><h4>#2. David Evans — Telling Better Stories</h4><p>I’m a BDDphile, even if I know that I don’t know how to write stories correctly. That’s something I’ve been trying to improve for a few months now. This is the reason I bought “<a href="https://fiftyquickideas.com/fifty-quick-ideas-to-improve-your-user-stories/">Fifty Quick Ideas To Improve Your User Stories</a>” for last Christmas. Shame on me, I haven’t read the book yet. So I couldn’t miss the presentation of its co-author, David Evans.</p><p>David Evans starts by talking about the famous “As a… I want… So That…” template. About the fact that despite being a good simplification, this template ruined the way we write stories. It’s now taken as a recipe to follow. It has became so popular that it hides the true meaning of stories, which is <em>to tell something</em>. He recommends to use other templates to clearly make the distinction between the sphere of influence and the zone of control of the story. In this regard, “In order to…, For…, We will…” is his recommended choice.</p><p>Another problem is that often the why part is poorly written. It’s either a lazy restatement of the what part or it’s too high and completely non specialized. Building a value map of the project can give a few potential reasons of why this story is important.</p><p>Sometimes the complexity of the story is not clear, because we don’t know how big the change is. To avoid this, a “whereas currently” part can be added to describe the current behavior and thus reflect how the change is.</p><p>The talk was fun, dynamic and sadly too short. I wish David Evans had the time to explain his fifty ideas. But no problem, I’ll read his book soon ;)</p><h4>#1. Paul Rayner — Fighting the Invisible Enemy</h4><p>Paul Rayner once again demonstrated what an amazing speaker he is. I’m always fascinated by people able to make you wonder: “This is so simple, so evident, why didn’t I think about it before?”. And that’s exactly what this talk is about for me.</p><p>I feel it everyday in my work, I see it everyday in my team, I suffer from it everyday in my company. The flow of work is continuously slowed down, diverted or even stopped by invisible and unmeasured queues. Even with retrospectives and continuous improvements, there is no way to work smoothly. According to Paul Rayner, the Agile community doesn’t put emphasis on flow. It’s focused about trying to fix structural problems. Capacity is seen as parking lot, instead of thinking about it as a freeway. On a freeway, the most important is to avoid congestion by all means. On a parking lot, the goal is to maximise its utilization. This simple analogy explains so well a feeling I’ve been struggling to express for such a long time. I feel it, see it and suffer from it everyday, even if I work in a so-called Agile company. We see capacity as a parking lot, which leads us to take the wrong decisions…</p><p>An event storming session can be used to depict the development flow and identify hotspots. Then, queues should be measured so that we can manage and constrain the most expensive ones. When queues start to grow, we should make quick and forceful interventions. At the end of the talk, Paul Rayner lists several ways to deal with emergent queues, to <a href="https://www.slideshare.net/virtualgenius/fighting-the-invisible-enemy-paul-rayner-newcrafts-2018">fight the invisible enemy</a>.</p><h4>That was just… amazing!</h4><p>The agenda of this conference was sick. There are so many other talks that I enjoyed: Jessica Kerr with “The Origins of Opera and the Future of Programming”, “Endangered Species: Senior Craftsmen” by Cyrille Dupuydauby, Felienne Hermans with “What is programming anyway?” and the “BugsZero Kata” driven by Johan Martinsson.</p><p>There are also so many slots where I struggled to choose where to go as everything seemed so damn interesting! That’s why I’m looking forward to watch the videos of Jenny Martin about “Death by User Stories”, Bruno Boucard &amp; Thomas Pierrain with “Discover Example Mapping: the real essence of BDD” and Adrian Bolboacă with “Evolutionary Design — Evolve your code like growing a live organism”.</p><p>It was the perfect balance of talks, workshops, lightnings and breaks. Speakers and topics were diverse and high-quality. Thanks to the organizers of this event. It was my first time at NewCrafts, but definitely not the last 😊.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d48aef1a0064" width="1" height="1" alt=""><hr><p><a href="https://medium.com/jjanvier/my-top3-talks-at-newcrafts-conference-d48aef1a0064">My Top3 Talks at NewCrafts Conference</a> was originally published in <a href="https://medium.com/jjanvier">jjanvier</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Feedback From the DDDx 2018 Conference]]></title>
            <link>https://medium.com/jjanvier/feedback-from-the-dddx-2018-conference-d698161f59e9?source=rss-8eb5d94a1dea------2</link>
            <guid isPermaLink="false">https://medium.com/p/d698161f59e9</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[ddd]]></category>
            <category><![CDATA[modelling]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <dc:creator><![CDATA[Julien Janvier]]></dc:creator>
            <pubDate>Fri, 04 May 2018 11:05:36 GMT</pubDate>
            <atom:updated>2018-05-04T11:05:36.164Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/593/1*S0ahf1TJ_otu164_brjAOw.jpeg" /></figure><p>Last week I attended the <em>DDD eXchange</em> conference which took place in London, at a fabulous place called <em>CodeNode</em>. I had the chance to win a ticket thanks to a contest organised by the <em>DDD Paris meetup</em>. Kudos to them!</p><h3>DDDParis on Twitter</h3><p>The random draw winner of DDDx 2018 ticket for #skillsmatter is Julien J. See you there for a great #DDX</p><p>It was my first time at <em>DDD eXchange</em> and I didn’t know what to expect, especially compared to <em>DDD Europe</em> that I attended twice.</p><p>Let’s start maybe by the most important. The conferences I liked the most listed by chronological order. Then we’ll continue with the few disappointments I experienced during this conference.</p><h3>The conferences I liked the most</h3><h4><strong>Marcello Duarte — Lean and Functional Domain Modelling</strong></h4><p>Coming from the PHP world, when the co-creator of <a href="http://www.phpspec.net/"><em>PhpSpec</em></a> is part of a conference schedule, you have to go. I personally use <em>PhpSpec</em> every working day, and I’m grateful to Marcello Duarte.</p><p>The talk was a summary version of the 2 days workshop he usually gives. It started with the importance of learning functional programming nowadays and a reminder about algebra and Algebraic Data Types. Then he presented a simple domain problem: a cafe which wants to reward its loyal customers. Marcello illustrated the modelling of this problem step by step, with Scala.</p><p>It was very interesting, but maybe too quick at the end (well, at least for me). This presentation made me want to dig further into Scala and to assist one of Marcello’s workshop.</p><h4><strong>Cyrille Martraire — Domain-Driven Dependencies</strong></h4><p>Ah, my favorite topic! Dependencies and coupling! The talk concerned all the classical aspects of this subject: independence from a service, independence from the framework and independence from the infrastructure. To achieve that, a developer has many tools in his box: inversion of control, hexagonal architecture, adapter, flyweight and bridge patterns, as well as the DDD strategic patterns with the knowledge of the downstream/upstream relationships.</p><p>Cyrille Martraire highlighted that in a downstream/upstream context, the direction of the relationship is not determined by the side which calls the other; but rather by which side uses the language of the other. He also made me discover the concept of “<a href="https://en.wikipedia.org/wiki/Object_Modeling_in_Color">UML in color</a>”.</p><h4><strong>Alberto Brandolini — Joys and Pitfalls of Collaborative Modelling</strong></h4><p>In this talk, the inventor of the event storming gave a lot of useful tips and tricks about how to accelerate the <em>Darwin selection</em> of a successful collaborative modelling. For instance:</p><ul><li>Try to sound stupid, even by asking obvious questions.</li><li>Model out loud. Don’t just read in your head.</li><li>Establish the “1, 2, 3, 4, flesh out something” rule during a modelling phase. Errors are better than blanks. Errors lead to discussions while blanks just lock the modelling process.</li><li>Rush to the goal. Focus on the most important happy path first. Then and only then, explore alternatives.</li><li>Don’t stop for alternatives. Use purple stickies instead and continue on the path you were currently exploring. Come back to the purple/problem stickies once this path has been investigated.</li><li>Only talk about visible things.</li><li>Raise the bar by not using a simple use case. Nothing valuable will come from a very simple example.</li><li>Try some variations of terms, and see what fits the best.</li><li>Take some breaks.</li><li>Split the group if needed. Then compare both solutions. Discussions will be focused on what the two sub groups did differently.</li><li>Once modelling has progressed, use the “3 minutes silence” round. To make everybody think about what they have achieved.</li></ul><p>Ultimately, people and personalities are what matter the most. And collaborative modelling is all about diversity and respect.</p><p>As always with Alberto Brandolini, I didn’t see the clock ticking. I warmly recommend this talk for every person that tries to facilitate an event storming session.</p><h4><strong>Cyrille Martraire — Interviewing Domain Experts: Heuristics from the Trenches</strong></h4><p>The embodiment of the French accent, round 2. Cyrille Martraire substituted Greg Young who couldn’t attend <em>DDDx</em>. And honestly, I was not disappointed. This was, in my opinion, the best talk of the whole conference. Since I read Nick Tune and Scott Millett’s <em>Patterns, Principles, and Practices of Domain-Driven Design</em>, and took note of the “powerful questions” to ask to domain experts, I have been looking to know more about it; without any success so far. This was the first conference I’ve seen that dealt with the topic.</p><p>A few heuristics and tips given by Cyrille Martraire:</p><ul><li>Learn about the domain before the interview. There are books for every domain.</li><li>Ask a precise question to start a conversation. For instance, “I’d like to understand how an insurance policy works”.</li><li>Apply active listening. Don’t change words during note taking.</li><li>Don’t interrupt, take notes for later.</li><li>Underline every new term, to be able to ask questions about it later.</li><li>Try to find differences (or not) between terms that look similar.</li><li>Establish credibility with sentences like “I know that xxx, but…”.</li><li>Ask for sample documents/data.</li><li>Best way to get the right answer: propose something wrong and let people correct you. Because people are happy to correct you.</li><li>Use your past knowledge into your new domain.</li><li>Note when the answer is not convincing.</li><li>Come with printed screenshots of the current running application.</li><li>Never think that you’re smarter than the expert, even if you know well the domain. Always ask for validation.</li><li>Better conversations happen in cafes and bars. Not in meeting rooms.</li><li>Ask key questions. Like: “Is it always true? Is there a case when it’s not true?”.</li><li>Most of the knowledge is tacit. Extract it with questions like “What if… ?”</li><li>Several domain experts together may lead to confusion. Or possibly be the sign that several bounded contexts are in the middle the conversation.</li></ul><p><em>Bref, vraiment, merci Cyrille !</em></p><h4><strong>Mathias Verraes — Design Heuristics</strong></h4><p>Last talk of the conference, and the one I was expecting the most, as Matthias Verraes is one of my coding heroes. I learnt so much from his blog posts a few years ago. OK, enough sentimentalism. Let’s go back to the talk.</p><p>Well, it was not a talk per se, but more of a kind of giant participatory exercice with the use of a whiteboard and sticky notes. Matthias Verraes presented briefly three pieces of software and how they were linked together. Something similar to this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/430/1*iK0Kc4i-BmIZjKHbmQ6ZDA.jpeg" /><figcaption>What comes to your mind when you see such a model?</figcaption></figure><p>Three stickies with an <em>Invoice</em>, a <em>Payment</em> and a random <em>Payment Behavior</em>. We didn’t know much more about those services or contexts, but it was not the point. When we work on a model, like this simple one defined by three stickies, we try to answer questions such as:</p><ul><li>Should we improve it?</li><li>Can we improve it?</li><li>Does it fit our problem?</li><li>What can we deduce from it?</li></ul><p>The goal of the exercice was to cogitate about all heuristics that we usually use during our modelling sessions to answer those questions. Often, we answer naturally, thanks to our previous mistakes or our past experiences, without even thinking how the response comes.</p><p>With the help of the crowd, Matthias Verraes highlighted a lot of modelling heuristics that we use on a daily basis as developers. Among them:</p><ul><li>Draw boxes and arrows: if you end up with a circle, you surely have a problem.</li><li>Check the direction of arrows.</li><li>What about changing the direction of arrows?</li><li>What about removing an arrow?</li><li>Push vs pull. Who will trigger the communication?</li><li>Events. What happens in the system?</li><li>Use examples. Does the model reflect reality?</li><li>Look for look alike, but are not alike.</li><li>Temporality. How does the system behave during time?</li><li>Should the publisher ignore the needs of a consumer?</li><li>Lifecycle. What are the different states/phases of the system?</li><li>Code ownership. Who is responsible of this part?</li><li>Rate and source of change. Does this part change often? Who is responsible of those changes?</li><li>Extract and share. Can a sub-part be taken out the system to simplify it overall?</li><li>and much more…</li></ul><p>All of this should, of course, not be considered as rules to follow. But they are questions that should be asked or clues that could be explored to try to improve a design.</p><p>To be honest, it wasn’t exactly what I expected of the presentation. Actually, it was way better! Especially with the active participation of the audience. This is definitely something I’ll think about more during my next modelling sessions. As Matthias Verraes suggested, I’ll try to create my own modelling heuristics’ box.</p><h3>Just a few disappointments</h3><h4>The unconference</h4><p>worThe unconference, a free slot where people can talk freely about whatever they want, is a great idea. And it was very well organized. Sadly, a lot of persons already left before it began. Also, the result of such talks will considerably vary depending of the group you are in. Too few people could lead to not enough diversity in the conversation while too many people could lead to boredom, as not everybody is able or has the time to talk (which was my case). Maybe a good solution would be to limit the number of persons per topic?</p><h4>Crowd/speakers, all developers?</h4><p>Same assessment as for <em>DDD Europe</em>. Maybe I’m totally wrong but I have the feeling that the very vast majority of people is made up of developers (or software engineers, software crafters, architects, software coaches, you name it). I’d like to see more variety: product owners, domain experts, product managers. More importantly, I’d like more topics focused around the dynamics of creating a software within a mixed team.</p><p>But perhaps it’s not the intention of a DDD conference, and I should look for something else. As it’s an important topic to me, I’ll dig more into those those questions in a coming post.</p><h3>Conclusion</h3><p><em>DDDx London 2018</em> was amazing! The conferences I’ve attended, the warm atmosphere, as well as discovering this vibrant city of London. Everything was great! Thanks to all the speakers, to the people I’ve talk to and to <em>SkillsMatter</em> for the organization. Most of the talks are already viewable <a href="https://skillsmatter.com/explore?q=tag%3Adddx">here</a>.</p><p>It was so good that I already bought my early-bird ticket for next year. See you next year <em>DDDx</em>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d698161f59e9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/jjanvier/feedback-from-the-dddx-2018-conference-d698161f59e9">Feedback From the DDDx 2018 Conference</a> was originally published in <a href="https://medium.com/jjanvier">jjanvier</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Re-building the storage from the ground up]]></title>
            <link>https://medium.com/akeneo-labs/re-building-the-storage-from-the-ground-up-d857bf497c32?source=rss-8eb5d94a1dea------2</link>
            <guid isPermaLink="false">https://medium.com/p/d857bf497c32</guid>
            <category><![CDATA[pim]]></category>
            <category><![CDATA[storage]]></category>
            <category><![CDATA[akeneo]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <category><![CDATA[mysql]]></category>
            <dc:creator><![CDATA[Julien Janvier]]></dc:creator>
            <pubDate>Thu, 08 Jun 2017 07:21:16 GMT</pubDate>
            <atom:updated>2017-06-08T07:21:16.873Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V_jYhHjiZOeNALMUMYejCQ.jpeg" /></figure><p>This is the third post of a series dedicated to the way we store products at Akeneo. Nicolas previously told <a href="https://medium.com/akeneo-labs/story-of-storage-9dbc27090de0">the story of products’ storage</a> and explained the <a href="https://medium.com/akeneo-labs/single-product-storage-28d92f35cbd7">soul-searching</a> we did at the end of 2016 regarding this critical part of the application. In this post, we’ll go one step further. What would it be to implement this ideal storage? What would it be to <strong>implement</strong> <strong>a single storage in Akeneo PIM</strong>?</p><h3>A Recap of our Ideal Single Storage</h3><p>Our ideal single storage could be explained as a simple equation:</p><blockquote>single storage = MySQL + product values into a JSON field + Elasticsearch</blockquote><p>The storage should work the same for both Community and Enterprise editions and should be able to handle the same amount of data. And as you can see, the number of products or values is not part of the equation anymore.</p><p>As explained in the previous post, our first POC confirmed that a standalone MySQL allows us to store our product values in a JSON field.</p><p>We had no doubt about the fact that Elasticsearch would fit our needs. We already had some experience with this tool as we provide a special bundle that handles product searches inside very large catalogs for our most challenging customers.</p><h3>Re-Modeling Product Values</h3><p>This approach has a direct impact on the <a href="https://github.com/akeneo/pim-community-dev/blob/1.7/src/Pim/Component/Catalog/Model/AbstractProductValue.php">product value model</a>. Even if this model is the key concept of our application, it suffers from several design flaws.</p><p>It is tied to the <a href="https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model">EAV implementation</a>, via the methods <em>setMedia</em> and <em>setNumber </em>for instance. Also, you don’t know directly which kind of value you are manipulating. Is it a metric? A number? A reference data? To get this information we have to look at the attribute linked to the value.</p><p>It has no dedicated business oriented method per value type. It would be really useful to have a <em>getUnit</em> method on metric values for instance.</p><p>It is handled by Doctrine’s unit of work, which, in itself, is not a problem. But when a product has thousands of values, it has direct consequences on memory usage, and by extension, on the application speed, especially during imports and exports.</p><p>It has been designed as an entity instead of being what it really is: a <a href="https://martinfowler.com/bliki/ValueObject.html">value object</a>. As a matter of fact, a product value measures, describes or quantifies a characteristic of a product. And a product value which contains “foo” is exactly the same that another value containing “foo”. It has no identity.</p><p>Considering these problems we decided to completely re-model this key object from the scratch.</p><p>We wanted to have one product value class per attribute type. They all share together a <a href="https://github.com/akeneo/pim-community-dev/blob/a5c800d0e2524dc6a87c440dddd6349e43ebe054/src/Pim/Component/Catalog/Model/ProductValueInterface.php">minimum contract</a>. Things are simple now. You know what you work on and it’s even possible to have dedicated business oriented methods depending of the value’s type.</p><p>We wanted to make them immutable, as real value objects are. We provided dedicated factories, to facilitate their creation.</p><p>We wanted to keep them out of Doctrine’s unit of work. Doctrine is still responsible for loading and saving the JSON field that contains all the values. But we transform this JSON representation into real Product Value objects by ourselves.</p><p>We wanted to offer a lot of design sugar. So we enriched the product layer API with meaningful objects, such as a dedicated collection of values or a factory that is the single entry point for creating any product value object from data provided as standard format.</p><p>The interesting thing about this refactoring, is that it has no serious impact on the product object API, nor does it impact the public APIs of features dealing with products. Actually, all those important changes are really deep in our internal API.</p><h3>Re-work most of the features handling products</h3><p>The re-modeling of product values had direct impacts on all features regarding products. Among these, can be mentioned variant groups, completeness, drafts, proposals or published products.</p><p>Some features that we coded in 2013/2014 haven’t been changed that much since their creation. Like published products or product reverting for instance. And they didn’t even use the “standard” layer we are used to now: product updater, validator and saver. They were living with their own, duplicated, and often complex, code. We took the opportunity to simplify those features by using the standard layer and all the brand new classes we introduced. We end up with less code, hopefully less bugs, and more shared knowledge and confidence within the team about these antique parts of the application.</p><p>But this refactoring doesn’t provide only code industrialization. It also brings its share of simplification. For instance, there is no more need to struggle in order to guess the changes made on the values of a product. Everything’s in one single place: in the JSON field.</p><p>The main aspect to keep in mind is that most of the userland API regarding these features has not changed at all. Again, it’s mainly a big <em>internal</em> refactoring.</p><h3>Not a silver bullet…</h3><p>Even if we are really confident about the usefulness of this project, we know it’s not a silver bullet. And as every choice made in the development world, it comes with limitations, trade-offs and considerations to keep in mind.</p><p>Storing the flexible product values in a JSON field and systematically querying our product values through an Elasticsearch index implies a strong and acknowledged technical limitation: we can’t query product values directly in MySQL anymore. To handle this, we kept the core ideas of our current <a href="https://marketplace.akeneo.com/package/elasticsearch-bundle">ElasticsearchBundle</a>: when saving a product in MySQL, its data is indexed in Elasticsearch. However, this change has been introduced by implementing new filters for our product query builder. The <a href="https://github.com/akeneo/pim-community-dev/blob/1.7/src/Pim/Component/Catalog/Query/ProductQueryBuilderInterface.php">querying contract</a> remains exactly the same.</p><p>Even if it is very common in web applications, Elasticsearch introduces an extra complexity regarding the product installation and configuration. This core change also implies extra work regarding migrations of existing customers to the next versions. We’ll explain how we handle these two aspects in an upcoming and dedicated post.</p><h3>But it’s worth it!</h3><p>We are aware these changes will affect our ecosystem. However we really <em>do </em>think this is for the best in the mid-term. Whether it be for our development team, our product owners, our contributors, our integrators or our customers.</p><p>First, providing a single product storage to handle all cases drastically simplifies our technical stack. It facilitates the on-boarding of new developers that can now focus on a single way of storing and manipulating data. It also helps more seasoned developers on Akeneo PIM to improve their expertise by being more focused on this unique stack. The fine tuning and optimization of the application or server infrastructure becomes easier. Finally, the cost of building and maintaining new features, projects or extensions also benefits from this standardization.</p><p>Talking about extensions, the new design of product values also has a positive impact. In the current version, adding a custom attribute type requires an override to the native product value class. As you can override only once, you can’t install two extensions adding their own attribute type. With the new implementation, no more need of overriding, you just have to implement an interface and voilà!</p><p>This implementation also unleashes future innovations and features. For instance, having a native search engine in the stack opens a lot of possibilities, the first one being a complete full text search. This new design will also allow to install new attribute types as plug-and-play extensions, just as easy as installing an add-on in Firefox.</p><p>Last but not least, this storage has been built from day one with scalability in mind. It allows us to target larger product catalogs and to support the growth of both our existing enterprise customers and community users.</p><h3>Fair enough. But when?</h3><p>The implementation has just been <a href="https://github.com/akeneo/pim-community-dev/pull/6254">merged</a> on the master branch of our repository. So it will be available in Akeneo’s next version. It has been a 5 months work, requiring 5 core team members who opened more than 300 pull requests.</p><p>In the next posts of this series, we’ll detail the set of tools we’re building to facilitate the installation and the automation of the migration. We’ll also share and explain our benchmarks regarding performances and scalability.</p><p>Stay tuned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d857bf497c32" width="1" height="1" alt=""><hr><p><a href="https://medium.com/akeneo-labs/re-building-the-storage-from-the-ground-up-d857bf497c32">Re-building the storage from the ground up</a> was originally published in <a href="https://medium.com/akeneo-labs">Akeneo Labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Akeneo PIM 1.5 and the PHP 7 Support of the CLI]]></title>
            <link>https://medium.com/akeneo-labs/akeneo-pim-1-5-and-the-php-7-support-of-the-cli-fa5a87325438?source=rss-8eb5d94a1dea------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa5a87325438</guid>
            <category><![CDATA[akeneo]]></category>
            <category><![CDATA[php7]]></category>
            <category><![CDATA[php]]></category>
            <dc:creator><![CDATA[Julien Janvier]]></dc:creator>
            <pubDate>Fri, 11 Mar 2016 12:41:06 GMT</pubDate>
            <atom:updated>2016-03-11T12:41:06.451Z</atom:updated>
            <content:encoded><![CDATA[<p>Recently, <a href="https://medium.com/u/da6e015fab0c">Nicolas Dupont</a> discussed about <a href="https://medium.com/akeneo-labs/akeneo-pim-php7-and-hhvm-compatibility-98e7fe0ce582#.bd1ive8os">our unit tests running on PHP 5.4, PHP 5.5, PHP 5.6, PHP 7 and HHVM</a>. With <a href="https://github.com/akeneo/pim-community-dev/pull/4005">this pull request</a>, we achieved another step on the road toward PHP 7 support.</p><h4>TL;DR</h4><ul><li>Akeneo 1.5 CLI (imports, exports, mass operations, versioning process, completeness calculation…) now works with PHP 7 and MySQL as storage engine, and that rocks!</li><li>the hybrid storage engine MySQL/MongoDB is not yet compatible with PHP 7 due to Doctrine not supporting PHP7 with MongoBD</li></ul><h4>Benchmarking our representative catalogs</h4><p>Depending on the size of the catalog, there are 2 ways to store product data:</p><ul><li>either the whole catalog is stored in MySQL</li><li>either products data (and only products data) is stored in MongoDB while the other parts of the catalog remains in MySQL</li></ul><p>To determine wether you should use the hybrid storage or not for your catalog, simply follow <a href="http://docs.akeneo.com/latest/reference/scalability_guide/more_than_5M_product_values.html">this rule</a>.</p><p>To ensure the application works correctly, we audited it with <a href="http://docs.akeneo.com/latest/reference/scalability_guide/representative_catalogs.html">3 representative catalogs</a>. The <em>small</em> and <em>medium</em> catalogs can be used with the regular MySQL storage engine, while the <em>large</em> catalog can only work with the hybrid storage engine MySQL/MongoDB. These catalogs contain respectively 5k, 50k and 1M products resp. 160k, 3.6M and 52.7M product values.</p><p>I performed a series of benchmarks on my local machine (Core-i7@2Ghz, 8GB RAM) with xdebug disabled, in production environment of course. My PHP versions are 5.6.17–3 and 7.0.3–5 as of Debian testing. The following commands have been tested:</p><ul><li>installation of the PIM (<em>pim:install</em>): it checks the requirements of the PIM, creates the database, imports the catalog without the products data and installs the assets.</li><li>import new products (<em>akeneo:batch:job csv_product_import — config=’{”realTimeVersioning”: false}’</em>): all products of the catalog are imported. As no products exist at this moment, there are only product creations. Real time history update (versioning) is disabled to allow running the versioning refresh command later.</li><li>import updated products (<em>akeneo:batch:job csv_product_import — config=’{”realTimeVersioning”: false}’</em>): all products are once again imported, but they are all updated with random data, no matter their family or their requirements. This is not a real life use case, but it shows what can happen in the worst case: when your products are completely different between each import. Real time history update (versioning) is disabled to allow running the versioning refresh command later.</li><li>versioning process (<em>pim:versioning:refresh</em>): products’ versioning are built to provide a complete history of the products.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*_4rjMARfyXPOOn-P419SDw.png" /><figcaption>php5 vs php7 wih the small catalog</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*D32ukp9w576PCxkUloskKg.png" /><figcaption>php5 vs php7 wih the medium catalog</figcaption></figure><p>Without any surprise, PHP 7 is far more rapid than PHP 5. All operations are between 1.5x and 2.6x times faster. Please do not take these values as granted. These are just benchmarks executed on my local machine and their only purpose is to compare PHP 5 and PHP 7, not to evaluate the PIM efficiency. You can expect better results on a production installation.</p><p>The important thing to notice, is that the bigger the import is, the more efficient PHP 7 is. Also, imports of existing products are even more efficient with PHP 7 than imports of non-existing products. This is surely due to the time spent in the <em>Doctrine Unit of Work</em>, particularly in the <em>computeChangeSets</em> methods. Those methods are CPU greedy and PHP 7 enhancements are particularly efficient on these kind of operations.</p><h4>About the large catalog and the hybrid storage engine</h4><p>As you may know, the PHP MongoDB team recently released a brand new version of their PHP driver called <em>mongodb</em>. This new driver is <a href="https://docs.mongodb.org/ecosystem/drivers/php/#compatibility">compatible</a> with PHP 5, PHP 7 and HHVM and with all Mongo versions (2.4, 2.6, 3.0 and 3.2), which is totally awesome; one driver to rule them all. The legacy driver, called <em>mongo</em>, does <strong>not</strong> support PHP 7 or HHVM.</p><p><a href="https://github.com/mongodb/mongo-php-library/releases/tag/1.0.0">Last month,</a> the Mongo team also released the 1.0.0 of the PHP userland library <em>mongo-php-library</em> which is a high-level abstraction of the new <em>mongodb</em> driver.</p><p>So everything seems perfect no? Well, almost…</p><p>The problem is that Akeneo PIM relies on Doctrine which is not yet compatible with the new <em>mongodb</em> driver and the <em>mongo-php-library</em> as explained in various GitHub tickets <a href="https://github.com/doctrine/mongodb/issues/239">here</a>, <a href="https://github.com/doctrine/mongodb-odm/issues/1292">here</a> and <a href="https://github.com/doctrine/mongodb-odm/issues/1234#issuecomment-143586903">here</a>. This is why I was not able to benchmark the <em>large</em> catalog with the hybrid storage engine.</p><p>But there are some <a href="http://www.doctrine-project.org/2016/02/16/doctrine-mongodb-odm-release-1.0.5.html">good news</a>. First, the Doctrine team is working hard to make the <em>doctrine/mongodb-odm</em> library compatible with the new <em>mongodb</em> driver. And judging by this tweet, it seems on a good way:</p><h3>alcaeus on Twitter</h3><p>Doctrine #MongoDB ODM running on #php7. https://github.com/alcaeus/mongo-php-adapter ... pic.twitter.com/lRJCYCnsOJ</p><p>The other good news is that the upcoming <em>mongodb</em> driver will be supported in the very next versions of the Doctrine libraries:</p><blockquote>The new driver should be properly supported once we release versions 1.1 and 1.3 of the ODM and underlying Doctrine MongoDB library, respectively.</blockquote><p>And last, but not least, they’re working on an <a href="https://github.com/alcaeus/mongo-php-adapter">adapter</a> between the legacy and the new driver. Why? Because the new <em>mongdb</em> driver and its userland library <em>mongo-php-library</em> are a complete rewrite, and are not compatible at all with the former versions. This adapter will allow us to use the new <em>mongodb</em> driver completely transparently, without backward compatibility breaks via Doctrine <em>doctrine/mongodb-odm. A</em>nd once again, it seems on a good way:</p><h3>alcaeus on Twitter</h3><p>Just released Beta 1 for mongo-php-adapter: run #Doctrine #ODM on #php7: https://github.com/alcaeus/mongo-php-adapter/releases/tag/1.0.0-BETA1 ...</p><h4>What’s next?</h4><p>We’ll keep an eye on the progress of the Doctrine team on the new <em>mongodb</em> driver and we’ll try to test it as soon as possible. Let’s cross our fingers for Akeneo PIM 1.6 :)</p><p>To officially support PHP 7 on CLI, we’ll have to include it in our performance test suites and update our documentation.</p><p>Finally, we’ll also study the possibility to make the whole application, including the UI, work and be compatible with PHP 7.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fa5a87325438" width="1" height="1" alt=""><hr><p><a href="https://medium.com/akeneo-labs/akeneo-pim-1-5-and-the-php-7-support-of-the-cli-fa5a87325438">Akeneo PIM 1.5 and the PHP 7 Support of the CLI</a> was originally published in <a href="https://medium.com/akeneo-labs">Akeneo Labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>