<?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 Cédric Teyton on Medium]]></title>
        <description><![CDATA[Stories by Cédric Teyton on Medium]]></description>
        <link>https://medium.com/@cedric.teyton_34486?source=rss-5e81423915d9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*9gTLREKCndvgu64pdWMkLA.jpeg</url>
            <title>Stories by Cédric Teyton on Medium</title>
            <link>https://medium.com/@cedric.teyton_34486?source=rss-5e81423915d9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 18:36:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@cedric.teyton_34486/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[9 Podcasts français qui parlent de Tech en 2024]]></title>
            <link>https://medium.com/@cedric.teyton_34486/9-podcasts-fran%C3%A7ais-qui-parlent-de-tech-en-2024-cda6ace4035c?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/cda6ace4035c</guid>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Thu, 25 Apr 2024 14:07:47 GMT</pubDate>
            <atom:updated>2024-04-25T14:07:47.581Z</atom:updated>
            <content:encoded><![CDATA[<p>Je ne vous apprends surement rien, les podcasts sont en constante croissance, que ce soit par leur nombre de créateurs et créatrices, que de <a href="https://www.notion.so/9-Podcasts-fran-ais-qui-parlent-de-Tech-en-2024-678e3f5768bc4e6389cbc5eef1b9b60d?pvs=21">personnes qui écoutent</a>. Dans ce billet, je vous propose une compilation de podcasts qui parlent de Tech, et vont surement vous intéresser que vous soyez dev, tech lead, engineering manager, CTO ou autre encore.</p><p><em>Je précise que ce n’est pas un classement, seulement des pointeurs qui vous feront peut-être, j’espère, découvrir de nouveaux contenus 🙂</em></p><h3>Tronche de Tech</h3><p>C’est un de ceux que j’écoute le plus régulièrement. Lancé en Juin 2023 par Mathieu Sanchez, CTO d’Acasi, ce podcast fait découvrir la face cachée de la Tech grâce à des invité.e.s qui partagent leurs parcours, notamment leurs premiers pas dans l’informatique, la découverte de la programmation, et aussi des anecdotes marquantes. Bien souvent d’ailleurs, l’anecdote est marquante car elle concerne un bug majeur en prod, bref quelque chose qui n’est pas du tout passé comme prévu et que personne n’a vu venir. C’est un peu ça aussi le charme de la Tech non!? A retrouver toutes les 2 semaines.</p><p>Découvrir <a href="https://feeds.acast.com/public/shows/tronche-de-tech">le podcast</a></p><h3>Les Podcasts Tech.Rocks</h3><p>Tech.Rocks, c’est LA communauté francophone des CTOs et Leaders techniques. Avec au moins chaque moins mois un nouvel épisode, on y parle de management, de visio, de tech, de santé mentale, d’open source, d’inclusion, et plus encore. Si vous êtes CTO et ne connaissez pas ce réseau, je vous invite fortement d’ailleurs à le rejoindre 😉</p><p>Lien du <a href="https://www.tech.rocks/podcasts">podcast</a>.</p><h3>CTO’z</h3><p>Ce podcast porte assez bien son nom, puisqu’il rassemble aujourd’hui près d’une centaine d’épisodes où les CTO et responsables IT partagent leurs parcours, leurs succès, échecs, apprentissages et leurs visions. Le tout animé par Pierre l’Hopitalier. Je trouve assez chouette son idée d’inclure des épisodes “Feedback” où les invité.e.s partagent leurs impressions en 5 min sur un épisode précédent.</p><p>Lien du <a href="https://podcast.ausha.co/cto-z-1">podcast</a>.</p><h3>IFTDD — If This Then Dev</h3><p>269 épisodes pour ce podcast animé par Bruno Soulez, qui est donc bien implanté dans le paysage de la Tech, avec joli rythme de plusieurs podcasts par semaines. Les sujets abordés sont très variés (au moment d’écrire ce billet, les derniers épisodes abordaient la CI/CD, l’Open Source, la Data, l’IA ou encore la blockchain). Un travail titanesque donc pour ce podcast lancé en Juillet 2019.</p><p>Lien du <a href="https://www.ifttd.io/">podcast</a></p><h3>Tech Lead Corner</h3><p>C’est l’instant “auto-promo” 😉 Tech Lead Corner est un podcast que j’ai lancé en Février 2024 et où l’on parle du rôle de <em>Leader Technique</em> avec des Tech Lead, Engineering Manager ou même CTO. Le but est d’aborder en 45 min. en quoi consiste ce rôle, les défis à relever, les postures à avoir (et à éviter également). Il y a certes le volet purement technique, mais on y parle aussi des autres composantes indispensables pour ce type de position: faire grandir les équipes, les coacher, les rendre autonomes, gérer les conflits, trouver la bonne organisation en fonction des personnes.</p><p>Lien du <a href="https://tlc.packmind.com/">podcast</a> (publication toutes les 2 semaines)</p><h3>Developer Experience</h3><p>Lancé en Novembre 2023 par Donatien Léon, ce podcast “<em>aide les développeur.se.s à gagner en expérience, sans parler code</em>”, pour reprendre les termes de la description. Donatien évoque les sujets relatifs aux tech leaders, notamment les questions de management, pour alimenter la vision que chacun.e peut se faire, en tant que dev, sur son évolution future.</p><p>Lien du <a href="https://podcast.ausha.co/developer-experience">podcast</a> (environ 2 par mois)</p><h3>Artisan Développeur</h3><p>Même si il n’est plus actif depuis Septembre 2023, ce podcast est une mine d’or sur tout un tas de sujet, allant de l’artisanat logiciel (Software Craftsmanship), l’évolution du métier de dev, mais également le freelancing. Spécialisé dans le coaching de devs, mais aussi entrepreneur, Benoit aborde un large panel de sujets Tech sans oublier le volet business.</p><p>Lien du <a href="https://artisandeveloppeur.fr/podcast/">podcast</a>.</p><h3>PunkinDev</h3><p>86 épisodes au total pour ce podcast animé par Sylvain Coudert. Sur des formats d’une durée variant entre une dizaine de minutes et une heure, Sylvain évoque avec ses invité.e.s des récits de la vie de dev, des retours d’expériences sur des technos ou des pratiques de développement, et des réflexions sur le métier du développement logiciel. <em>NB: Le dernier épisode est sorti fin Novembre 2023 (je ne sais pas dire si la pause est temporaire ou non).</em></p><p>Lien du <a href="https://podcast.ausha.co/punkindev">podcast</a></p><h3>WeLoveDevs — Le Podcast</h3><p>WeLoveDevs, c’est un cabinet de recrutement pour les devs, le podcast propose une approche plus centrée sur le volet RH, la recherche d’emploi, l’accompagnement de carrière, etc.</p><p>Lien du <a href="https://podcast.ausha.co/welovedevs-podcast">podcast</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cda6ace4035c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why tech leaders must advocate for Trunk-Based Development]]></title>
            <link>https://medium.com/promyze/why-tech-leaders-must-advocate-for-trunk-based-development-2f519588edb4?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f519588edb4</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[tech-leadership]]></category>
            <category><![CDATA[kanban]]></category>
            <category><![CDATA[trunk-based-development]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Mon, 25 Mar 2024 10:03:42 GMT</pubDate>
            <atom:updated>2024-03-25T10:03:42.368Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*UGH84bjyP04TycBTzs0k-A.jpeg" /></figure><p>In the second episode of <a href="https://tlc.packmind.com/">Tech Lead Corner</a>, I had the chance to welcome Dimitri Baeli, Staff Engineer at Backmarket (a French scale-up with 250+ engineers), and also the co-founder of <a href="http://teck.rocks/">Teck.Rocks</a>, the #1 CTO’s community in France. In the previous episode, we focused on communication and transmission skills with Dorra Bartaguiz. In this episode, I’ve invited Dimitri to share his insights on what being a tech leader means to him. This post summarizes his 4 thoughts, with a focus on code delivery.</p><h3>Evangelizing Trunk-based development (TBD)</h3><p>Dimitri emphasized the importance of explaining the code lifecycle to non-technical stakeholders, highlighting trunk-based development as a cornerstone of their approach. Trunk-based development, a strategy where developers work in short branches frequently merged into the main branch, ensures a steady and sustainable pace of progress. Inversely, long-lived feature branches drive a codebase too far away from the main code. Dimitri thinks that mastering TBD is the “holy grail” for tech leaders since it supports the speed of code evolution.</p><h3>Standing as the pilot of the codebase</h3><p>A tech leader is likened to a pilot steering the team, ensuring the codebase evolves appropriately. Their essential role is not just overseeing code production but nurturing a codebase that is a collective work. The challenge of managing a large codebase, especially in companies scaling up like Backmarket, is a test of leadership in maintaining code quality and delivery cadence. The tech leader’s capability to navigate through technical challenges, from simple code incidents to complex merge conflicts, underpins their effectiveness in maintaining a smooth delivery process.</p><h3>Championing autonomy and prioritization</h3><p>Dimitri advocates for a work process in which each task is independent and prioritized for its impact. He champions the Kanban method, promoting a flow where tasks are self-sufficient, reducing dependencies and facilitating a more streamlined delivery. A task should always be considered in the context of the main branch to minimize its reliance on other branches and their associated tasks, which can hinder progress due to unresolved dependencies.</p><h3>Impacting beyond code</h3><p>According to Dimitri, the tech leader’s role transcends code management. It involves a holistic understanding of the project lifecycle, from conceptualization to deployment, and the ability to communicate complex technical processes to non-technical team members. This broad perspective enables tech leaders to anticipate potential bottlenecks, streamline workflows, and foster a culture of collaboration and continuous improvement. Dimitri thinks that a tech leader’s ultimate responsibility is <strong>to ensure the code’s quality and the speed of its evolution</strong>. The true measure of a tech leader’s success is not just in the code that reaches production but in navigating the challenges and opportunities along the way, guiding their team toward excellence.</p><p>Along this conversation with Dimitri, we focused on how tech leaders must master the speed of the evolution of the code, but it also enhanced their multifaceted role in both technical and non-technical domains. I liked his vision about the Kanban and mono-task principles, which fosters the rhythm at which the codebase moves on.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f519588edb4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/why-tech-leaders-must-advocate-for-trunk-based-development-2f519588edb4">Why tech leaders must advocate for Trunk-Based Development</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tech Leader: the power of listening, sharing, being assertive, and growing people.]]></title>
            <link>https://medium.com/promyze/tech-leader-the-power-of-listening-sharing-being-assertive-and-growing-people-b6ca43ba0e22?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6ca43ba0e22</guid>
            <category><![CDATA[tech-lead]]></category>
            <category><![CDATA[technical-leadership]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[tech-leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Thu, 15 Feb 2024 20:57:21 GMT</pubDate>
            <atom:updated>2024-02-16T09:32:06.432Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*INNCDaoB4DcxeCFN-KOCVw.jpeg" /><figcaption>Being a Tech Leader</figcaption></figure><p>I recently welcomed <a href="https://www.linkedin.com/in/%F0%9F%92%8Edorra-bartaguiz-457b5315/">Dorra Bartaguiz</a>, VP Tech at <a href="https://arolla.fr/">Arolla</a>, to the Podcast <a href="https://tlc.packmind.com/">Tech Lead Corner</a> and asked her to share her vision of what it means “<em>Being a Tech Leader</em>“. Here are her three key takeaways:</p><h3>Practice active listening and being assertive</h3><p>According to Dorra, active listening is a tech leader’s most underrated yet crucial skill. The ability to truly hear and understand the team’s ideas, concerns, and suggestions fosters a culture of collaboration and mutual respect. Leaders can harness their team’s collective intelligence to navigate challenges and identify the best path forward by acknowledging that they don’t hold all the answers. Dorra thinks active listening is a cornerstone of any successful team.</p><p>Assertiveness means defending your work with conviction and trust while respecting others. This should not be confused with aggressiveness; it’s about being firm and straightforward without undermining the team’s morale. It’s not about harming; it’s about stopping the bleeding. When problems arise, it’s crucial to address them immediately.</p><p>A common misconception is that a tech leader must be the top expert in every technological domain. However, leadership doesn’t require omniscience. Instead, it demands a solid foundation in technical knowledge to make informed decisions and guide the team effectively. Active listening and being assertive enables tech leaders to evaluate solutions proposed by their team, ensuring that choices align with the project’s goals and strategic direction.</p><h3>Share knowledge and encourage others to share</h3><p>The transmission of knowledge within a team is a seal of effective tech leadership. Dorra underlines that tech leaders should be passionate about <a href="https://www.packmind.com/from-missed-insights-to-collective-wisdom-enhancing-knowledge-flow-among-developers/">sharing </a>(technical skills, best practices, and even attitudes). Moreover, mentorship extends beyond technical skills to include professional development, encouraging a mindset of continuous learning and curiosity.</p><p>A tech leader must elevate other developers’ skills. Dorra pays attention to developers’ perspectives of growing as tech leaders and tries to detect as early as possible who has the potential to become a tech lead. According to her, a tech leader should understand and adapt to their team members’ personalities early on. Those who are shy or introverted but still willing to share with others should be encouraged to progress in that domain (for instance, by running internal presentations). The idea is that the team can rely on another leader when the current leader will leave the team.</p><p>Finally, a tech leader must prepare their team to function independently, minimizing the “bus factor” — the risk associated with the departure or absence of key individuals. If a team panics when the tech leader is missing, this is a bad smell.</p><h3>Provide constructive feedback to help people grow</h3><p>Delivering and receiving feedback constructively is an art that tech leaders must master. It involves not only the content of the feedback but also its delivery method, which should be tailored to the individual’s personality and the context. Dorra says that it’s not always a pleasant moment, especially when the feedback has negative content. But this is truly necessary to help the receiver progress and learn.</p><p>Both Tech leaders and developers should be open to receiving feedback. Otherwise, this will curb any form of progression. When there is a problematic situation to address, we need to discuss it to determine the root cause, and if it’s due to a wrong behavior or practice, we must work to fix it. Otherwise, you’re merely applying band-aid solutions, and no one will progress. That’s why a tech leader should always maintain an environment where failure is seen as a stepping stone to learning. On that topic, the book <a href="https://www.amazon.fr/Radical-Candor-What-Want-Saying/dp/1509845364">Radical Candor</a> by Kim Scott is a must-read to provide constructive feedback.</p><p>I enjoyed this discussion with Dorra about the soft skills and postures of the tech leaders. Let’s catch up after the <a href="https://tlc.packmind.com/">next episode</a> to share new insights on that topic!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6ca43ba0e22" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/tech-leader-the-power-of-listening-sharing-being-assertive-and-growing-people-b6ca43ba0e22">Tech Leader: the power of listening, sharing, being assertive, and growing people.</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Missed Insights to Collective Wisdom: Enhancing Knowledge Flow Among Developers]]></title>
            <link>https://medium.com/promyze/from-missed-insights-to-collective-wisdom-enhancing-knowledge-flow-among-developers-dc6bccbcef82?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc6bccbcef82</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[knowledge-sharing]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Mon, 30 Oct 2023 16:04:13 GMT</pubDate>
            <atom:updated>2023-10-30T16:04:13.806Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pLBeCYh04N9VdpuyM6t8kg.png" /><figcaption>Credits to Dall-e</figcaption></figure><p>According to <a href="https://cloud.google.com/blog/products/devops-sre/announcing-the-2023-state-of-devops-report?hl=en">2023 DORA report</a>, knowledge sharing has a positive impact on software delivery &amp; organizational performance. An effective <strong>knowledge-sharing</strong> process is a balanced combination of both tacit (oral transmission) and explicit (codified &amp; written) sharing, where questions are answered once, and the information is available to others; it’s a process where <strong>capitalization</strong> is key (share with the most).</p><p>A culture that supports knowledge sharing boosts each engineer’s learning curve, consolidating job satisfaction. As <strong>tech leaders</strong>, you &amp; your team experiment with daily situations with missed knowledge transfer opportunities. If they sound familiar, it’s a chance for you to adapt behaviors to make the most of these situations. It’s worth to give a shot!</p><h3>1. Missed opportunities to elevate during code reviews</h3><p>An efficient code review process leads to code improvements, knowledge transfer, shared code ownership, and team ownership. But they have two limitations: 1) code reviews remain in a 1:1 conversation scope, restricting the scope for the value of the discussion 2) There are regular debates about coding standards, which should involve the whole team. So, while reviews should ensure no major defect is pushed to production, they lack capitalization from the developer’s discussions about the code.</p><p>To overcome these limitations, keep the code review focused on checking major issues and catching relevant and meaningful comments or topics. This content should be reviewed <strong>collectively</strong> during a <a href="https://www.promyze.com/code-reviews-to-team-performance/">synchronous meeting</a> with your team to thoroughly review each point, explain different concepts, share knowledge, or reach a consensus about coding practices. Don’t create bottlenecks to deliver value to your customers and postpone technical discussions.</p><h3>2. Missed opportunities to learn from bugs</h3><p>If software engineers fix bugs on their own and don’t share more content with others, you can bet someone else will struggle in the future to do the same work. Consequently, time will be wasted to identify the bug, devoting effort to fixing it, and probably reinventing the wheel, which frustrates everyone. We all make mistakes, but we should capitalize on them to avoid seeing them again.</p><p>To save a precious amount of time, we can dive into the <a href="https://www.promyze.com/dantotsu-best-practices/">Dantotsu</a> methodology to prevent defects from happening again. This is based on a sharing session about why defects occurred (their root causes), how they were handled and fixed, and what countermeasures have been implemented to reduce the risk of seeing them again. It’s not about blaming people, but to collectively progress by learning from our mistakes. The Dantotsu philosophy brought many benefits in Toyota’s factories.</p><h3>3. Missed opportunities to highlight code improvements</h3><p>Assume you made a fix that drastically improves the runtime performance, adds an extra security layer to an API, or updates the CI/CD pipeline to add new quality checks. These changes are worth showing to the whole team so that all developers become aware of them to grow their codebase ownership and knowledge. And code review won’t fully help since it usually involves one reviewer. So, most engineers will miss this value.</p><p>To share this valuable content, you can post a thread on your messaging platform (Slack, …), but you’re likely to be read by a minority of people (we’re often surrounded by notifications &amp; emails to read, so we have limited attention). The best chance you have is during a synchronous meeting with your team, where you can browse any technical topics, such as discussing your coding practices.</p><h3>4. Missed opportunities during newcomer’s onboarding</h3><p>Developers may need up to 7 months to reach optimal productivity. During onboarding, knowledge sharing should happen at a high throughput. The ramp-up will be optimized if people can get the answers they need without pain. Suppose teammates are unavailable or don’t invest enough time in this process. In that case, the whole team will pay for that: the newcomer won’t feel integrated, and code issues are likely to occur, meaning a rework and a longer time to delivery.</p><p>To ensure a great onboarding experience, recruits should have access to both tacit (during informal meetings, pair programming sessions, code reviews.) and explicit knowledge (codified information in your knowledge management system). It helps to learn in both synchronous and asynchronous ways. For instance, if you document your coding standards, a tool like Promyze helps new engineers to become quickly familiar <a href="https://www.promyze.com/onboarding-developers-best-coding-practices/">with them</a>.</p><h3>5. Missed opportunities to fix outdated documentation</h3><p>While looking for a technical answer, you encountered many README files or wiki pages without success. Finally, after a few hours of searching, you can figure out how to resolve your problem. That’ll be a great chance to update this knowledge so that people will easily find the right answer next time. Still, people don’t always take this opportunity and prefer to say, “<em>If someone faces this problem later, I’ll remember the solution</em>”. Of course, two months later, you probably forgot how you made it. Skipping this chance will again make people waste their time.</p><p>First, if there is too much outdated knowledge, you should reconsider if the repository used (e.g., wiki) is the most relevant for the use cases. If it’s a technical procedure for installing software, you should remind everyone that it truly matters to keep this documentation up-to-date. If you address coding standards, it’s been observed that generic wikis <a href="https://www.promyze.com/dont-let-your-best-coding-practices-die-in-a-wiki/">have limitations</a> since they’re disconnected from developers’ workflow. In any case, you should set a smooth process that is not felt as a burden by developers.</p><h3>6. Missed opportunities during pair programming sessions</h3><p>Pair programming helps reach a better result sooner, fosters interactions with other developers, and catalyzes learning. This practice can be extended to mob programming involving the whole team. But it’s rare to observe teams practicing full-time mob programming in 2023. Similar to code reviews, knowledge-sharing is restricted to the scope of participants, and there are missed opportunities to share with others or beyond the team.</p><p>To avoid repetitions through each session, define a process where you 1) identify and catch relevant technical discussion you’d like to bring beyond the pair programming session 2) review and discuss them with more participants later during a dedicated meeting. If you work in Mob programming, think also beyond your team. We bet you’ve got valuable knowledge to share with other teams in your organization.</p><h3>7. Missed opportunities when sharing conferences, books, or blog posts</h3><p>Developers can learn from blog posts, attend meetups or meetings, or watch their replays in videos. If a group of developers has the chance to go to a Tech event, they’ve probably seen many exciting talks, so how could these 2-day conferences benefit to others in the teams? Similarly, If you’ve watched a tremendous 60-minute talk online, how to share this with your team effectively? We’re all busy, so sending a video link to your colleagues turns down to say, “you’ll ALL need to spend 60 mins of your time to watch this as it’s a must-see”. Like blog posts, sometimes they’re pretty long and need more attention.</p><p>An actionable tip is to set a 15-minute weekly meeting where participants can summarize a blog post they read or a conference they watched and highlight the key findings and what they’ve learned (you can adapt the frequency and duration, like a 1-hour monthly meeting). People returning from a multi-day conference often organize an internal meeting with their team to share feedback and summarize their favored talks. So, don’t push content or links; take it as an exercise to summarize your thoughts and communicate them with your team.</p><h3>Set a culture to support knowledge-sharing</h3><p>Our key message is that knowledge sharing can’t happen if engineers are not committed to sharing with others. <strong>Capitalization</strong> is vital in this process. As a tech leader, you should make the most of each opportunity to upskill developers, bring technical interactions and discussion, and ensure continuous knowledge streams connect each developer in your team. As you noticed, we encourage regular <strong>collective synchronous</strong> meetings, mainly when you deal with complex topics that involve the whole team. But don’t make it <em>yet another meeting</em>: create a place where everyone gets value.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc6bccbcef82" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/from-missed-insights-to-collective-wisdom-enhancing-knowledge-flow-among-developers-dc6bccbcef82">From Missed Insights to Collective Wisdom: Enhancing Knowledge Flow Among Developers</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Code Reviews to Team Growth: Unlocking the Power of Practice Reviews]]></title>
            <link>https://medium.com/promyze/from-code-reviews-to-team-growth-unlocking-the-power-of-practice-reviews-4aabc9f7da1a?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4aabc9f7da1a</guid>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[knowledge-sharing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Thu, 31 Aug 2023 12:42:31 GMT</pubDate>
            <atom:updated>2023-08-31T12:42:31.296Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lEHYLdfh9bJowQ1n6OryCQ.png" /></figure><p>In 2008, GitHub revolutionized how we approached code by introducing its Pull-Request model for code reviews. Initially adopted by open-source projects, they were used as checks to review the code from possibly anonymous contributors and make sure they made the product better. Fast forward to today, while this model has been widely adopted, its potential is not fully harnessed, as reviews continue to be used as mere checks. For high-performing teams, the stakes are higher. Beyond checking code quality, they foster collaboration, continuous learning, and <strong>knowledge sharing</strong>. These are first-class concerns for engineering managers and tech leaders.</p><p>Knowledge sharing is the engine driving efficiency, agility, innovation, and growth. Rethink your approach to code reviews. View them not just as a procedural step, but as a platform to amplify knowledge sharing:</p><ul><li>Prioritize discussions on coding standards and best practices, primarily in Pull/Merge Requests’ comments. Remember: <strong>Every comment is an opportunity to elevate, not just evaluate</strong>.</li><li>Limit immediate discussions to issues that hinder code from being production-ready. File away secondary discussions for later, asynchronous engagements.</li></ul><p>Imagine if every <strong>code review</strong> taught something new to your whole team.</p><h3>Maximizing the Impact of Code Reviews</h3><p>Previously, we did a <a href="https://www.promyze.com/accelerate-code-reviews/">deep dive</a> into the ‘<a href="https://www.promyze.com/accelerate-code-reviews/">Ship/Show/Ask</a>’ framework, which empowers Pull Request authors to determine one of the following next steps:</p><ul><li>No review is needed for trivial changes (Ship)</li><li>Share code changes with peers for feedback (Show). Note: feedback can be provided after the merge.</li><li>Seek a review for significant/critical code changes (Ask)</li></ul><p>In code review, spotlight potential bugs, security/legal concerns, ensuring resolution before deployment. One oversight? Code review feedback often remains confined to the author, leaving the team in the dark. Relevant insights should be accessible to all. Moreover, tech leaders often complain about the need to explain the same concepts in 1:1 threads <a href="https://www.promyze.com/code-review-gitlab-linter-rules/">repeatedly</a>.</p><p>Furthermore, discussions on code readability or maintainability should ideally be <strong>deferred</strong>. Why? These conversations typically involve broader team perspectives and, when prematurely debated, can derail the development flow and increase the lead time for change.</p><p>So, when’s the ideal time for these high-stake discussions? Enter: <strong>Practice Reviews</strong>.</p><h3>Harnessing the Power of Practice Reviews</h3><p>Think of practice reviews as collaborative spaces for developers, whether in teams or broader communities (guilds, <a href="https://www.promyze.com/community-of-practice-in-software-engineering-teams/">community of practice</a>, …), aimed at:</p><ol><li>Fostering knowledge-sharing and discussions about <strong>coding practices</strong></li><li>Formulating and aligning with new coding standards</li><li>Leveraging and sharing developer expertise</li></ol><p><em>NB: Note that a coding practice can address topics such as a programming language, a framework, security, architecture, design, performance, and more.</em></p><p>Scheduled regularly (perhaps weekly or bi-weekly) and clocking in at around an hour, practice reviews are disconnected from the code release process, and address source code that may have been already pushed into production. Unlike code reviews, they have no impact on the lead time.</p><p>The practices review’s agenda includes source code snippets annotated with a suggestion of coding practices, a discussion topic, or a question. These insights can come from code reviews, coding sessions, or virtually anywhere.</p><p>Each insight is introduced by its contributor, paving the way for team discussions, clarifications, and collective learning. By session end, the team not only adopts new coding standards but also amplifies its shared technical expertise. To go further, check how Ubisoft <a href="https://www.promyze.com/ubisoft-knowledge-sharing-scale/">gets value</a> from these practice reviews.</p><h3>Code Reviews and Practice Reviews: A Synergy</h3><p>Code reviews are focused 1:1 discussions, ensuring code-readiness for production, typically multiple times weekly. They drive asynchronous interactions. As code reviews <strong>block the delivery process</strong>, they pressure developers and prevent them from diving into deeper discussions about coding practices, so they lose a chance to elevate as a team.</p><p>In contrast, practice reviews are team-centric workshops. Held weekly or several times per month, they combine asynchronous code insights from code reviews or code changes with synchronous discussions. This approach enhances knowledge sharing and refines coding standards. Inversely to code reviews,<strong> they don’t block</strong> the delivery process, so developers are freed from any constraint and can dive deep into technical discussions with their team.</p><p>Over time, practice reviews not only improve the overall code quality but streamline subsequent code reviews. Ensuring all developers know your coding standards brings confidence that the source code will gain consistency and will be easier to maintain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/756/1*xt089Zi_k6zbvT-wdsw8Nw.png" /><figcaption>Credits — <a href="https://tidyfirst.substack.com/p/thinking-about-code-review">Kent Bec</a></figcaption></figure><p>For engineering managers and tech leaders, practice reviews are a powerful ally to foster collaboration, continuous learning, and knowledge sharing among software engineers.</p><h3>Introducing Promyze for practice reviews</h3><p>Recognizing the huge upside for development teams, we have built Promyze as your partner to foster knowledge sharing and manage coding practices. Seamlessly integrated with your IDEs, code review platforms, and code repositories, it offers a platform for sharing insights and curating coding practices.</p><figure><img alt="Example: A coding practice queued for a practice review:" src="https://cdn-images-1.medium.com/max/720/1*Te6GAQRLu8hGvRTojG4DAQ.png" /><figcaption>Example: A coding practice queued for a practice review</figcaption></figure><p>In addition, the Promyze platform proactively scans for coding practices within your IDEs or during code reviews, providing an immediate feedback loop to developers. The development team remains in sync with the evolving best practices, fostering a culture of continuous learning.</p><p>Discover more about Promyze and embark on your practice review journey <a href="https://promyze.com/">here 🚀</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4aabc9f7da1a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/from-code-reviews-to-team-growth-unlocking-the-power-of-practice-reviews-4aabc9f7da1a">From Code Reviews to Team Growth: Unlocking the Power of Practice Reviews</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[7 frustrations to avoid with code review best practices]]></title>
            <link>https://medium.com/promyze/7-frustrations-to-avoid-with-code-review-best-practices-60badc1ba08d?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/60badc1ba08d</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Fri, 26 May 2023 08:56:58 GMT</pubDate>
            <atom:updated>2023-05-26T08:56:58.905Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oKCydvCtnz9qYfiBxMO8BA.png" /></figure><p>Code review is one of the most established processes in software engineering. Recent studies indicate that almost <a href="https://media.trustradius.com/product-downloadables/DD/D7/XID8MVZTH0JF.pdf">90% of IT companies</a> practice it. The emergence of AI technologies brings since 2022 new tools to improve the code review experience.</p><p>While its maturity has unveiled some common best practices for code reviews, it also emphasized several frustrations for developers in this context. At Promyze, we discussed their code review process with many technical leaders, engineering managers, and developers for several years. We’re especially interested in their improvement fields and what pains they still have. This post summarizes our findings.</p><h3>Frustration 1: Spend too much time to understand the context and the code</h3><p><em>Lucas submitted a Pull Request to Sara. She realizes it contains 800 lines (”whao!”) scattered among 40 files. There are 3 commits with the respective messages: 1/ “Add new feature” 2/ “Fix bug” 3/ “Fix bug for good”. The PR description simply indicates “Add new features on product listing”. “I have no idea what I’m gonna read”, sighs Sara.</em>*</p><p>What frustrates Sara is the lack of clear context, leading to a more significant effort from her to dive into the code and understand it. Also, its size is an issue. There is tons of web content about what should be the ideal size of the code review. It depends on the context, and there’s no silver bullet. As the submitter, you should preview the Pull Request to gain empathy for the reviewer. This person will have a <strong>diff-based</strong> perception of your changes, which is not your vision of your changes.</p><p>As a submitter, soon as you start working on your code, think about how this code will be reviewed. Try to build atomic commits will clear and concise messages, and give a proper description to the PR. This <strong>context</strong> will help the reviewer understand what you’ve achieved and save precious time, avoiding frustrations. If the commit messages are too long, that’s a bad smell of a commit that encompasses too many changes.</p><h3>Frustration 2: Bikeshedding and debating about standards</h3><p><em>Sara reads the review comments made earlier by Sofia. One is about a coding style that “doesn’t change the behavior, but I prefer like this”. Sara is annoyed because she wrote the code like many other parts of the software, so she wanted to keep consistency. She tells Sofia, “Both solutions are okay, but maybe it’s better to keep the current way of doing this?”. But Sofia argues it’s a chance to bring a new evolution in our coding practices. Sara gets frustrated because this debate delays the review completion.</em></p><p>Sometimes, don’t you regret that code reviews tools don’t limit the length of discussion threads? While some reviews might be critical and require a deep analysis, most of the time they do not. If the review is a discussion space to improve a piece of code, the scope of the suggestions made should be limited and known by all reviewers. In the scenario below, the problem is that Sofia began a discussion that goes beyond the scope of the review because it’s about a coding standard; this should involve the <strong>whole team</strong> in making such a decision.</p><p>Comments should target what’s necessary to update in the code before it gets merged. All other discussion topics should be addressed in a dedicated session gathering all developers in the team. That’s the framework suggested by <a href="https://promyze.com/">Promyze</a>, whose code review extensions offer a smooth way to convert code review comments into coding practice suggestions; this practice will be discussed and validated (or not) during a workshop.</p><h3>Frustration 3: Spend time reviewing trivial code</h3><p><em>Sara starts reviewing a pull request from John, including two modified files and less than 20 lines of code changed. She’s in the middle of an emergency, but still took the time to do the review to avoid a latency for John. She approves the PR, but wonders why she was called to review that code. John could have done it himself!</em></p><p>Rigorous process right? A solution is to consider that not all code changes <strong>deserve the same attention</strong>. Some changes will be pretty basic and target non-critical parts of the system. Inversely, some changes will be more complex, impacting the application’s core logic, or requiring strong attention regarding security concerns. We met several companies that have a <strong>rigorous process</strong> of code review, including, for instance, three reviews before validation. But does it make sense to follow this process every time without consideration of the review material?</p><p>Depending on the code submitted, we could imagine that developers are free to merge if they consider there’s no risk and need to assign a reviewer, and they should ask for two reviewers if the code changes are critical. That’s the idea promoted by the <a href="https://martinfowler.com/articles/ship-show-ask.html">Ship Show Ask</a> model. With solutions like <a href="https://reviewpad.com/">Reviewpad</a>, you can implement your assignment and merge rules depending on the content of the review.</p><h3>Frustration 4: Getting few valuable feedbacks</h3><p><em>Sara carefully submitted the review: she created isolated commits with clear messages and added detailed context in the PR description. It was the first time she had worked on this part of the software, so she took care to avoid any mistakes and expected to get constructive feedback. The PR contains about 400 hundred added lines. Stefan took the review but only wrote on comment: “LGTM”. Sara is relieved but expected a bit more material.</em></p><p>Maybe Sara just did the job perfectly, right? Even if it’s true, a good practice during the code review is to provide positive feedback on the code, to highlight what’s been done correctly. People often emphasize what’s “bad” and forget to comment when the work done is fine. This refers to <strong>empathy</strong>: Sara paid attention to the quality of the submission, and Stefan probably felt that, so he should also show empathy towards her.</p><p>To optimize the quality of the feedback, the reviewers must allow a sufficient amount of time for the review. Otherwise, they’ll extract only shallow and superficial content. And the submitter will feel that. So better don’t do the review if you’re in a hurry or not in the mindset for that. Ask a colleague to replace you this time. Also, adapt your expectations depending on who’s gonna make the review (her technical skills and expertise on the code, …). If the reviewer has few knowledge of the context, maybe it’s best to ask for a second review from a more advanced developer.</p><h3>Frustration 5: The latency until the review gets completed</h3><p><em>Sara opens a pull request at 01:00 pm. She asks her team if someone can review her changes. Bob will show up at 3:40 pm. and, after spending 5 mins reviewing, will suggest one minor change. Sara immediately takes 2 min to apply the change and asks Bob to approve the new version of the code. Bob approves at 5:00 pm, and the code is shipped in production. The whole process lasted 4 hours, but stuff happened only for 7 minutes. Fortunately, only one reviewer was required!</em></p><p>The first step is to focus on the root problem: why is this latency significant during the process? Do reviewers lack time because they’re overwhelmed? Don’t they pay enough attention to their notifications from the code review tool? Or is it because you don’t like to review, so they procrastinate as much as possible? The whole completion time indeed depends on the availability of the reviewer. There’s no silver bullet here, but this problem must be discussed internally to identify how to improve this process.</p><p>Between the PR creation until it’s merged, the majority of the time, nothing will happen. We wait for the next step to happen. Unfortunately, that idle time hurts the delivery time (<a href="https://www.promyze.com/compute-dora-metrics-tools/">the lead time for changes</a>). While they wait for a review, developers will be tempted to start another task, leading to context-switching. Practicing <strong>mob programming</strong> can prevent such latencies. Also, a solution like <a href="https://axolo.co/">Axolo</a> offers a Slack application to manage GitHub pull requests and reduce the Pull Request merge time.</p><h3>Frustration 6: Getting unpleasant or hurtful comments</h3><p>The <a href="https://www.promyze.com/discovering-the-code-review/">egoless programming</a> principles stand as core concepts for doing great code reviews. One stipulates that <em>“You’re not your code”</em>. Code review, such as any other discussion space in a Tech organization, should be respectful among the participants. So we’re all kind to each other, and we formulate constructive comments about how to improve the code. Even though you’re uncomfortable with the code you’re reading, there’s no reason to write something like: <em>“This is a non-sense, and this code should be thrown away”.</em> Be constructive instead: <em>“What do you think about this alternative instead?”.</em> If developers are stressed or feel bad before getting review comments, your team has a severe problem to solve.</p><h3>Frustration 7: The source code has obvious bugs</h3><p>If you review a code and immediately say, <em>“Hey, how this code possibly works?”</em>, this does not smell like a great start. But you might be wrong and have missed something. So you politely ask to code author: <em>“I’m possibly wrong, but I think this code has an issue and does not have the expected behavior since …”</em>. If the answer is, “<em>Oh yes, my bad, I didn’t run it actually.”</em> I can definitively understand your frustration ;-) This is an apparent lack of rigor and empathy from the code author. To avoid this, set guidelines and rules before submission; for instance: code must have been tested (manually) and/or covered by unit tests, linters should have been executed, and the CI/CD pipeline is checked, …</p><p>Feel free to share with us your main frustrations when doing code reviews; we’d be happy to read them. To go further, we suggest you read our dedicated post on how to accelerate <a href="https://www.promyze.com/accelerate-code-reviews/">the code review process</a>. Thanks for reading ;)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=60badc1ba08d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/7-frustrations-to-avoid-with-code-review-best-practices-60badc1ba08d">7 frustrations to avoid with code review best practices</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t let your coding standards die in a wiki]]></title>
            <link>https://medium.com/promyze/dont-let-your-coding-standards-die-in-a-wiki-4e5faf7faf20?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4e5faf7faf20</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[knowledge-management]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Tue, 25 Apr 2023 13:40:18 GMT</pubDate>
            <atom:updated>2023-04-25T13:41:01.871Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*tC1ovLI5B8opqQboAGdd6w.png" /></figure><p>In software engineering organizations, there’s this challenge to define, record and spread best coding practices and standards across teams. This brings consistency to source code and improves its maintainability. It also avoids bottlenecks and endless discussions during <a href="https://www.promyze.com/accelerate-code-reviews/">code reviews</a> on a given coding practice. A common approach to this challenge is building a knowledge base in a Wiki-like tool, such as Confluence or Notion. Although the idea makes sense and is relevant, at Promyze, we’ve talked with companies that shared the pitfalls and drawbacks of this approach for managing their coding standards. We discuss them in this post.</p><h3>Raising and maintaining the practices repository is complex</h3><p>The most observed pattern can be summarized with the following picture:</p><figure><img alt="Wikis can get quickly outdated and require energy to be kept up-to-date" src="https://cdn-images-1.medium.com/max/957/1*NwCMiHpm0hLh9IEWOjjgDA.png" /></figure><p>There are 2 details here that reflect the pitfalls of most wikis: The “<strong>TODO</strong>” section and the “<strong>Last update</strong>” property. Keeping an up-to-date wiki requires energy and effort from a group of people (mainly technical leaders). Most of the job is often achieved when bootstrapping the process since there is a solid motivation to build a knowledge base of coding practices. But this motivation tends to lower after several months, mainly because:</p><ul><li>It takes time to identify and raise the practices, write them, and find the appropriate positive and negative examples (Do/Don’t);</li><li>This feeling that content gets a few hits and engagement from other developers (so why should I continue?)</li></ul><p>As a consequence, most of the companies we talked with shared with us the “outdated wiki” pattern when we discussed their best coding practices management.</p><h3>Engaging engineers is too neglected</h3><p>Knowledge has value only if it’s shared and understood by others. But having great content in your Wiki does not guarantee that people will interact with it. Do they even know it exists?</p><figure><img alt="Developers often don’t hit the practices" src="https://cdn-images-1.medium.com/max/590/1*GeEbDTf1c4d1QwGDhzs9Bg.png" /></figure><p>If not, they won’t search for it. It’s common that engineers looking for answers to their questions receive as answer a link to the appropriate Wiki page because they’ll be more likely to directly ask their colleagues instead of searching in the knowledge base.</p><p>Coding practice shouldn’t be built independently by a small group of engineers <strong>without collaboration and discussion with others engineers</strong>. Think about how best practices are shared once written down in a Wiki. If a developer receives a message saying:</p><blockquote><em>Hey, I’ve added new 4 React coding practices to follow in our Wiki. Take a look here!</em></blockquote><p>Do you think it’s engaging? We’ve got plenty of stuff to do, and you’ve already decided they’re all valid. So I’ll wait until someone tells me in a future code review that I don’t follow them. What if, instead, the same developers get this:</p><blockquote><em>Hey, I came up with 4 React coding practices that I think could be helpful in our context. I want to introduce them to the team, discuss them, and decide if we validate or discard them. Would you be available for a short 30-min meeting this Friday?</em></blockquote><p>More engaging right? Developers feel more involved in the construction process. And maybe they’ll have great suggestions to make!</p><h3>Static content is not appropriate when coding</h3><p>Developers seldom code in their IDE while interacting with the knowledge base to see if they follow or not a coding standard. Ideally, they need to get the <strong>right information when they need it</strong>. They should be notified if their code is not compliant with a practice. But Notion or Confluence are not designed for this specific use case. And when coding, we want to stay focused on our IDE.</p><p>That’s why static should become <strong>dynamic</strong> instead: how to push a coding practice when it’s relevant? How to create a bi-directional flow between developers and the knowledge base?</p><h3>Create Living Coding Practices</h3><p>If this post reminds you of your current context, you’re likely looking for alternatives to improve how you manage your best practices. Here is one for you. At Promyze, our ambition is to design a dedicated solution to this coding standards-sharing challenge. Our platform allows to:</p><ul><li>Raise coding standards from IDE and during code reviews thanks to our extensions;</li><li>Validate them during collective workshops;</li><li>Create a <strong>living coding practice</strong> by enriching it with patterns (regular expressions, Semgrep patterns, …), and making it available for developers when they write or review source code;</li><li>Support onboarding of new engineers with interactive challenges to learn the current practices in the organization.</li></ul><p>Learn more on <a href="http://promyze.com/">promyze.com</a> to find more on this.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4e5faf7faf20" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/dont-let-your-coding-standards-die-in-a-wiki-4e5faf7faf20">Don’t let your coding standards die in a wiki</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[35 Knowledge base tools for developers in 2023]]></title>
            <link>https://medium.com/promyze/35-knowledge-base-tools-for-developers-in-2023-2584d1ea6bbb?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/2584d1ea6bbb</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[knowledge-management]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Wed, 12 Apr 2023 08:58:05 GMT</pubDate>
            <atom:updated>2023-04-12T08:58:05.930Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ntdJSiSv10SnCCMtJ95r1g.png" /></figure><p>In 2023, there should be no debate about the added value of great documentation in software projects. Software engineers should have access to the appropriate knowledge base, depending on the resource type and when they need it. Technical documentation for software developers can take many forms, including evergreen documentation (e.g., procedures for setting up a project), architectural principles that developers should follow in their projects, release documentation, <a href="https://www.promyze.com/create-best-coding-practices/"><strong>coding standards</strong></a> and guidelines, onboarding guides, and more.</p><p><strong>Documentation for technical audiences</strong> is a tough challenge for many reasons: it requires a rigorous organization to be kept up-to-date. It can quickly be put aside by engineers who often dislike spending time on maintaining documentation. One common mistake is to consider all categories of documentation at the same level: an ever-green procedure to install software is not the same as a coding standard, for instance, which regularly evolves. You don’t need this knowledge at the same time and frequency. Once you understand that, you can define different processes and channels to manage your technical documentation</p><p>In this post, we provide an overview of 35 existing tools for managing technical knowledge, which can be scattered into these main categories:</p><ul><li><strong>Wiki-like tools</strong> where engineers write documentation in the tool’s UI (ex: Notion, Confluence, …)</li><li><strong>Living knowledge</strong> tools, where knowledge emerges from developers’ tools and become then dynamic, are used for instance, in code analysis and onboarding sessions (ex: Promyze);</li><li><strong>Communication</strong> tools, such as Questions/Answers platforms (ex: StackOverflow for Teams, …)</li><li><strong>Generated-wiki</strong> tools where developers will typically write documentation in markdown, and then all the magic will happen (ex: ReadTheDocs, …)</li></ul><p>This post does not consider tools that provide <em>end-user</em> documentation, such as self-service portals (Zendesk, Intercom, etc.). We focus on documentation made by developers for developers. We also exclude API documentation tools, which belong to a specific domain that deserves its article.</p><h4><a href="https://acreom.com/">Acreom</a></h4><p>Capture notes, break down issues, track your progress, create a knowledge base.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2gyGDIsRFnf-XCyRvlSMNg.png" /></figure><h4><a href="https://www.answerhub.com/">AnswerHub</a></h4><p>Empowering developers and teams to learn, share, and succeed through online communities and knowledge sharing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rXLMBSPI02HmanQ-Pxif_w.png" /></figure><h4><a href="https://appflowy.io/">AppFlowy</a></h4><p>Open Source Notion Alternative</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DAVSOM5USG1aJTatAEbNpQ.png" /></figure><h4><a href="https://www.archbee.com/">Archbee</a></h4><p>Build better product documentation — faster</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fehM0DcevHsTvV93w9C7TA.png" /></figure><h4><a href="http://bit.ai/">Bit.ai</a></h4><p>Next-Gen Document Collaboration Platform for Teams!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ffE2pjpUwbRaCT46r_lqzw.png" /></figure><h4><a href="https://www.bookstackapp.com/">BookStack</a></h4><p>(Open Source) BookStack is a simple, self-hosted, easy-to-use platform for organizing and storing information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5REjal4-Ca4f-BtU1yt2Dw.png" /></figure><h4><a href="https://clickup.com/">ClickUp</a></h4><p>Save time with the all-in-one productivity platform that brings teams, tasks, and tools together in one place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L5zgtbf955lMK-z1_yqi1Q.png" /></figure><h4><a href="https://coda.io/">Coda</a></h4><p>The all-in-one doc for teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HCykr7wXXLiGBwzv16R6Uw.png" /></figure><h4><a href="https://www.codestream.com/">CodeStream</a></h4><p>New Relic CodeStream is a free open-source extension for VS Code, Visual Studio, and JetBrains.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cqexNOuFh-JkofhQveOPQw.png" /></figure><h4><a href="https://www.atlassian.com/software/confluence">Confluence</a></h4><p>Confluence is your remote-friendly team workspace where knowledge and collaboration meet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jxES-yDxgIMwdQCFfm5ybQ.png" /></figure><h4><a href="https://daux.io/">Daux.io</a></h4><p>(OpenSource) The Easiest Way To Document Your Project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SiLRxwPu7g3ce5K3tqKXfg.png" /></figure><h4><a href="https://developerhub.io/">Developerhub.io</a></h4><p>All-in-One Platform for Online Documentation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EutmiEN7w8mpi9BRhe2MuQ.png" /></figure><h4><a href="https://docusaurus.io/">Docusaurus</a></h4><p>(OpenSource) Build optimized websites quickly, focus on your content.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a0KgY-M7JhHDSvO-V-W0Pw.png" /></figure><h4><a href="https://flarum.org/">Flarum</a></h4><p>(Open Source) Forums made simple. Modern, fast, and free!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gsMy6iv7_Fsiazjq-CMvYg.png" /></figure><h4><a href="https://www.forem.com/">Forem</a></h4><p>(Open Source) Forem is an open source platform for building modern, independent, and safe communities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HLqos7yfYk-nFVfa9B22ng.png" /></figure><h4><a href="https://www.gitbook.com/">GitBook</a></h4><p>Where software teams break knowledge silos. (We use it at Promyze for our <a href="https://docs.promyze.com/">public documentation</a>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HaYLsxIN2Uz3A_z-5cIyfA.png" /></figure><h4><a href="https://pages.github.com/">GitHub Pages</a></h4><p>Websites for you and your projects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xDTKYW-a_RAONh2a63XfNA.png" /></figure><h4><a href="https://gohugo.io/">Hugo</a></h4><p>(OpenSource) The world’s fastest framework for building websites.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TgKFkdAbRLw5bj_lfhlUvA.png" /></figure><h4><a href="https://jekyllrb.com/">Jekyll</a></h4><p>Transform your plain text into static websites and blogs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cFX9xjOQrtEFf0ZsSMOC-w.png" /></figure><h4><a href="https://rust-lang.github.io/mdBook/">mdBook</a></h4><p>Static site generator from Markdown files.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GRXxTWxJ9qRpjUuIJ9nP1w.png" /></figure><h4><a href="https://www.mkdocs.org/">MkDocs</a></h4><p>(Open Source) Project documentation with Markdown.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AQ-jSgdmQ3J9Co2eNYnAow.png" /></figure><h4><a href="https://notion.so/">Notion</a></h4><p>The all-in-one workspace — for your tasks, notes, wikis, and calendar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KPc7xdEdWwSuKukPzDAtEQ.png" /></figure><h4><a href="https://notaku.so/product/docs">Notaku</a></h4><p>Build a full-featured Docs website in minutes, using Notion as CM</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nmRkuXODOMj_dF99qdVa3Q.png" /></figure><h4><a href="https://www.nuclino.com/">Nuclino</a></h4><p>A modern, simple, and blazingly fast way to collaborate — bring knowledge, docs, and projects together in one place.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ogH1OgDaOwZAh7LBWPGYQ.png" /></figure><h4><a href="https://papyrs.com/">Papyrs</a></h4><p>The easiest way to create an online for your company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*52-zqvc6r5F6yayILvNqSA.png" /></figure><h4><a href="https://readthedocs.org/">Read The Docs</a></h4><p>(Open Source) Read the Docs simplifies software documentation by automating building, versioning, and hosting of your docs for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*54npt0J6Y2W5AN8EhzYDjg.png" /></figure><h4><a href="https://skydocs.skyost.eu/">SkyDocs</a></h4><p>(OpenSource) SkyDocs is a lightweight static documentation builder with MarkDown.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CSeZLB5rFY1fsAhw6584wg.png" /></figure><h4><a href="https://slab.com/">Slab</a></h4><p>Build a culture of knowledge-sharing today.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wng9Rtzz5evLEecvq2Eicg.png" /></figure><h4><a href="https://www.sphinx-doc.org/">Sphinx</a></h4><p>(OpenSource) Sphinx makes it easy to create intelligent and beautiful documentation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CDt0-gbY7GLh6GmMcG0PRg.png" /></figure><h4><a href="https://stackoverflow.co/teams/">Stack Overflow For Teams</a></h4><p>Knowledge sharing and collaboration without distractions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_DQFPxJ4CSnDRJkE8XgxhQ.png" /></figure><h4><a href="https://swimm.io/">Swimm</a></h4><p>Documentation Platform Built for Engineers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mJ1qLIl_8spMSfcR4DCdWg.png" /></figure><h4><a href="https://backstage.io/docs/features/techdocs/">TechDocs</a></h4><p>Spotify’s docs-like-code plugin for Backstage.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0t5XJG_EJUm04LBPHAkkCw.png" /></figure><h4><a href="https://tettra.com/">Tettra</a></h4><p>The best way to organize and share knowledge with your teammates.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XZc9p2aW1GmK6DZgGSwjfQ.png" /></figure><h4><a href="https://js.wiki/">Wiki.js</a></h4><p>(OpenSource) The most powerful and extensible open source Wiki software</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s8MzLtvP2BbFWV7kY97Tpw.png" /></figure><h4><a href="https://promyze.com/">Promyze</a></h4><p>Connect Developers’ Knowledge and share best coding practices, fully integrated in developers tools.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fs1_QFf9dHCkzR2fHtu3jw.png" /></figure><p>That’s all, folks; we hope that post gave you an overview of the current landscape of the knowledge base tools for software developers.</p><p>Among the ones quoted above, at Promyze, we use Notion to gather material such as procedures to create new releases of our IDE extensions. We use GitBook to publish the user documentation of our platform. Finally, we use our tool Promyze internally to raise new coding standards continuously. We bring these standards directly in IDEs &amp; during code reviews since we consider this is the moment developers need this knowledge. You don’t code with a Wiki opened in a tab.</p><p>For each <a href="https://www.promyze.com/knowledge-management-tooling-software-developers/">kind of documentation</a>, you must define who should update it, when, and how other engineers will be notified of this change.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2584d1ea6bbb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/35-knowledge-base-tools-for-developers-in-2023-2584d1ea6bbb">35 Knowledge base tools for developers in 2023</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How a start-up implemented hexagonal architecture — The case of Promyze]]></title>
            <link>https://medium.com/promyze/how-a-start-up-implemented-hexagonal-architecture-the-case-of-promyze-e20efcd05b87?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/e20efcd05b87</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[hexagonal-architecture]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Mon, 27 Mar 2023 11:06:01 GMT</pubDate>
            <atom:updated>2023-03-27T11:06:01.903Z</atom:updated>
            <content:encoded><![CDATA[<h3>How a start-up implemented hexagonal architecture — The case of Promyze</h3><p>Our platform <a href="https://promyze.com/">Promyze</a> is developed in a Client-Server model with a Front side developed in TS and React, while our back-end relies on Node.js. To give some context, the code base started 3 years ago, and we’ve always been a small team with max. 4 developers working on the code simultaneously. We currently have 156 KLOC in our back-end and 154 KLOC on the front-end.</p><p>Our <strong>motivations</strong> for implementing concepts from <a href="https://www.happycoders.eu/software-craftsmanship/hexagonal-architecture/">hexagonal architecture</a> were to support the <strong>maintainability</strong> of our code base, and ease our life when working on it to add new features. When we discovered concepts from <a href="https://www.promyze.com/why-read-red-book-domain-driven-design/">Domain-Driven Design</a>, Clean &amp; Hexagonal Architecture, we liked the idea of building <strong>separate bounded contexts</strong> and having in our code domains that encapsulate <strong>the business logic</strong>, being free of any third-party framework and technical implementation.</p><p>As we also use <strong>TDD</strong> (Test-Driven Development) in our coding process, we thought that applying ideas from hexagonal architecture and TDD would help to produce consistent hexagons covered by tests. This post <strong>shares how we currently implement a hexagon</strong> in our Node.js back-end.</p><p><em>This is how we do it in March 2023. Our practices have evolved for 2 years, and they’re likely to be improved in the future; if it’s the case, we’ll share a digest in a new post ;)</em></p><h3>The key concepts</h3><p>In our context, a hexagon targets a specific domain of our app, for instance, the <a href="https://www.promyze.com/automatic-suggestions/">automatic suggestions</a> or the notifications. We enforce to make it self-sufficient and ensure it can be easily enabled or disabled at runtime. Each hexagon contains <strong>4 distinct modules</strong>:</p><ul><li><strong>Domain</strong>: Contains the entities and aggregates specific to a domain and the repository interfaces (abstractions) to manipulate these entities.</li><li><strong>Application</strong>: Contains the services offered by the hexagon. This layer directly manipulates the Domain.</li><li><strong>Infrastructure</strong>: Implements the domains’ repository with concrete back-ends such as a database, files, in-memory, and more.</li><li><strong>UI</strong>: Handles how the rest of the world interacts with the application (Rest API, CLI, …).</li></ul><h3>Illustration</h3><p>Let’s take a concrete example with a hexagon handling the <strong>Knowledge Hexagon</strong>, the core concept being the <em>BestPractices</em>, used to raise coding standards from our IDE &amp; Code review extensions. We’ll skip irrelevant details for readability. Note that we’ve still included the folder structures if it can help some readers to understand how to organize their code.</p><h3>Domain &amp; Infra</h3><p>First, let’s zoom in on the <strong>Knowledge Hexagon</strong> on the relationship between the <strong>Domain</strong> and the <strong>Infra</strong> layers. In our context, we use a MongoDB implementation:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9s4NLun5vyoUz0xRPjX2Rg.png" /></figure><p>The domain is simple and only contains entities and the repositories interfaces. As you can notice, the domain has no link with the Infra layer. We’ve chosen to use a “main” interface <em>KnowledgeRepositories,</em> that will expose all the repositories of our domain. In the Infra layer, we use <em>Converter</em> components to transform objects <strong>from Infra to Domain</strong>, and inversely. This is optional, and it all depends if you rely on an ORM or not.</p><p>Instantiating the Infra Layer looks like this:</p><pre>const bpMongoRepo = new BestPracticeRepositoryMongo();<br>const knowledgeRepositories: IKnowledgeRepositories = new KnowledgeRepositories(bpMongoRepo);<br>const infra: KnowledgeInfra = new KnowledgeInfra(knowledgeRepositories);<br><br>// const knowledgeRepositories: IKnowledgeRepositories = new KnowledgeRepositories(new BestPracticeRepositoryinMemory())) would allow to use an in-memory implementation instead</pre><h3>Application</h3><p>Still in the <em>Knowledge Hexagon</em>, Now let’s zoom in on the <strong>Application</strong> layer and how it interacts with the <strong>Domain</strong> layer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7lI8YKC7JXqQXDXJe6k8DQ.png" /></figure><p>The application will stand as an API, containing <strong>all the services</strong> the hexagon offers to manipulate the domain, both entities and repositories. As domain repositories in the domain layer are abstractions (e.g., interfaces), they need concrete implementations at runtime. So we can reuse the one instantiated for the Infra layers.</p><pre>const bpMongoRepo = new BestPracticeRepositoryMongo();<br>const knowledgeRepositories: IKnowledgeRepositories = new KnowledgeRepositories(bpMongoRepo); <br>const knowledgeServices: KnowledgeServices= new KnowledgeServices(knowledgeRepositories);</pre><h3>UI (Presentation)</h3><p>Finally, let’s zoom in on the <strong>UI</strong> layer, which helps the rest of the world to interact with our hexagon:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5PPmqGykFbFdDcLMT5bsRA.png" /></figure><p>In our context, we have two types of interactions:</p><ul><li>From our <strong>end-users</strong> that interact with the app from their IDE/Code review plugins or their web browsers. The express framework is used in this context.</li><li>From other parts of <strong>our API</strong> (e.g., others hexagons) to avoid re-implementing business logic in a hexagon. We call them <em>InternalExposedMethods</em>. As we don’t use micro-services in our context, we considered that using such HTTP calls does not make sense. Instead, using these exposed methods works fine and fills our needs.</li></ul><h3>The big picture</h3><p>Finally, if we all put things together, here is the big picture from the macro-level perspective. Again, we’ve included one concept (<em>BestPractice</em>) from the <em>Knowledge Hexagon</em>, but we could have added more in this context (such as <em>CodeExample</em> listed above in the Infra layer).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IarW23eAQX7doTMYGPnUIA.png" /></figure><p>Here is how the hexagon can be started programmatically:</p><pre>class KnowledgeHexagonApp {<br>	 constructor() {<br>      //Infra<br>      const bpMongoRepo = new BestPracticeRepositoryMongo();<br>      const knowledgeRepositories: IKnowledgeRepositories = new KnowledgeRepositories(bpMongoRepo); <br>      const infra: KnowledgeInfra = new KnowledgeInfra(knowledgeRepositories);<br><br>      //Application<br>      const knowledgeServices: KnowledgeServices= new KnowledgeServices(knowledgeRepositories); <br>      <br>      //UI <br>      const routers = [new BestPracticeRouter(knowledgeServices), ...];<br>      const exposedMethods = new InternalKnowledgeExposedMethods(knowledgeServices);<br>  }<br>}</pre><p>You can adapt this example to change the infrastructure layer to something different than MongoDB dynamically. If you want to use SQL or in-memory, this could be injected at runtime as a <strong>dependency</strong> of the <em>KnowledgeHexagonApp</em> constructor.</p><h3>Managing tests</h3><p>Each hexagon embeds a test suite resulting from the TDD practice. For the record, we use <a href="https://www.promyze.com/setup-mocha-in-watch-mode-for-tdd-in-node-js/">Mocha</a> and <em>Chai</em> to write and run our tests. In our context, our tests layer has two main parts:</p><ol><li>The first is to test the <strong>Application</strong> Layer and its functions, using <em>Fake</em> repositories defined in the Infra folder and using in-memory implementations (basic TypeScript List/Map/…).</li><li>The second targets <strong>our concrete MongoDB implementation</strong> of the repositories. We’re not testing the Mongoose framework or the MongoDB infrastructure, but we ensure we have the right behavior when interacting with the repositories. It would be a pity to have a bug in production just because we misuse our ORM, right? We use the <a href="https://www.npmjs.com/package/mongo-unit">mongo-unit</a> library that runs an embedded in-memory MongoDB server for that purpose. We use hard-coded fixtures in specific files, which mongo-unit will ingest before the <strong>beforeEach</strong> call.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sMzJPre0--gNJX-jacZKaw.png" /></figure><h3>Events management</h3><p>It does not appear above, but in our API we’ve implemented a custom event management system. We have two requirements:</p><ul><li>we want to track core events in our system (a best practice has been created) and record them in our database;</li><li>each hexagon should be able to react to specific events (a user has been deleted)</li></ul><p>We’ve developed a lightweight system that relies on the <a href="https://nodejs.dev/en/learn/the-nodejs-event-emitter/">EventEmitter</a> provided by NodeJS. We’ve decided to centralize all our events in a shared module outside hexagons as <em>payload</em> objects, such as <em>BestPracticeCreatedPayload</em> emitted when a best practice is created. Here is how it’s implemented in the hexagon:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7S_lAZY-S3GmLoF77wDpVw.png" /></figure><p>In the <strong>UI layer</strong>, we can find the <em>Listeners</em> that react to events emitted by others hexagons in the API.</p><p>In the <strong>Application</strong> layer, the events will be emitted and handled by other hexagons.</p><p>In the <strong>Infra</strong> layer, we implement the services that will perform the event messaging. Instead of using EventEmitter from Node, we could use other alternatives, such as sending a message to a RabbitMQ channel.</p><h3>Other discussions</h3><p>One important point is that <strong>most hexagons use shared concepts</strong> like <em>BestPractice</em> or <em>Users</em>. We voluntarily chose to duplicate their definitions in the Domain and Infra layers. One cool thing with Mongoose is that, when writing the mapping model, we can specify only the fields we need in the hexagon. And if you ask, “<em>what happens when the model evolves ?</em>”, I’d say this does not happen very often; when it does, only a few hexagons are impacted, so we don’t consider this a main concern for us.</p><p>This version currently fills our need, especially because we’re a <strong>small team,</strong> and we want each of us to be able to work on any component of the app. We <a href="https://www.promyze.com/community-of-practice-in-software-engineering-teams/">ban knowledge silos</a>, and our weekly <a href="https://www.promyze.com/share-best-practices-workshops/">workshops</a> to discuss coding standards are helpful. So we’re all responsible for the code, and no one is in charge of a particular domain. So if we radically change how best practices are designed, we can easily discuss this. Our monolith works fine with a single database instance, and if we need in the future to deploy micro-services, we’ve prepared the ground for that. Plus, as we use <strong>TDD, we’ve built a security net</strong> to prevent possible regressions.</p><p>Finally, our main specificity was to build the <em>ExposedServices</em> when it made sense for each hexagon. As we run in a monolithic approach, we considered a relevant solution. If, in the future, our system evolves and we need to run micro-services, we’ll need to replace the methods calls with class HTTP calls.</p><h3>Adapt generic concepts in your context</h3><p>As said earlier, the way we wrote hexagons has evolved and might still evolve. We continuously train our skills on that topic and don’t claim we’re experts in that field (feel free to share your thoughts with us; we’d be happy to take them! :-)).</p><p>To keep our coding standards aligned, we use our platform <a href="https://promyze.com/">Promyze</a> to share and discuss our best practices. If you also want to define your tailored coding standards, not only on hexagonal architecture, but also on Security, JavaScript, Performance, or whatever topic that matters to you, Promyze might be a good ally for that.</p><p>In a future post, we’ll focus on how we’ve implemented concepts from the <strong>clean</strong> <strong>architecture in front-end</strong>, still using TDD, to remain independent as much as possible from the underlying framework (React in our context) and the API.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e20efcd05b87" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/how-a-start-up-implemented-hexagonal-architecture-the-case-of-promyze-e20efcd05b87">How a start-up implemented hexagonal architecture — The case of Promyze</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Simple knowledge-sharing sabotage field manual]]></title>
            <link>https://medium.com/promyze/simple-knowledge-sharing-sabotage-field-manual-451b43749981?source=rss-5e81423915d9------2</link>
            <guid isPermaLink="false">https://medium.com/p/451b43749981</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[knowledge-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Cédric Teyton]]></dc:creator>
            <pubDate>Wed, 15 Mar 2023 16:57:19 GMT</pubDate>
            <atom:updated>2023-03-16T08:00:07.433Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ttMeYhmVUBXKjSjInHkJ1Q.png" /></figure><p>In 1944, the OSS — <em>Office of Strategic Services</em> — of the USA shared with their Europe-based agents a <a href="https://www.openculture.com/2015/12/simple-sabotage-field-manual.html">sabotage manual</a> designed to create friction, frustrations, slow-downs, and disturbances in Nazi organizations.</p><p>80 years later, it’s interesting that the guidelines look familiar in many large companies. For instance:</p><blockquote><em>Insist on doing everything through “channels.” Never permit short-cuts to be taken in order to expedite decisions.</em></blockquote><p>I recently could have the chance to give a talk at the Bordeaux JS Meetup about how this sabotage manual could be applied to <strong>knowledge sharing</strong> in tech companies. This post summarizes its content.</p><h3>Context</h3><p>Our common goal is to harm the company <strong>Deforest Corp</strong>. They have a bad ecological impact as their primary mission is to massively destroy natural forests to favor intensive agriculture. As a software developer, you’ll join a feature team working on an app used by employees that drive deforestation sites. This app has undergone recent bugs so software quality is a major concern.</p><p>Your mission will be to degrade code quality (or at least, not improve it), increase bugs risks, and negatively impacts the relationships among members in the team. So we choose a smooth, subtle, and (almost) pacific approach. If you’re too radical, you’ll probably be fired immediately, so no interest.</p><p>Your action plan: hurt everything <strong>related to knowledge-sharing</strong>. Why so? It’s one of the factors that fuels business <a href="https://www.mckinsey.com/industries/technology-media-and-telecommunications/our-insights/developer-velocity-how-software-excellence-fuels-business-performance">performance</a>, developers still spend a lot of time <a href="https://survey.stackoverflow.co/2022/">answering questions</a> and looking for answers, and knowledge-sharing is still a challenge <a href="https://codingsans.com/state-of-software-development-2020">for developers</a>. More generally, it breaks knowledge silos; still need to be convinced of the value?</p><p>Let’s see how to do it?</p><h3>The guidelines</h3><ol><li><strong>Don’t share the </strong><a href="https://www.promyze.com/dantotsu-best-practices/"><strong>root causes</strong></a><strong> of the bugs you fix</strong>. You increase the risk that someone else performs the mistake related to the root cause, and the bug will happen again.</li><li><strong>Don’t share the code improvements you made</strong>. Any best practice that has a positive impact on the code (readability, performance, …) should be kept for you, preventing others to apply them in their code. Don’t be too greedy about that.</li><li><strong>Don’t update obsolete documentation</strong>. If you spent a lot of time finding an answer because the Wiki was outdated, ensure your colleagues will also face troubles. Leave it as it is.</li><li><strong>Make yourself unavailable for </strong><a href="https://www.promyze.com/onboarding-developers/"><strong>onboarding sessions</strong></a>. Onboarding new developers is a great exercise for sharing knowledge with a newcomer. Make sure that won’t happen.</li><li><strong>Don’t read or react to content shared by your colleagues</strong>. Someone just shared a nice post on Slack? Of course, you’re too busy to read it. But don’t even ask for a short digest, and don’t react at all. They’ll get tired.</li><li><strong>Support the idea that aligning your coding standards is pointless</strong>. Everyone should write code in their own way. YOLO, right? This will bring heterogeneity in the source code, leading to potential quality issues.</li><li><strong>Decline all pair/mob programming sessions</strong>. Pair and Mob programming sessions optimize the output while fostering social interactions. You don’t want that.</li><li><strong>Pretend you didn’t see you’ve been asked to do a </strong><a href="https://www.promyze.com/accelerate-code-reviews/"><strong>code review</strong></a>. Oh, you saw this notification for reviewing a pull request? We already received too many notifications, right? So I’m sure you missed that. This will create a good latency.</li><li><strong>Postpone the code review by pretending a huge workload</strong>. Sometimes, you’ll see the notifications. But guess what? You’re too busy; you also have work to do. So wait 2–3 days. And finally, just be honest with your colleague and say “<em>I did my best but unfortunately could find the time. Can you ask to someone else?</em>” Precious time lost; we love that.</li><li><strong>Validate the review without reading the code</strong>. Free <em>LGTM</em> distribution at random locations. Don’t take that chance to improve the code, identify possible bugs, or share valuable tips. People will think you did a review. Send the code as it is in production.</li><li><strong>Suggest conflicting best practices from one review to another</strong>. You’ve suggested one coding standard the last time? Suggest now the opposite. This will bring confusion, friction, and heterogeneity in the code.</li><li><strong>Feed endless discussions during code reviews about coding standards</strong>. GitHub/GitLab provide features to create comment threads, right? Use it as much as you can. This will create latency in the process. And of course, disagree with your interlocutor.</li><li><strong>Make comments on source code NOT updated during the review</strong>. Run discussions on the code that have not changed at all (you know, these lines of code not starting with “+” or “-” in the diff). Why not? Huge frustration coming in.</li><li><strong>Decline any help coming from someone external to the team.</strong> A technical coach is about to bring new best practices and methodology to the team? Decline it. We can’t impose a coach; they need your adhesion. Don’t give them.</li><li><strong>Don’t share anything related to your technology watch</strong>. Did you go to a great Tech conference? Don’t talk about that to your team, don’t share any replay. Don’t talk about some nice blog posts you’ve read. Keep them for you.</li><li><strong>Question the ROI of the </strong><a href="https://www.promyze.com/community-of-practice-in-software-engineering-teams/"><strong>community of practices</strong></a>. Don’t you think it’s strange, these people gathering several times per month, to share common problems and feedback that would be interesting to everyone? They’re just talking, and we have features to implement. Don’t learn from others teams that share common problems with you.</li><li><strong>Ensure the company won’t pay for the books read during Book Clubs</strong>. So that people will be discouraged from participating and thus won’t read that book that still looked interesting.</li><li><strong>Ask a lot of questions during Coding Dojos</strong>. The size of the room, the exercise statements, the schedule, and more. Complain about everything. Ensure this 90min-session won’t be optimized.</li><li><strong>Call for BBL boycott</strong>. Brown-Bag Lunch is scandalous. At that time, everyone should eat alone and not have a chance to learn while sharing a meal.</li></ol><h3>The summary</h3><p>Of course, reasoning by absurd is a voluntary choice I made. If knowledge-sharing matters in your context, of course, you should consider doing the opposite ;). If some of the guidelines remind you of some experiences you lived, sorry to hear that, and I hope it’s passed!</p><h3>What about you?</h3><p>I’ll end by sharing this <a href="https://www.promyze.com/quizz-evaluate-the-knowledge-sharing-level-in-your-software-engineering-teams/">3-min test</a> from Promyze to evaluate how your current engineering teams are performing in terms of knowledge-sharing, hoping it will give you some insights :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=451b43749981" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/simple-knowledge-sharing-sabotage-field-manual-451b43749981">Simple knowledge-sharing sabotage field manual</a> was originally published in <a href="https://medium.com/promyze">Packmind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>