<?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[Packmind - Medium]]></title>
        <description><![CDATA[Packmind is a Collaborative Learning Platform that leverages AI to accelerate developers’ learning. By intelligently identifying and integrating best coding practices tailored to each team’s unique context, Packmind elevates coding standards. - Medium]]></description>
        <link>https://medium.com/promyze?source=rss----794278fcb836---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Packmind - Medium</title>
            <link>https://medium.com/promyze?source=rss----794278fcb836---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 19:08:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/promyze" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Creating a culture of engineering excellence and team progress]]></title>
            <link>https://medium.com/promyze/creating-a-culture-of-engineering-excellence-and-team-progress-08b9835469d8?source=rss----794278fcb836---4</link>
            <guid isPermaLink="false">https://medium.com/p/08b9835469d8</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Laurent PY]]></dc:creator>
            <pubDate>Mon, 03 Jun 2024 13:16:49 GMT</pubDate>
            <atom:updated>2024-06-03T13:16:49.563Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oQPySjAaQi4rpY4UqgYo2Q.png" /></figure><p>In the first post of this series about <a href="https://www.packmind.com/secret-high-performing-software-teams/">building high-performing teams</a>, I highlighted the most critical factor for developer performance: skills! The second post touched on the importance of fostering a generative culture. Now, I want to delve into a more controversial topic 🙂: performance, and how to cultivate a culture of high performance.</p><p>Having led organizations ranging from a single engineering team to over 100 engineers, my north star has been the same with these three fundamental pillars:</p><ul><li>Developing leaders with a growth mindset</li><li>Investing in goal setting and measurement</li><li>Accountability</li></ul><h3>Growth mindset</h3><p>The most talented and impactful individuals I’ve encountered are those who are impressively eager to learn and push the boundaries. This is what I mean by a growth mindset. People with a growth mindset embrace challenges, persist through obstacles, learn from criticism, and find inspiration in the success of others. They see effort as a path to mastery and view failures as opportunities to grow and improve. This is why having a <a href="https://www.packmind.com/generative-culture/">generative culture</a> is so important — failure is part of the process!</p><p>Setting the right attitude and approach towards achieving goals is critically important as it significantly influences the motivation and behavior of individuals. Goal orientation typically divides into two main types:</p><ol><li><strong>Approach Orientation</strong>: Focuses on achieving success and mastering new skills. Individuals with this orientation are motivated by the desire to improve, learn, and accomplish goals. They tend to engage in behaviors that promote learning and growth, viewing challenges as opportunities.</li><li><strong>Avoidance Orientation</strong>: Focuses on avoiding failure and negative outcomes. Individuals with this orientation are motivated by the desire to prevent mistakes and protect their self-esteem. They may avoid challenging tasks to minimize the risk of failure and criticism, which can limit their learning and growth.</li></ol><p>Understanding goal orientation helps create environments that foster a positive, growth-oriented approach, encouraging individuals to pursue success and view mistakes as part of the learning process rather than as setbacks.</p><p>When building from scratch or up-leveling a team, the key for me is to first hire leaders with a growth mindset and the ability to coach and mentor, as these people become the biggest lever for team performance. Experts who have achieved a certain level of mastery don’t necessarily know how to share that knowledge, so I look for those who can do both. When hiring more junior developers, I prioritize eagerness to learn and coachability over specific language expertise or knowledge. The goal is to upskill the team because ultimately, skill is what enables delivery performance as measured by the <a href="https://www.packmind.com/secret-high-performing-software-teams/">DORA metrics</a>.</p><p>With engineering leaders who have a growth mindset and the right attitude towards achieving goals, you are in a good spot. This leads to the next crucial part: goal setting and measurement.</p><h3>Goal setting and measurement</h3><p>We can’t discuss performance without addressing metrics and measurement. However, this isn’t about measuring developer productivity, a hot topic recently highlighted by a <a href="https://www.mckinsey.com/industries/technology-media-and-telecommunications/our-insights/yes-you-can-measure-software-developer-productivity">McKinsey article</a>. Many weighed in on this, including Dan North:</p><blockquote>Just don’t try to measure the individual contribution of a unit in a complex adaptive system, because the premise of the question is flawed. DORA metrics, for example, are about how the system of work works, whether as Westrum culture indicators or flow of technical change into production. They measure the engine, not the contribution of individual pistons, because that makes no sense.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*kHaLxkeo6SLzPB_X.png" /></figure><p>Delivery performance and DORA metrics are better proxies for team productivity, but they are not sufficient on their own. While DORA metrics measure the efficiency of the “engine,” businesses care about the direction: where are we going, and when will we get there?</p><p>This is where business outcomes come into play, and these outcomes should be shared by the whole team. Customers care about the business impact of processes, tasks, or activities, not just the immediate output. Outcomes can be challenging to measure as they may be long-term consequences. In such cases, define smaller units of value toward the outcome that can be delivered in a week or quarter rather than defaulting back to output metrics. Here is an example:</p><p>Assume as part of a team developing a test management tool, we plan to release a new feature using GenAI to automate manual tests. We have several definitions of success:</p><ul><li><strong>The feature being released</strong> 🚀. This is still what a lot of teams use as a success definition. Don’t 🙅🏻‍♂️. This is just the output and users may not care about the new feature. It may be just a waste of time.</li><li><strong>The number of users #️⃣.</strong> This is slightly better. Usage of this next-gen test automation feature is an indicator but not nearly good enough to be a proxy of the value delivered.</li><li><strong>Change in behavior and benefits 😇</strong>. The real outcome of a new feature is often a change in behavior that leads to a benefit. We could track, for example, the average number of tests automated per organization thanks to this new feature and correlate that number to a benefit: $x saved by test run.</li></ul><p>Using outcome-oriented metrics as shared goals is a game changer for the teams because they stop thinking about just releasing a feature but now work creatively to deliver an impact to the business. Delivery performance (and DORA metrics) tracks doing things right, while outcome-based goals ensure you’re doing the right thing.</p><h3>Accountability</h3><p>For developers, being accountable means taking ownership of their work, responsibilities, and the outcomes of their actions. Accountability around DORA metrics and business goals involves a commitment to delivering high-quality code, meeting deadlines, and adhering to best practices. It extends beyond completing tasks to ensure the code is efficient, maintainable, and free of critical bugs. Accountable developers understand the impact of their work on the overall project and strive to contribute positively to the team’s success.</p><p>Accountability also means being transparent and honest about progress and challenges. Developers should regularly communicate with their team and stakeholders, providing updates and alerting them to any issues or delays. This openness builds trust and ensures that problems are addressed promptly, minimizing their impact on the project. Taking responsibility for mistakes demonstrates a commitment to continuous improvement and learning, essential for personal and team growth.</p><p>Accountable developers actively seek feedback and learn from their peers. They recognize the importance of collaboration and knowledge sharing in a successful development process. By participating in code reviews, pair/mob programming, and team discussions, they contribute to a culture of mutual support and collective responsibility. This collaborative approach enhances code quality and fosters a sense of shared ownership and accountability.</p><p>Ultimately, accountability for developers means high agency. They anticipate potential issues and continuously seek ways to improve their skills and the development process. By embodying these principles, developers enhance their professional growth and contribute to their teams’ overall success and resilience.</p><h3>Final thought</h3><p>Creating a culture of engineering excellence and team progress hinges first on developing leaders with a growth mindset, who not only learn aggressively but also mentor and upskill their teams. It also means aligning teams with ambitious business goals, pushing boundaries, and fostering accountability. By focusing on these pillars, organizations can cultivate high-performing teams that achieve their goals while continuously improving and building new talents. This has been my recipe for ensuring that teams do the right things, the right way, ultimately driving business success.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=08b9835469d8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/creating-a-culture-of-engineering-excellence-and-team-progress-08b9835469d8">Creating a culture of engineering excellence and team progress</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[Embracing generative culture: the foundation to building high performing teams]]></title>
            <link>https://medium.com/promyze/embracing-generative-culture-the-foundation-to-building-high-performing-teams-dd6363d34944?source=rss----794278fcb836---4</link>
            <guid isPermaLink="false">https://medium.com/p/dd6363d34944</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[culture]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Laurent PY]]></dc:creator>
            <pubDate>Fri, 24 May 2024 12:47:29 GMT</pubDate>
            <atom:updated>2024-05-24T12:47:28.787Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TNeO-KxWeh6KUmWV6CcWUw.png" /></figure><p>In my first post of the series about <a href="https://www.packmind.com/secret-high-performing-software-teams/">building high performing teams</a>, I shared the single biggest factor in developer performance: <strong>skills</strong>!</p><p>In this second post, I’ll focus on a pivotal aspect that can make or break the journey: organizational culture, specifically the generative culture. Based on my experience and the insights offered by the DevOps Research and Assessment (DORA), I will share a few concrete steps you can undertake to cultivate a generative culture, a critical enabler of the 10x factor in engineering performance.</p><h3>What the hell is a generative culture?</h3><p>Dr. Ron Westrum, a sociologist, researched and identified a correlation between a robust culture, which facilitates the flow of information, and positive business outcomes.</p><p>From his research, he formulated a typology to describe various organizational cultures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4ErE52w95D0PNftb.png" /><figcaption>Credits: dora.dev</figcaption></figure><p>Building a <a href="https://dora.dev/devops-capabilities/cultural/generative-organizational-culture/">generative culture</a> is one of the 27 DORA capabilities, with demonstrated leverage in increasing team performance. As you can see in the chart below, generative culture and process capabilities required to improve delivery performance build on and reinforce each other.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MJEC9LjYFt-54vZ5.png" /><figcaption>Credits: dora.dev</figcaption></figure><p>And that makes sense. Have you seen many examples of teams deploying multiple times a day in a culture that is bureaucratic and where failure leads to punishment? Another way to think about Westrum’s findings is to consider code as text — <strong>information that flows</strong> through the dev lifecycle to ultimately be transformed into an experience for the end user. Back to the initial statement: there is a correlation between a robust culture that facilitates the <strong>flow of information</strong> and positive business outcomes.</p><h3>Leading by example</h3><p>So the generative culture promotes an environment where information flows freely, and innovative ideas are nurtured, creating a fertile ground for high performance and continuous improvement. Cool, but how to get there?</p><p>First, let me get back to a moment that was eye-opening for me. During a 360-review, one piece of feedback really caught my attention: ‘Sometimes Laurent will elaborate and make up an answer even if it is clear that he doesn’t know the answer.’ For a long time, I always wanted to appear right and avoid showing any vulnerability to the extent that I wasn’t able to say, ‘I don’t know or I failed.’ The message this sent to the team was terrible: it is not acceptable to lack answers or to fail. That was an aha moment for me that completely transformed my approach.</p><p>Yes, as leaders, we should often be right, as per one of Amazon’s leadership principles. However, it is okay to be wrong sometimes. Being humble, open to being wrong is an opportunity to learn and improve. It also shows your team that you are authentic and vulnerable. This is how you create the psychological safety necessary for a team to thrive, give their best, and sometimes fail.</p><p>Same goes with failure. Failure should lead to inquiry instead of scapegoating. There is no innovation without failure. Failures that lead to learning have compounding effects. Without learning, this is just a waste. And this is really aligned with the lean principle of seeking constant improvement. Interestingly I have seen engineering teams way more comfortable with the approach to failure than their leadership.</p><h3>Concrete steps to create a generative culture</h3><p>Here are some concrete steps you can take to create a generative culture:</p><ol><li><strong>Demonstrate Leadership Commitment and Role Modeling: </strong>Leadership must visibly commit to and model the behaviors that encourage a generative culture. This includes showing vulnerability, admitting mistakes, and fostering an environment where learning from failures is valued over assigning blame.</li><li><strong>Encourage and Reward Collaboration:</strong>Implement systems that reward teamwork and collaboration over individual accomplishments. This can include revising performance metrics to reflect team achievements and promoting cross-functional projects. Many teams have found success using Objectives and Key Results (OKRs), among other goal-setting frameworks. The key point is to measure success at the team level, reinforcing the concept that the team is the primary unit of progress.</li><li><strong>Promote Psychological Safety: </strong>Actively foster an environment where all team members feel safe to express their ideas, concerns, and questions without fear of retribution. Encourage open debates and constructive conflict to create healthy cognitive friction. It’s crucial for teams to engage in explicit debates, disagree openly, and commit to decisions once everyone has been heard, rather than silently disagreeing and potentially undermining the decisions made.</li><li><strong>Implement Blameless Postmortems: </strong>Focus on learning, not blame, when issues arise. Blameless postmortems are critical for uncovering root causes without finger-pointing, thereby nurturing a culture of learning and continuous improvement. This approach is a key marker of a generative culture. Toyota’s adoption of the <a href="https://www.packmind.com/dantotsu-best-practices/">Dantotsu</a> Radical Quality Improvement method, transforming it into a symbol of quality excellence, exemplifies this principle at its best. This approach to quality has been successfully implemented by the tech industry as well.</li><li><strong>Strive for Information Transparency and Clarity</strong>: Promote open access to information necessary for decision-making at all levels. The more information teams have about the strategy, finances, and goals of the organization, the better their decisions will be. Of course, this means that these elements must be clearly defined and without ambiguities. This context becomes the enabling constraints for the teams, guiding them within a framework that empowers autonomy while aligning with the organization’s overall objectives.</li><li><strong>Celebrate Innovation, experimentation: </strong>Create programs that reward innovation and experimentation, even when they don’t always lead to success. Recognizing and celebrating attempts at innovation encourages a culture of continuous improvement and risk-taking. Leverage hackathons to create opportunities for cross-functional learning, aiming to explore new territories.</li><li><strong>Foster Continuous Learning: </strong>As discussed in my first post, learning and upskilling are the biggest levers for improving engineering performance. Invest in your team’s continuous development by providing access to training and education, supporting participation in industry conferences and workshops, and emphasizing learning by doing — the biggest missed opportunity. The most successful organizations implement mentoring programs, pair or mob programming, Brown Bag Lunches (BBL), and internal conferences to promote a culture of knowledge sharing and learning by doing. Retention rates are significantly higher. These principles underpin <a href="https://www.packmind.com/">Packmind</a>, the platform enabling developers to <strong>share, learn, and refine their craft daily while enhancing their workflow</strong>.</li></ol><p>This is obviously not an overnight transformation and it starts from the CEO and ELT. It always struck me how much influence the CEO has on the culture compared to the relative influence on the execution. And that’s okay, because culture is a significant lever on people’s behavior and organizational outcomes. By fostering an environment of psychological safety, collaboration, and continuous learning, organizations can unlock the 10x factor, driving unparalleled performance and innovation.</p><p>I am eager to learn more about your experiences. How have you fostered a Generative culture within your organization? What challenges and successes have you encountered in this journey?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd6363d34944" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/embracing-generative-culture-the-foundation-to-building-high-performing-teams-dd6363d34944">Embracing generative culture: the foundation to building high performing teams</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[What is the secret of high-performing teams and how to achieve this 10x factor?]]></title>
            <link>https://medium.com/promyze/what-is-the-secret-of-high-performing-teams-and-how-to-achieve-this-10x-factor-23ee389d2e0f?source=rss----794278fcb836---4</link>
            <guid isPermaLink="false">https://medium.com/p/23ee389d2e0f</guid>
            <category><![CDATA[craftsmanship]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Laurent PY]]></dc:creator>
            <pubDate>Fri, 17 May 2024 15:30:16 GMT</pubDate>
            <atom:updated>2024-05-17T15:30:16.124Z</atom:updated>
            <content:encoded><![CDATA[<p>Over the past 20 years, I’ve had the privilege of leading high-performing teams that delivered quality software continuously, multiple times per day. I have also been responsible for product teams struggling to release once a quarter, hampered by quality issues.</p><p>The contrast in skills and behaviors between these teams has been stark. Reflecting on these differences, I’ve been driven to understand the root causes. Turns out, it’s not that simple. The environment, especially the role of top management, plays a big part. I could easily write an essay about top management being in the way 🙂. But, once you manage to fix that, what actually prevents a team from achieving excellence and how do you really measure performance?</p><p>I decided to write a series of posts about it starting with this one:</p><ul><li><strong>What is the secret of high-performing teams and how to achieve this 10x factor?</strong></li><li>The Westrum organizational culture and the importance of creating a safe environment. Dont coddle devs</li><li>Creating a culture of engineering excellence and team progress. ⇒ Context-based driven by business contraints. Exemple of Netflix. Cuklture of sharing</li><li>Deep dive into developers’ mentoring. do assesment and focus on what natters for team and business. Sparing partner VS coach</li><li>How will AI impact engineering performance?</li></ul><h3>So, what is the secret of high-performing teams?</h3><p>One week, as I was traveling and meeting a newly acquired team, the engineering lead described their CI/CD process to me:</p><ul><li>him: <em>We have the build that can take about an hour. Then we run our API tests, about 1000 in a staging environment for a couple of hours, and then…</em></li><li>me: (I interrupted him) <em>How long does it take from a code commit to release/production?</em></li><li>him: <em>Well, about 2 weeks if we include the manual testing.</em></li><li>me: <em>Is that a problem? I mean, such a long feedback loop for your developers.</em></li><li>him: <em>No, because in the meantime, our developers work on something else, another branch.</em></li></ul><p>That was a rough start…</p><p>Interestingly, on the same day, the lead of one of my top-performing teams reached out with a different kind of concern: “<em>Laurent, I think we need to ease up on rolling out new features. Our tests, all 7000+ of them, are now taking over 15 minutes to run. That’s too slow for us and is holding the team back. We need to fix this ASAP</em>.”</p><p>These 2 conversations perfectly highlight the massive gap in performance, skills, and expectations across teams. The difference couldn’t be starker.</p><p>So, you might wonder if there’s a playbook to go from being a low-performing team to a high-flying one, and what’s the biggest game-changer to make that leap? But first, let’s get clear on what we actually mean by ‘performance’.</p><h3>Decoding Performance with the DORA Framework</h3><p>Enter the <a href="https://dora.dev/">DORA</a> framework (DevOps Research and Assessment), our GPS for navigating the complex world of software delivery, showing us exactly where to zoom in for improvement. It proposes 4 metrics (Deployment Frequency, Change Lead Time, Change Failure Rate, Failed Deployment Recovery Time). Their research, based on 36,000 professionals worldwide, shows a causation between these metrics, delivery performance, and organizational performance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/1*vXz7zbIWoV-fmCshVdviDg.png" /></figure><p>You don’t have to pick between velocity and quality. That was a lie. You can and should have both. And this is backed by science. And, DORA proposes a playbook, 27 <a href="https://dora.dev/devops-capabilities/">capabilities</a> that you should invest in to improve your performance as measured by the 4 metrics. It includes technical capabilities like CI, Test Automation, Loosely Coupled Architecture, and many others, including process and culture capabilities.</p><p>Building these capabilities will improve your delivery performance and your business! That’s precisely why investing in our developers’ growth is so critical. Building skills is the root of any progress on these capabilities. The Playbook is there, opensource, knowledge is accessible and free.</p><h3>Then, it’s all about upskilling the team</h3><p>Upskilling developers is not just about enhancing their technical capabilities; it’s a holistic approach that includes improving their problem-solving skills, adaptability, and ability to work collaboratively. Focusing on upskilling helps create a culture of continuous learning and innovation. It involves:</p><ol><li><a href="https://dora.dev/devops-capabilities/cultural/learning-culture/"><strong>Continuous Learning</strong></a> (one of the DORA capabilities)<strong>:</strong> Encourage and provide resources for continuous learning. This can include access to online courses, attending workshops and conferences, and regular training sessions.</li><li><strong>Mentoring and Coaching:</strong> Pair less experienced developers with mentors who can guide them, fostering an environment where knowledge sharing becomes second nature. This not only accelerates the learning curve but also builds a strong sense of community and support within the team.</li><li><strong>Feedback Culture:</strong> Cultivate a culture where <a href="https://www.packmind.com/tech-leader-the-power-of-listening/">constructive feedback</a> is regularly exchanged. Make it clear that feedback is a tool for growth, not criticism. This encourages developers to stretch their boundaries and continuously improve.</li></ol><p>These are the three levers I have used to upskill the newly acquired team I mentioned at the beginning of this post. A few of my best tech leads have spent weeks with this team, mentoring and coaching them on TDD, automation, design patterns… And after a 2-year journey, they were able to deploy without downtime and release at the end of their 2-week sprints.</p><p>So, it’s all about upskilling teams, and this is exactly why I joined <a href="https://www.packmind.com/">Packmind</a>. Its mission resonates deeply with me: to elevate developers by putting the human element at the core of creating sustainable software. The <a href="https://www.packmind.com/">Packmind</a> platform accelerates the skill growth of developers by integrating learning directly into their workflow, making knowledge accessible right when and where it’s needed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QRyJSRIow9R0kIMy906DAg.png" /></figure><h3>Skills are also the biggest factor contributing to the value delivered</h3><p>Frameworks like DORA have dramatically improved our approach to team performance. Yet, the value delivered by a team remains an elusive notion. Regis Medina, during <a href="https://www.youtube.com/watch?v=U3D39kspGaA">FlowCon 2022</a>, brilliantly summarized this value in a simple formula:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IbFjXMchHEnnijL8FJHrAA.png" /></figure><p><strong>Value = Quality / Total Cost,</strong> where:</p><ul><li><strong>Quality</strong> encompasses all quality attributes of the project, including the achievement of functional scope, reliability, maintainability, scalability, security, etc.</li><li><strong>Total Cost</strong> includes not only the development cost but also the costs of operation, support, and maintenance of the project over time.</li></ul><p>Thus, exceptional teams know how to maximize quality while optimizing costs. And guess what! Developer skills are the key factors in maximizing the value produced!</p><p>Skilled developers and teams are more adept at identifying opportunities for cost reduction and, therefore, maximizing the value produced. They will know how to create sustainable software that can be run and supported cost-effectively using DRY, KISS S.O.L.I.D, and the right design. Skills are key to achieving that cost reduction.</p><p>On the numerator side of the equation, there is always a tension between quality and total cost. Establishing the right compromises is what truly defines the success of a project. The developer’s expertise also consists of better understanding customer requirements, constraints, and focusing on what really matters to build a quality product.</p><p>So, developer skills are what really enable them to maximize the value produced, thus ensuring the project’s success.</p><h3>Conclusion</h3><p>And that’s why my playbook has always been about creating a learning organization. The secret to unlocking a team’s full potential lies not only in the tools and processes we implement but in continuously investing in our developers’ growth. Upskilling is the cornerstone of transforming average teams into high-performing powerhouses, capable of not just meeting but exceeding expectations and delivering exceptional value at speed.</p><p>This is beneficial for the individuals and the business. I have never compromised on that. Invest in your developers, coach, mentor, train them, and they will take care of your product! That also means that when I hire, I look for people who are eager to learn and coachable. That’s at the top of the list.</p><p>This is the 10x factor that distinguishes the extraordinary from the ordinary.</p><p>I am really curious about your own experience. What has been your most effective strategy for upskilling your team? How do you foster a culture of continuous learning in your organization? Please share in comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23ee389d2e0f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/promyze/what-is-the-secret-of-high-performing-teams-and-how-to-achieve-this-10x-factor-23ee389d2e0f">What is the secret of high-performing teams and how to achieve this 10x factor?</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[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----794278fcb836---4</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----794278fcb836---4</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----794278fcb836---4</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----794278fcb836---4</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----794278fcb836---4</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:59 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----794278fcb836---4</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----794278fcb836---4</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:06 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>
    </channel>
</rss>