<?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[SourceLevel - Medium]]></title>
        <description><![CDATA[SourceLevel (https://sourcelevel.io) provides metrics and insights from data collected from GitHub and GitLab. Our product brings visibility over every corner of the delivery pipeline in a Data &amp; Analytics Solution for Engineering Teams. - Medium]]></description>
        <link>https://medium.com/sourcelevel?source=rss----ebf39c586b0e---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>SourceLevel - Medium</title>
            <link>https://medium.com/sourcelevel?source=rss----ebf39c586b0e---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 12:58:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/sourcelevel" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[The Perfect Git Commit Quest]]></title>
            <link>https://medium.com/sourcelevel/the-perfect-git-commit-quest-2490e5ba8644?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/2490e5ba8644</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[best-practices]]></category>
            <dc:creator><![CDATA[Weverton Timoteo]]></dc:creator>
            <pubDate>Tue, 22 Aug 2023 14:07:57 GMT</pubDate>
            <atom:updated>2023-08-07T21:25:56.809Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Importance of Writing a Good Commit Message</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*z1z4xKJvvwPOFGLEjX63eg.jpeg" /><figcaption>Photo by Markus Winkler</figcaption></figure><p>When it comes to Git commits, a well-crafted message is more than just a technical necessity. It serves as documentation, providing essential context for future reference. During a <strong>git show</strong>, a descriptive commit message offers valuable insights into the changes made, aiding comprehension and troubleshooting.</p><p>Furthermore, communicating with accessible peers about implementation and modifications opens doors for constructive collaboration and alternative perspectives. Tech leads can also better understand your approach, enabling them to offer valuable advice on advancing the solution using alternate methods.</p><h3>Commit Title/Header/Subject</h3><p>The commit header should be concise, with a maximum length of 72 characters in GitHub, to avoid truncation with ellipsis. Ending the title with a period is unnecessary, as every character counts. Starting with an imperative mood verb, such as <strong>Add</strong>, <strong>Fix</strong>, <strong>Remove</strong>, or <strong>Refactor</strong>, sets a clear and actionable tone for the commit.</p><h3>Using Conventional Commits</h3><p>To provide even more context, consider following the <a href="https://www.conventionalcommits.org/en/v1.0.0/">Conventional Commits</a> specification, which builds on the Angular Commit Guidelines. Prefix the title with specific keywords like fix, feature/feat, refactor, deploy, chore, docs, or test. Each prefix highlights the nature of the changes made.</p><ul><li><strong>fix</strong>: Represents a bug fix for your application.</li><li><strong>feature</strong> / <strong>feat</strong>: Adds a new feature to your application or library.</li><li><strong>refactor</strong>: A code change that neither fixes a bug nor adds a feature.</li><li><strong>deploy</strong>: Changes related to the deployment process.</li><li><strong>chore</strong>: Upgrades libraries and/or performs maintenance tasks.</li><li><strong>docs</strong>: Documentation-only changes.</li><li><strong>test</strong>: Adding missing tests or correcting existing tests.</li></ul><p>Here&#39;s an example:</p><pre>feature(shopping-cart): Add remove button<br><br>User can now remove the item entirely from shopping cart.<br><br>On clicking the button an animation transition will be<br>displayed.<br><br>&lt;https://linear.app/&gt;&lt;workspace&gt;/issue/A-123/add-ability-to-remove-item-from-shopping-cart</pre><h3>Commit Body</h3><p>Adding a line break between the header and the body helps organize information clearly. You can mention the files affected by the changes and explain the purpose and accomplishments of the commit. Keeping individual lines within 100 characters enhances readability.</p><ul><li>Add a linebreak between Header and the body</li><li>You can mention which files are included in these changes</li><li>Explain why and what was accomplished in this commit</li><li>Many tools recommends that any line cannot be longer than 100 characters, making each one more readable</li></ul><h3>Commit message conventions (Annotations)</h3><h3>Co-authored-by</h3><p>Marking your pairs during commits is essential for effective collaboration, especially in pair programming (eXtreme Programming). When the author accepts the suggestions block made during a Pull Request review, GitHub doesn’t use Suggested-by convention, instead it uses Co-authored-by.</p><p>While there are <a href="https://archive.kernel.org/oldwiki/git.wiki.kernel.org/index.php/CommitMessageConventions.html">more conventions to follow</a>, in common workflows, using <strong>Co-authored-by</strong> is strongly recommended.</p><h3>When to Commit?</h3><p>Committing early and often throughout development is highly recommended. Delaying commits until the end of the process can create challenges in organizing atomic commits, crafting a coherent narrative, and receiving timely feedback during the Code Review process. By committing regularly, you can easily create a Draft Pull/Merge Request to seek immediate peer input.</p><h3>Staging the Changes</h3><p>Simplify your commit process with tools like <a href="https://github.com/jesseduffield/lazygit"><strong>LazyGit</strong></a>, <a href="https://jonas.github.io/tig/"><strong>tig</strong></a>, <a href="https://desktop.github.com/"><strong>GitHub Desktop</strong></a>, <a href="https://www.git-tower.com/"><strong>Git Tower</strong></a>, or <a href="https://www.gitkraken.com/"><strong>GitKraken</strong></a>. When making changes, think of each commit as a &quot;package&quot; that should be &quot;revertable&quot; through <strong>git revert</strong> without breaking the build or test suite. Run tests right after creating a commit to ensure changes do not disrupt the suite. To temporarily remove existing changes, use <strong>git stash --include-untracked</strong>, then remember to <strong>git stash pop</strong> and continue the commit process.</p><h3>Forgot Something in the Previous Commit?</h3><p>If you missed including a change, you can easily remedy the situation with <strong>git add</strong> followed by <strong>git commit --amend</strong>. The <strong>--amend</strong> command picks up your previous commit message (don&#39;t forget to update the details about the inclusion) before pushing it with <strong>git push</strong>.</p><p>Note that if you already pushed the commit, you&#39;ll need to use <strong>git push -f</strong> to replace the existing commit with the regenerated SHA1 commit from the amendment. If you&#39;re collaborating with others in the same branch, remind your peers to pull the changes, though no impact is expected if they haven&#39;t started working in this branch yet.</p><h3>The Art of Summarize: Drafting/Opening a Pull Request</h3><p>When working on a project for 2-5 days, summarizing your work in a Pull Request can be challenging. Leverage your well-crafted commit messages to read the story and provide concise summaries to your reviewers. Doing so not only streamlines the review process but also serves as documentation for future reference.</p><h3>Tuning Your git Command</h3><p>Ensure your <strong>$EDITOR</strong> is set to your favorite editor for <strong>git commit</strong> execution:</p><pre>export EDITOR=nvim</pre><p>You can also configure <strong>core.editor</strong> to open any <strong>git</strong> command in your preferred editor (Visual Studio Code in this example):</p><pre>git config --global core.editor code --wait</pre><h3>Use Templates for Commit Messages</h3><p>Simplify the git commit message structure by using templates:</p><pre>$ git config --global commit.template ~/.gitmessage.txt<br>$ git commit</pre><p>Not sure how to start? Use this one:</p><pre># Replace this title (&lt;- imperative), &lt;= 50 chars, no period<br><br># Keep this blankline above but replace this line and below<br># by your body explaining *what* and *whay* (not *how*) no<br># more than 100 chars.<br><br># Here is a footer, include the Git Conventions annotations<br># you prefer, such as: <br># Co-authored-by: name &lt;user@users.noreply.github.com&gt;</pre><h3>The Journey to Better Commits: Level Up! Quest Completed!</h3><p>In the journey of perfecting your Git commits, you&#39;ve unlocked the art of crafting informative and context-rich messages that enhance your development process. Embracing Conventional Commits, staging your changes, and committing early and often, you&#39;ve laid the foundation for collaborative and efficient code reviews.</p><p>Before marking your Pull Request as “Ready for review”, check this blog post: &#39;<a href="https://sourcelevel.io/blog/10-items-to-check-before-assigning-a-pull-request-to-someone-plus-a-bonus">10 Items to Check Before Assigning a Pull Request to Someone</a>.&#39; Should your team seek more opportunities for reviews, venture into the realm of &#39;<a href="https://sourcelevel.io/blog/creating-code-reviews-opportunities">Creating Code Review Opportunities</a>&#39; for valuable insights. <strong>Continue your quest for better commits and conquer new challenges, kupo!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2490e5ba8644" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/the-perfect-git-commit-quest-2490e5ba8644">The Perfect Git Commit Quest</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mastering Git: The lesser-known commands you could be using (or not)]]></title>
            <link>https://medium.com/sourcelevel/mastering-git-the-lesser-known-commands-you-could-be-using-or-not-40aac31e3165?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/40aac31e3165</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[advanced-guide]]></category>
            <category><![CDATA[gitlab]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[github]]></category>
            <dc:creator><![CDATA[Weverton Timoteo]]></dc:creator>
            <pubDate>Wed, 16 Aug 2023 12:56:09 GMT</pubDate>
            <atom:updated>2023-08-16T12:56:09.569Z</atom:updated>
            <content:encoded><![CDATA[<p>Navigating the vast landscape of Git commands can sometimes feel like venturing into a bustling marketplace where everyone seems to know the most popular stalls: <strong>pull</strong>, <strong>commit</strong>, <strong>push</strong>, <strong>rebase</strong>, <strong>stash</strong>, and <strong>checkout</strong>. These commands are the cornerstone of everyday version control tasks, often forming the basis of a developer’s Git journey. But amidst this bustling crowd of common commands, have you ever paused to wonder, “What else can Git do?” Have you ever caught yourself in the quiet moments, pondering the existence of lesser-known Git commands that could potentially transform your workflow?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o4vH1cwQqOIBynY1.jpg" /><figcaption>Photo by Gabriel Heinzer</figcaption></figure><p>Join us as we navigate through these unexplored corners of Git, revealing commands that may have eluded your attention but can significantly enhance your mastery of version control.</p><h3>git switch: a fresh approach to branch management</h3><p>While git checkout remains a versatile command for various purposes, it also comes with the potential to inadvertently discard changes or create confusion. Enter git switch, introduced in Git version 2.23 as a dedicated tool for branch management.</p><p>Unlike the all-encompassing nature of git checkout, git switch focuses solely on simplifying branch-related operations. Its purpose is straightforward: to provide a clearer and safer way to switch branches, reducing the risk of errors and data loss.</p><p><strong>Why Consider Using </strong><strong>git switch?</strong></p><p>If you’ve ever felt the unease of accidentally losing your work while using git checkout, git switch offers a more reassuring alternative. This command offers explicit error messages and is designed to minimize the chances of unintentional changes.</p><p>Here are some examples of how you can use git switch effectively:</p><ul><li>Create and switch to a new branch with git switch -c my-new-branch, using the current commit as its base.</li><li>Swiftly switch to the main branch using git switch main</li><li>Return to the previous branch by employing git switch -</li></ul><h3>git bisect: tracking bugs down</h3><p>In software development, locating a bug can be akin to finding a needle in a haystack. But fear not — the git bisect command is here to help. It’s like a guided missile for tracking down the elusive bug.</p><p>Here’s how it works:</p><ol><li><strong>Identify Known States</strong>: First, you need to identify a “good” commit (when the code worked) and a “bad” commit (when the bug surfaced).</li><li><strong>Start Bisecting</strong>: Begin the process with: git bisect start</li><li><strong>Mark Known Commits</strong>: Tag the known “good” and “bad” commits: git bisect good &lt;good-commit&gt; git bisect bad &lt;bad-commit&gt;</li><li><strong>Navigate Commits</strong>: Git will automatically guide you to a commit between the two states. You test your code there. To see which commit you’re at: git log -n 1 --oneline</li><li><strong>Continue the Hunt</strong>: Based on your test, you mark the commit as “good” or “bad”: git bisect good # or git bisect bad</li><li><strong>Repeat Until Found</strong>: Git will automatically move to the next commit within the narrowed range. You repeat the process until you’ve pinpointed the bug’s source.</li><li><strong>End the Hunt</strong>: When you’ve found the problematic commit: git bisect reset</li></ol><p>This concludes the process and takes you back to the clean state and the previous HEAD before you started the bisect process.</p><h3>git notes: Enhancing Commit Context</h3><p>Git notes provide a versatile way to attach supplementary information to a commit without altering the commit itself.</p><p>Imagine you and your team found yourselves in a Git repository with less-than-ideal commit messages. Often, commits lack the necessary clarity to explain their purpose effectively. This feature allows you to enrich commits with essential context without the need to modify or rewrite commit SHA1.</p><p><strong>How to Utilize Git Notes</strong></p><p>Stored locally within .git/refs/notes, Git notes remain separate from the main commit data. By default, they are not pushed to the remote repository. However, this can be changed by pushing them in a manner similar to git tag:</p><pre>git push origin refs/notes/commits</pre><p>To retrieve existing notes from a remote repository:</p><pre>git fetch origin refs/notes/commits:refs/notes/commits</pre><h3>Adding Notes to Commits</h3><p>You can easily add notes to existing commits using the git notes add command:</p><pre>git notes add -m &quot;Introduce irreversible migrations at this point&quot; &lt;commit-sha1&gt;</pre><ul><li>The m option is optional. If omitted, your default text editor will open, allowing for a more detailed explanation.</li><li>If you skip providing &lt;commit-sha1&gt;, the HEAD commit will be assumed.</li></ul><h3>Removing Notes</h3><p>Removing notes is straightforward:</p><pre>git notes remove &lt;commit-SHA1&gt;</pre><h3>Listing and Viewing Notes</h3><p>To list all existing notes:</p><pre>git notes list</pre><p>For more in-depth insight into a specific note:</p><pre>git notes show &lt;commit-SHA1&gt;</pre><p>Unfortunately, GitHub no longer displays <strong>git notes</strong> in its UI. This adjustment, in my opinion, reflects the limited usage of these commands. By making this change, GitHub appears to be fostering a culture of encouraging developers to consistently produce improved commits without the temptation to revisit or dwell on the details of previous commits.</p><h3>Sharing Diffs: git diff + git apply</h3><p>Consider a common scenario: a pair programming session happens to address a specific problem. During this interaction, the most experienced developer takes the lead, demonstrating a viable solution by implementing essential changes.</p><p>As the collaborative session unfolds, these changes become crucial building blocks for the solution. To facilitate the smooth continuation of this collaborative effort, Git provides two essential commands: git diff and git apply.</p><p>Once the demonstration is complete, and the necessary changes are in place, you can encapsulate these modifications within a concise patch file:</p><pre>git diff &gt; ~/Downloads/pair_programming_session.patch</pre><p>The other developer can then seamlessly incorporate these modifications into their local codebase using:</p><pre>git apply pair_programming_session.patch</pre><p>In this manner, Git offers an efficient mechanism for transferring insights and progress gained from collaborative coding sessions, ensuring that developmental strides are effectively communicated.</p><h3>Embrace Unfamiliar Commands</h3><p>I understand that consistently learning new tools and programming languages can be challenging. However, it’s important to recognize that <strong>git</strong> serves as a tool for delivering your work. Thus, make it a practice to regularly peruse the official documentation and keep your <strong>git</strong> CLI updated to fully leverage its capabilities and embrace new features.</p><p>Have you ever considered integrating these commands into your workflow? I hope you’ve found something useful or at least identified a command to avoid using.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40aac31e3165" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/mastering-git-the-lesser-known-commands-you-could-be-using-or-not-40aac31e3165">Mastering Git: The lesser-known commands you could be using (or not)</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Creating Code Reviews opportunities]]></title>
            <link>https://medium.com/sourcelevel/creating-code-reviews-opportunities-2115a0ce0f22?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/2115a0ce0f22</guid>
            <category><![CDATA[merge-request]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[pull-request]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[gitlab]]></category>
            <dc:creator><![CDATA[Weverton Timoteo]]></dc:creator>
            <pubDate>Mon, 31 Jul 2023 18:44:37 GMT</pubDate>
            <atom:updated>2023-07-31T18:44:37.817Z</atom:updated>
            <content:encoded><![CDATA[<p>Picture this: Your team is working on a project, and Pull/Merge Requests are piling up without any reviews. Code Reviews are not just a formality; they are an incredible opportunity to learn, grow, motivate, mentor, debate, and share knowledge. So, how can you turn this situation around and make the most out of Code Reviews to enhance your development process?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tQHa8c9fcBKNWT3v.jpg" /></figure><h3>Finding Time Slots — Optimizing Your Review Routine</h3><p>Reviewing code shouldn’t be an added burden to your team’s daily tasks. Instead, seamlessly integrate it into your workflow by using available time slots. Take advantage of moments like coffee breaks, filling your water bottle, grabbing a coffee, or just before lunchtime and wrapping up the day. By incorporating these review moments into your daily rhythm, you ensure consistent Code Reviews without disrupting your workflow, promoting a culture of continuous improvement.</p><h3>Using Interruptions to Your Advantage</h3><p>Interruptions are unavoidable, but they can also be opportunities for the Code Review process. When interrupted, use the time to review code. Seamlessly integrate Code Reviews into various workflow transitions, such as finishing user stories, pulling new user stories, opening pull requests, merging pull requests, and ending pair programming sessions.</p><p>Dedicate specific time slots for reviews to ensure a focused approach. Avoid rushing reviews under time pressure; communicate time constraints and plan for thorough reviews. Prioritize quality over quantity; thoroughly review a few Pull Requests rather than performing hasty, superficial reviews.</p><h3>Maximizing Collaboration: Pair Programming’s Hidden Gem — Code Reviews</h3><p>Pair programming fosters collaboration and knowledge sharing. At the end of a session, leverage this opportunity for collaborative Code Reviews. Engage in open discussions, share feedback, document decisions, and celebrate successes, boosting collaboration, code quality, and a culture of continuous learning and growth.</p><h3>Empowering Psychological Safety in Code Review Discussions</h3><p>Prioritize psychological safety to enhance team collaboration and code quality. Encourage openness and embrace diverse perspectives during reviews. Deliver feedback respectfully and focus on the code, not the developer. Lead by example, treat mistakes as learning opportunities, and provide guidance to support less experienced team members. Welcome questions and set clear expectations for Code Reviews.</p><p>Empowering psychological safety encourages questions and fosters a welcoming environment for other reviewers to participate and interact. Your team can foster a culture of trust, continuous improvement, and code excellence.</p><h3>Optimizing Code Reviews with Available Tools</h3><p>Streamline the Code Review process and avoid overlooking reviews by using available tools. GitHub Reminders, integrated with Slack, improve communication and collaboration. Assigned “Reviewers” receive direct messages, ensuring timely notifications. Configure a Slack channel to receive daily reminders, helping the team stay informed and address reviews promptly.</p><h3>Fostering Accountability through Code Reviews</h3><p>Code Reviews promote accountability within your team. As “Reviewers,” team members take ownership of the codebase, ensuring it meets the team’s standards. A culture of mutual support and continuous improvement emerges, enhancing overall productivity and code quality.</p><h3>Embrace a Strong Code Review Culture</h3><p>Before assigning a Pull Request to someone, consider taking a moment to review it yourself. By ensuring your PR is well-prepared and clear, you set the stage for efficient and effective feedback sessions. To optimize your Code Review process and discover essential tips for preparing Pull Requests, explore our blog post <a href="https://sourcelevel.io/blog/10-items-to-check-before-assigning-a-pull-request-to-someone-plus-a-bonus"><strong>here</strong></a>.</p><p>With a proactive approach to Code Reviews and a commitment to continuous learning, your team will thrive in a collaborative and supportive environment.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2115a0ce0f22" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/creating-code-reviews-opportunities-2115a0ce0f22">Creating Code Reviews opportunities</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sunsetting SourceLevel’s Code Quality feature: What’s next? — SourceLevel]]></title>
            <link>https://medium.com/sourcelevel/sunsetting-sourcelevels-code-quality-feature-what-s-next-sourcelevel-d78aead6cc62?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/d78aead6cc62</guid>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[engineering-ops]]></category>
            <category><![CDATA[linter]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[engineering-management]]></category>
            <dc:creator><![CDATA[Weverton Timoteo]]></dc:creator>
            <pubDate>Wed, 15 Jun 2022 20:09:20 GMT</pubDate>
            <atom:updated>2022-06-21T18:27:44.749Z</atom:updated>
            <content:encoded><![CDATA[<h3>Sunsetting SourceLevel’s Automated Code Review feature: What’s next?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Tf3QksOjapNvzUx0.jpg" /></figure><p>When we launched SourceLevel, we had a great focus on Automated Code Review, through 30+ Open Source linters (including support for Ruby, JavaScript, Elixir, Golang, PHP, Python, etc.). During product validation we have introduced some use case metrics which includes Work In Progress, Engagement, and Deliveries.</p><p>Last year, we released a new product completely focused on Engineering Metrics. And we’ve decided to sunset the Automated Code Review feature, improving our Analytics product bringing visibility over every corner of the delivery pipeline in a Data &amp; Analytics Solution for Engineering Teams.</p><p>We still consider Code Quality metrics relevant, but we don’t think we should keep running the linters since a lot of free alternatives are available to be included in your Continuous Integration pipeline, such as <a href="https://github.com/features/actions">GitHub Actions</a>.</p><p>In the future, we are considering importing issues identified by these runners through our API. We’d recommend including the linter that you use to your GitHub Actions pipeline or consider installing <a href="https://danger.systems/">Danger.systems</a> (which supports Ruby, Python, Swift, Kotlin, and JavaScript) for your organization.</p><p>We’ll start contacting existing customers to notify about Automated Code Review sunset and schedule a turn-off customer-by-customer.</p><p>Currently, Analytics is providing metrics for Software Engineering Management, to see a glimpse of what we offer, go to our <a href="https://sourcelevel.io/engineering-metrics">Engineering Metrics</a> page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/100/0*n2kllzjPHrEHBVa1" /></figure><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/sunsetting-sourcelevels-code-quality-feature-whats-next"><em>https://sourcelevel.io</em></a><em> on June 15, 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d78aead6cc62" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/sunsetting-sourcelevels-code-quality-feature-what-s-next-sourcelevel-d78aead6cc62">Sunsetting SourceLevel’s Code Quality feature: What’s next? — SourceLevel</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[RuboCop: How to install and configure — SourceLevel]]></title>
            <link>https://medium.com/sourcelevel/rubocop-how-to-install-and-configure-sourcelevel-949dbd514bd1?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/949dbd514bd1</guid>
            <category><![CDATA[linter]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[rubocop]]></category>
            <category><![CDATA[rails]]></category>
            <category><![CDATA[ruby]]></category>
            <dc:creator><![CDATA[Gustavo Araújo]]></dc:creator>
            <pubDate>Tue, 15 Mar 2022 13:54:49 GMT</pubDate>
            <atom:updated>2022-03-18T19:40:22.578Z</atom:updated>
            <content:encoded><![CDATA[<h3>RuboCop: How to install and configure — SourceLevel</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TCtmbuDcKAESTgh8.jpeg" /></figure><p>That Code quality is important, and any high-performing team knows it, but do you follow a guideline to standardize your codebase and make sure that everyone is going and looking in the same direction?</p><p>Making a brief introduction, this is the goal of a linter: A tool that analyzes your source code to identify programming errors, bugs, and suspicious constructions</p><p>The main objective is to ensure that your code follows the same rules and practices, to look like the entire code was written by the same person.</p><p>In a large variety of linters from Ruby, we have (available as a gem) that follows the best practices described in <a href="https://rubystyle.guide/">The Ruby Style Guide</a>.</p><p>One of the advantages of using a linter is to save time reviewing code because it prevents small issues like inconsistent variable names and practices during the development process. With that, the code review is more efficient, and it can be focused on implementations and features requirements.</p><p>Starting using RuboCop is very straightforward and doesn’t depend on anyone else to setup it. You can install the gem and run it immediately during your workflow.</p><h3>Installation</h3><p>To install the RuboCop, it’s quick and easy. Let’s consider here that all your Ruby environment is working, so just execute the following command to install the latest RuboCop version available:</p><pre>$ gem install rubocop</pre><p>RuboCop officially supports the <strong>MRI 2.5+</strong> and <strong>jRuby 9.2+</strong> implementations. You can also install directly in the project using Bundler, adding the gem to your Gemfile, and then run bundle install.</p><h3>Configuration</h3><p>The RuboCop behavior can be controlled in the .rubocop.yml file in the root path where you want to execute it. In this file, you can enable/disable certain cops (rules) or change their behavior.</p><p>All cops are grouped into departments: <strong>Style</strong>, <strong>Layout</strong>, <strong>Lint</strong>, <strong>Naming</strong>, <strong>Security</strong>, <strong>Metrics</strong>, <strong>Migration</strong>, <strong>Bundler,</strong> and <strong>Gemspec</strong>. You can read about the cops and their departments in the <a href="https://docs.rubocop.org/rubocop/cops.html">documentation</a>. For reference purposes, check the configuration file that we use in <a href="https://sourcelevel.io/">SourceLevel</a> in our <a href="https://github.com/sourcelevel/linters/blob/main/.rubocop.yml">linter’s configuration repository</a>.</p><p>The .rubocop.yml file has the following structure:</p><pre>inherit_from: ../.rubocop.yml</pre><pre>require: rubocop-rails</pre><pre>Style/Encoding:<br>  Enabled: false</pre><pre>Layout/LineLength:<br>  Max: 99</pre><pre>...</pre><p><em>Note 1: We’re using inherit_from to inherit all defined cops in the other file. See more in the </em><a href="https://docs.rubocop.org/rubocop/configuration.html#inheritance">documentation</a><em>.</em><br><em>Note 2: If you’re using Rails, it’s important to require the rubocop-rails extension (remember to add it to your Gemfile), which will force RuboCop to follow the </em><a href="https://rails.rubystyle.guide/">conventions and good practices</a><em> defined by the Rails community.</em></p><p>By default, when executed, the RuboCop looks for .rubocop.yml in the current directory, then in your home path (~/.rubocop.yml), and in the last case it will use the defaults. More details about RuboCop&#39;s configuration file can be found on the <a href="https://docs.rubocop.org/rubocop/configuration.html">documentation</a>.</p><p>If you want to create your configuration file, which I encourage, a good starting point is to use the <a href="https://github.com/rubocop/rubocop/blob/master/.rubocop.yml">configuration</a> available in the RuboCop repository as a reference. You can review cop by cop and configure what suits you. Just remember to check the cop availability for the version of RuboCop that you’re using.</p><p>Keep in mind that style rules that belong to the Style namespace are configurable and optional. A good recommendation is that these rules need to be discussed and defined with the entire team, not by a single person.</p><p>It’s nice to mention that you can write your own cops, called <strong>Custom Cops</strong>. With that, you can create your own rules, defining your practices to ensure that they will be followed. You can find more information about this process in <a href="https://docs.rubocop.org/rubocop/development.html">documentation</a>.</p><h3>Usage</h3><p>To use the RuboCop you just need to navigate to the directory where you want to run the linter, and execute:</p><p>You can specify a file/path too:</p><pre>$ rubocop lib/file.rb</pre><p>It’s possible to specify a list of directories and files:</p><pre>$ rubocop app/ spec/ lib/file.rb</pre><p>After running RuboCop, you’ll get an output with offenses, like:</p><pre>Offenses:</pre><pre>test.rb:1:1: C: Style/FrozenStringLiteralComment: Missing magic comment # frozen_string_literal: true.<br>def badName<br>^<br>test.rb:1:5: C: Naming/MethodName: Use snake_case for method names.<br>def badName<br>    ^^^^^^^<br>test.rb:2:3: C: Style/GuardClause: Use a guard clause instead of wrapping the code inside a conditional expression.<br>  if something<br>  ^^<br>test.rb:2:3: C: Style/IfUnlessModifier: Favor modifier if usage when having a single-line body. Another good alternative is the usage of control flow &amp;&amp;/||.<br>  if something<br>  ^^<br>test.rb:4:5: W: Layout/EndAlignment: end at 4, 4 is not aligned with if at 2, 2.<br>    end<br>    ^^^</pre><pre>1 file inspected, 5 offenses detected</pre><h3>Autocorrecting</h3><p>A great thing about RuboCop is the autocorrecting feature. This option fix automatically all possible offenses in your code, based on defined rules. In our case, we use -a that fix safe offenses, but you can be more optimistic and use -A to fix all offenses (including unsafe), but you need to use it with caution.</p><p>To use them, you just need to run RuboCop with this autocorrecting argument:</p><pre>$ rubocop --auto-correct # or $ rubocop -a</pre><p>You can check all <strong>RoboCop’s</strong> arguments using the --help:</p><pre>$ rubocop --help</pre><p>Just for linking purposes, you can check the <a href="https://docs.rubocop.org/rubocop/usage/auto_correct.html">documentation</a> to know more about autocorrect.</p><h3>Integrating with other tools</h3><p>RuboCop integrates with many other tools. You may integrate it into your code editor to run it every time you save a file, and you’ll immediately get its insights.</p><p>For a list of currently supported code editors, you can check <a href="https://docs.rubocop.org/rubocop/integration_with_other_tools.html#editor-integration">this page</a> on documentation, and if your favorite is not listed, it’s a great opportunity to contribute to RuboCop implementing an integration.</p><p>Another great usage is creating a <a href="https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks">Git Hook</a> to run RuboCop before every commit. You can also setup RuboCop to be run into your Continuous Integration service (such as GitHub Actions) to have some insights for every commit. In all cases, more details can be found in the <a href="https://docs.rubocop.org/rubocop/integration_with_other_tools.html#git-pre-commit-hook-integration-with-pre-commit">documentation</a>.</p><p>I hope you enjoyed the content, and thank you for reading.</p><figure><img alt="Authors photo" src="https://cdn-images-1.medium.com/max/266/1*TfqaaKSYTmU7yX0o104Q3w.jpeg" /><figcaption><a href="https://medium.com/u/d63b2a610a7">Gustavo Araújo</a> — <a href="https://twitter.com/garaujodev">Twitter</a></figcaption></figure><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/rubocop-how-to-install-and-configure"><em>https://sourcelevel.io</em></a><em> on March 11, 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=949dbd514bd1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/rubocop-how-to-install-and-configure-sourcelevel-949dbd514bd1">RuboCop: How to install and configure — SourceLevel</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[State of Golang linters and the differences between them — SourceLevel]]></title>
            <link>https://medium.com/sourcelevel/state-of-golang-linters-and-the-differences-between-them-sourcelevel-3ae2c2072171?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/3ae2c2072171</guid>
            <category><![CDATA[golint]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[linter]]></category>
            <dc:creator><![CDATA[Weverton Timoteo]]></dc:creator>
            <pubDate>Thu, 20 Jan 2022 21:36:36 GMT</pubDate>
            <atom:updated>2022-01-20T21:36:36.777Z</atom:updated>
            <content:encoded><![CDATA[<h3>State of Golang linters and the differences between them — SourceLevel</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dqjXYCSdWMT7pC-G.jpeg" /></figure><p>Golang is full of tools to help us on developing securer, reliable, and useful apps. And there is a category that I would like to talk about: <strong>Static Analysis through Linters</strong>.</p><h3>What is a linter?</h3><p>Linter is a tool that analyzes source code without the need to compile/run your app or install any dependencies. It will perform many checks in the static code (the code that you write) of your app.</p><p>It is useful to help software developers ensure coding styles, identify tech debt, small issues, bugs, and suspicious constructs. Helping you and your team in the entire development flow.</p><p>Linters <a href="https://sourcelevel.io/linters-unleashing-the-power-of-static-code-analysis">are available for many languages</a>, but let us take a look at the Golang ecosystem.</p><h3>First things first: how do linters analyze code?</h3><p>Most linters analyzes the result of two phases:</p><h3>Lexer</h3><p>Also known as tokenizing/scanning is the phase in which we convert the source code statements into <em>tokens</em>. So each keyword, constant, variable in our code will produce a token.</p><h3>Parser</h3><p>It will take the tokens produced in the previous phase and try to determine whether these statements are semantically correct.</p><h3>Golang packages</h3><p>In Golang we have scanner, token, parser, and ast (Abstract Syntax Tree) packages. Let&#39;s jump straight to a practical example by checking this simple snippet:</p><pre>package main</pre><pre>func main() {<br> println(&quot;Hello, SourceLevel!&quot;)<br>}</pre><p>Okay, nothing new here. Now we’ll use Golang standard library packages to visualize the ast generated by the code above:</p><pre>import (<br> &quot;go/ast&quot;<br> &quot;go/parser&quot;<br> &quot;go/token&quot;<br>)</pre><pre>func main() {<br> // src is the input for which we want to print the AST.<br> src := `our-hello-world-code`</pre><pre>// Create the AST by parsing src.<br> fset := token.NewFileSet() // positions are relative to fset<br> f, err := parser.ParseFile(fset, &quot;&quot;, src, 0)<br> if err != nil {<br>  panic(err)<br> }</pre><pre>// Print the AST.<br> ast.Print(fset, f)<br>}</pre><p>Now let’s run this code and look the generated AST:</p><pre> 0  *ast.File {<br> 1  .  Package: 2:1<br> 2  .  Name: *ast.Ident {<br> 3  .  .  NamePos: 2:9<br> 4  .  .  Name: &quot;main&quot;<br> 5  .  }<br> 6  .  Decls: []ast.Decl (len = 1) {<br> 7  .  .  0: *ast.FuncDecl {<br> 8  .  .  .  Name: *ast.Ident {<br> 9  .  .  .  .  // Name content<br>16  .  .  .  }<br>17  .  .  .  Type: *ast.FuncType {<br>18  .  .  .  .  // Type content<br>23  .  .  .  }<br>24  .  .  .  Body: *ast.BlockStmt {<br>25  .  .  .  .  // Body content<br>47  .  .  .  }<br>48  .  .  }<br>49  .  }<br>50  .  Scope: *ast.Scope {<br>51  .  .  Objects: map[string]*ast.Object (len = 1) {<br>52  .  .  .  &quot;main&quot;: *(obj @ 11)<br>53  .  .  }<br>54  .  }<br>55  .  Unresolved: []*ast.Ident (len = 1) {<br>56  .  .  0: *(obj @ 29)<br>57  .  }<br>58  }</pre><p>As you can see, the AST describes the previous block in a struct called ast.File which is compound by the following structure:</p><pre>type File struct {<br> Doc        *CommentGroup   // associated documentation; or nil<br> Package    token.Pos       // position of &quot;package&quot; keyword<br> Name       *Ident          // package name<br> Decls      []Decl          // top-level declarations; or nil<br> Scope      *Scope          // package scope (this file only)<br> Imports    []*ImportSpec   // imports in this file<br> Unresolved []*Ident        // unresolved identifiers in this file<br> Comments   []*CommentGroup // list of all comments in the source file<br>}</pre><p>To understand more about lexical scanning and how this struct is filled, I would recommend <a href="https://www.youtube.com/watch?v=HxaD_trXwRE">Rob Pike talk</a>.</p><p>Using AST is possible to check the formatting, code complexity, bug risk, unused variables, and a lot more.</p><h3>Code Formatting</h3><p>To format code in Golang, we can use the gofmt package, which is already present in the installation, so you can run it to automatically indent and format your code. Note that it uses tabs for indentation and blanks for alignment.</p><p>Here is a simple snippet from <a href="https://gobyexample.com/closures">Go by Examples</a> unformatted:</p><pre>package main</pre><pre>import &quot;fmt&quot;<br>func intSeq() func() int {<br>    i := 0</pre><pre>return func() int {<br>        i++<br>        return i<br>    }<br>}</pre><pre>func main() {</pre><pre>nextInt := intSeq()</pre><pre>fmt.Println(nextInt())<br>    fmt.Println(nextInt())<br>       fmt.Println(nextInt())</pre><pre>newInts := intSeq()<br>    fmt.Println(newInts())</pre><pre>}</pre><p>Then it will be formatted this way:</p><pre>package main</pre><pre>import &quot;fmt&quot;</pre><pre>func intSeq() func() int {<br> i := 0</pre><pre>return func() int {<br>  i++<br>  return i<br> }<br>}</pre><pre>func main() {</pre><pre>nextInt := intSeq()</pre><pre>fmt.Println(nextInt())<br> fmt.Println(nextInt())<br> fmt.Println(nextInt())</pre><pre>newInts := intSeq()<br> fmt.Println(newInts())</pre><pre>}</pre><p>So we can observe that import earned an extra linebreak but the empty line after main function declaration is still there. So we can assume that we shouldn&#39;t transfer the responsibility of keeping your code readable to the gofmt: consider it as a helper on accomplishing readable and maintainable code.</p><p>It’s highly recommended to run gofmt before you commit your changes, you can even <a href="https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks">configure a precommit hook</a> for that. If you want to overwrite the changes instead of printing them, you should use gofmt -w.</p><h3>Simplify option</h3><p>gofmt has a -s as Simplify command, when running with this option it considers the following:</p><p><strong>An array, slice, or map composite literal of the form:</strong></p><pre>[]T{T{}, T{}}</pre><p>will be simplified to:</p><pre>[]T{{}, {}}</pre><p><strong>A slice expression of the form:</strong></p><pre>s[a:len(s)]</pre><p>will be simplified to:</p><pre>s[a:]</pre><p><strong>A range of the form:</strong></p><pre>for x, _ = range v {...}</pre><p>will be simplified to:</p><pre>for x = range v {...}</pre><p>Note that for this example, if you think that variable is important for other collaborators, maybe instead of just dropping it with _ I would recommend using _meaningfulName instead.</p><p><strong>A range of the form:</strong></p><pre>for _ = range v {...}</pre><p>will be simplified to:</p><pre>for range v {...}</pre><p>Note that it could be incompatible with earlier versions of Go.</p><h3>Check unused imports</h3><p>On some occasions, we can find ourselves trying different packages during implementation and just give up on using them. By using <a href="https://pkg.go.dev/golang.org/x/tools/cmd/goimports">goimports package</a> we can identify which packages are being imported and unreferenced in our code and also add missing ones:</p><pre>go install golang.org/x/tools/cmd/goimports@latest</pre><p>Then use it by running with -l option to specify a path, in our case we&#39;re doing a recursive search in the project:</p><pre>go imports -l ./.. ../my-project/vendor/github.com/robfig/cron/doc.go</pre><p>So it identified that cron/doc is unreferenced in our code and it&#39;s safe to remove it from our code.</p><h3>Code Complexity</h3><p>Linters can be also used to identify how complex your implementation is, using some methodologies for example, let’s start by exploring ABC Metrics.</p><h3>ABC Metrics</h3><p>It’s common nowadays to refer to how large a codebase is by referring to the LoC (Lines of Code) it contains. To have an alternate metric to LoC, Jerry Fitzpatrick proposed a concept called <a href="https://en.wikipedia.org/wiki/ABC_Software_Metric">ABC Metric</a>, which are compounded by the following:</p><ul><li><strong>(A) Assignment counts:</strong> = , *= , /=, %=, +=, &lt;&lt;=, &gt;&gt;=, &amp;=, ^=, ++, and --</li><li><strong>(B) Branch counts when:</strong> Function is called</li><li><strong>(C) Conditionals counts:</strong> Booleans or logic test (?, &lt;, &gt;, &lt;=, &gt;=, !=, else, and case)</li></ul><p><strong><em>Caution:</em></strong> This metric should <strong>not</strong> be used as a “score” to decrease, consider it as just an indicator of your codebase or current file being analyzed.</p><p>To have this indicator in Golang, you can use <a href="https://github.com/droptheplot/abcgo">abcgo package</a>:</p><pre>$ go get -u github.com/droptheplot/abcgo<br>$ (cd $GOPATH/src/github.com/droptheplot/abcgo &amp;&amp; go install)</pre><p>Give the following Golang snippet:</p><pre>package main</pre><pre>import (<br> &quot;fmt&quot;<br> &quot;os&quot;</pre><pre>&quot;my_app/persistence&quot;<br> service &quot;my_app/services&quot;</pre><pre>flag &quot;github.com/ogier/pflag&quot;<br>)</pre><pre>// flags<br>var (<br> filepath string<br>)</pre><pre>func main() {<br> flag.Parse()</pre><pre>if flag.NFlag() == 0 {<br>  printUsage()<br> }</pre><pre>persistence.Prepare()<br> service.Compare(filepath)<br>}</pre><pre>func init() {<br> flag.StringVarP(&amp;filepath, &quot;filepath&quot;, &quot;f&quot;, &quot;&quot;, &quot;Load CSV to lookup for data&quot;)<br>}</pre><pre>func printUsage() {<br> fmt.Printf(&quot;Usage: %s [options]\n&quot;, os.Args[0])<br> fmt.Println(&quot;Options:&quot;)<br> flag.PrintDefaults()<br> os.Exit(1)<br>}</pre><p>Then let’s analyze this example using abcgo:</p><pre>$ abcgo -path main.go<br>Source            Func         Score   A   B   C<br>/tmp/main.go:18   main         5       0   5   1<br>/tmp/main.go:29   init         1       0   1   0<br>/tmp/main.go:33   printUsage   4       0   4   0</pre><p>As you can see, it will print the <em>Score</em> based on each function found in the file. This metric can help new collaborators identify files that a pair programming session would be required during the onboarding period.</p><h3>Cyclomatic Complexity</h3><p><a href="https://en.wikipedia.org/wiki/Cyclomatic_complexity">Cyclomatic Complexity</a> in another hand, besides the complex name, has a simple explanation: it calculates how many paths your code has. It is useful to indicate that you may break your implementation in separate abstractions or give some <a href="https://en.wikipedia.org/wiki/Code_smell">code smells</a> and insights.</p><p>To analyze our Golang code let use <a href="https://github.com/fzipp/gocyclo">gocyclo package</a>:</p><pre>$ go install github.com/fzipp/gocyclo/cmd/gocyclo@latest</pre><p>Then let’s check the same piece of code that we’ve analyzed in the ABC Metrics section:</p><pre>$ gocyclo main.go<br>2 main main main.go:18:1<br>1 main printUsage main.go:33:1<br>1 main init main.go:29:1</pre><p>It also breaks the output based on function name, so we can see that the main function has 2 paths since we&#39;re using if conditional there.</p><h3>Style and Patterns Checking</h3><p>To verify code style and patterns in your codebase, Golang already came with installed. Which was a linter that offer no customization but it was performing recommended checks from the Golang development team. It was archived in mid-2021 and it is being recommended <a href="https://staticcheck.io/">Staticcheck</a> be used as a replacement.</p><h3>Golint vs Staticcheck vs revive</h3><p>Before Staticcheck was recommended, we had <a href="https://revive.run/">revive</a>, which for me sounds more like a community alternative linter.</p><p>As revive states how different it is from archived golint:</p><ul><li>Allows us to enable or disable rules using a configuration file.</li><li>Allows us to configure the linting rules with a TOML file.</li><li>2x faster running the same rules as golint.</li><li>Provides functionality for disabling a specific rule or the entire linter for a file or a range of lines.</li><li><strong>golint</strong> allows this only for generated files.</li><li>Optional type checking. Most rules in golint do not require type checking. If you disable them in the config file, revive will run over 6x faster than golint.</li><li>Provides multiple formatters which let us customize the output.</li><li>Allows us to customize the return code for the entire linter or based on the failure of only some rules.</li><li><strong>Everyone can extend it easily with custom rules or formatters.</strong></li><li><strong>Revive</strong> provides more rules compared to <strong>golint</strong>.</li></ul><h3>Testing revive linter</h3><p>I think the extra point goes for <strong>revive</strong> at the point of creating custom rules or formatters. Wanna try it?</p><pre>$ go install github.com/mgechev/revive@latest</pre><p>Then you can run it with the following command:</p><pre>$ revive -exclude vendor/... -formatter friendly ./...</pre><p>I often exclude my vendor directory since my dependencies are there. If you want to customize the checks to be used, you can supply a configuration file:</p><pre># Ignores files with &quot;GENERATED&quot; header, similar to golint<br>ignoreGeneratedHeader = true</pre><pre># Sets the default severity to &quot;warning&quot;<br>severity = &quot;warning&quot;</pre><pre># Sets the default failure confidence. The semantics behind this property<br># is that revive ignores all failures with a confidence level below 0.8.<br>confidence = 0.8</pre><pre># Sets the error code for failures with severity &quot;error&quot;<br>errorCode = 0</pre><pre># Sets the error code for failures with severity &quot;warning&quot;<br>warningCode = 0</pre><pre># Configuration of the `cyclomatic` rule. Here we specify that<br># the rule should fail if it detects code with higher complexity than 10.<br>[rule.cyclomatic]<br>  arguments = [10]</pre><pre># Sets the severity of the `package-comments` rule to &quot;error&quot;.<br>[rule.package-comments]<br>  severity = &quot;error&quot;</pre><p>Then you should pass it on running revive:</p><pre>$ revive -exclude vendor/... -config revive.toml -formatter friendly ./...</pre><h3>What else?</h3><p>As I’ve shown, you can use linters for many possibilities, you can also focus on:</p><ul><li>Performance</li><li>Unused code</li><li>Reports</li><li>Outdated packages</li><li>Code without tests (no coverage)</li><li>Magic number detector</li></ul><p>Feel free to try new linters that I didn’t mention here, I’d recommend the <a href="https://github.com/golangci/awesome-go-linters#linters">archived repository awesome-go-linters</a>.</p><h3>Where to start?</h3><p>To start, consider using gofmt before each commit or whenever you remember to run, then try revive. Which linters are you using?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/100/0*Er1jxcope1fcV24D" /></figure><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/state-of-golang-linters-and-the-differences-between-them"><em>https://sourcelevel.io</em></a><em> on January 18, 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ae2c2072171" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/state-of-golang-linters-and-the-differences-between-them-sourcelevel-3ae2c2072171">State of Golang linters and the differences between them — SourceLevel</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 better Engineering Metrics uses for Managers]]></title>
            <link>https://medium.com/sourcelevel/3-better-engineering-metrics-uses-for-managers-3398afb96b56?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/3398afb96b56</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[metrics-and-analytics]]></category>
            <category><![CDATA[management-and-leadership]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <dc:creator><![CDATA[George Guimarães]]></dc:creator>
            <pubDate>Fri, 12 Mar 2021 19:06:18 GMT</pubDate>
            <atom:updated>2021-03-12T19:06:18.449Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xFeV5INdzAigF13H.jpg" /></figure><p>Many managers use engineering metrics to set goals. They measure the product delivery process and then use these numbers to set <a href="https://sourcelevel.io/blog/okrs-vs-kpis-explanation-with-examples-for-engineering-teams">OKRs</a>, attach to a pay raise or promotion, or micromanage. All the ways lead to pressure for achieving a specific number.</p><p>I’ve worked in teams in which managers would make leaderboards and control every individual’s output. It didn’t solve the problem, though. Micromanaging only increases illusory productivity, not the performance itself.</p><p>At the cultural level, it changes how the team dynamic works. Individualism increases and the team starts to make bad engineering decisions. The focus becomes to be at the top of the leaderboard, not delivering an excellent product.</p><p><strong>There are other ways to use metrics</strong>. They serve multiple purposes, and managers can use them on different occasions. In this article, I listed three better ways to use metrics within engineering teams.</p><h3>Metrics to motivate the team</h3><p>Nobody likes to have their work wasted because of misalignments. Engineers want to work on what’s important and relevant. Add challenges to the equation, and engineers will have fun doing their jobs.</p><p>In this sense, managers need to communicate what’s most important clearly. If the team understands the plan, it is easier for them to see how they fit.</p><p>Some kinds of work are fast, and the team stays motivated from the beginning to the end. However, when an activity takes too much time, the team may lack the feeling of achievement. When it happens, morale and motivation tend to drop. Managers can avoid it by establishing smaller, tangible, and measurable milestones in the long run.</p><p>If a team has 30 technical debts that need to be addressed, managers can break it into a doable plan. It can be fixing one technical debt by a week or fixing ten up to the end of the quarter. The tactics don’t matter.</p><p><strong>The crucial thing here is to enable the team to sense progress</strong>. Every week the leader can discuss the progress. In this case, metrics are not micromanaging anyone. They’re an indicator of progress. If the improvement is not satisfactory, that’s the right moment to change the plans, not blame.</p><p>Regularly looking to a metric towards a plan brings a sense of progress and a frequent feeling of achievement. That’s great. Besides, don’t hesitate to celebrate small and big wins. Both are essential.</p><h3>Metrics as indicators</h3><p>Metrics don’t tell the story; the context does. Metrics are merely a quantitative view of the facts. That’s important to have in mind when measuring, especially for those metrics that managers take as productivity.</p><p>The usage of indexes differs from traditional goals. Goals are future-centric and represent where the team should be from now. Indexes, on the other hand, show the present, like an indicator.</p><p>Therefore, <strong>a better approach is using Engineering Metrics as indicators</strong>. The hardest part is to find the appropriate set of metrics to compose the index.</p><p>For example, the <a href="https://sourcelevel.io/blog/3-benefits-of-devops-metrics-within-engineering-teams">Lead Time for Change</a>, which measures from commit to deployment, is an excellent index of how fast the team works. It includes many outputs — commits, pull requests, deployments — and practices — coding, testing, DevOps, Product.</p><p>When it comes to quality, the problem can be more complicated. As quality is subjective, engineering managers may diverge.</p><p>Choosing the correct set of metrics depends on many aspects, such as team maturity, the company’s strategic goals, and product positioning. It could be the number of bugs found in production or the meantime to a system to recover from failure.</p><p>There are many metrics that we could use. Collaboration, culture, quality are all abstract terms that need a measurement. Once it’s covered, tracking indexes’ evolution over time can point to real-life changes.</p><p>I recommend starting with what seems obvious, then polish it as you learn.</p><h3>Experimentation and innovation</h3><p>In the last years, lots of frameworks, practices, and tools came out. Some of them changed the way we develop software — <a href="https://www.atlassian.com/agile/agile-at-scale/spotify">Spotify Model</a>, to cite a famous one. They usually come from big companies that have a culture of experimenting.</p><p>Not every experiment needs to be that big and successful, though. Small improvements in the system are enough for our daily activities. But how can we tell whether an experiment has worked or not? Yes, metrics.</p><p>If managers measure outcomes instead of outputs, <strong>metrics become a powerful tool for empowering engineering teams with autonomy and responsibility</strong>.</p><p>The teams themselves can look at the metrics as indicators and tell whether their initiatives are working or not. They can try new practices, change the process, and dive into innovation. The only restriction would be not changing metrics for the bad.</p><p>Growth Marketers use this dynamic in daily operations. And I believe engineering teams should benefit from it as well.</p><p>The secret of enabling innovation is an instrumented system and strategic experimentation. There must be a rationale behind each initiative. And metrics will tell how successful they are.</p><p>To make it useful, it requires a fast feedback loop. It would be costly if every experiment had to run for months to determine its success. Early feedback — looking at how metrics behave — enables changing directions when things are not going well.</p><h3>In short</h3><p>Metrics shouldn’t be villains. They are a vital tool for modern software development. There is no space for micromanaging anymore because it just doesn’t work.</p><p>I listed in this article three better uses for metrics than comparing individuals against their peers.</p><p>In summary, we should look for metrics as indicators. They can motivate the team, tell how the system responds to daily activities, and enable innovation through experimentation.</p><p>SourceLevel provides a set of metrics that managers can use as indicators. If you’re unsure about what to measure, <a href="https://sourcelevel.io/software-engineering-kpi-consultation">apply for a Free Strategy Session</a> with me. If you’re wondering how to implement pragmatic metrics in your team, <a href="https://sourcelevel.io/schedule-your-demo">Schedule a Demo</a>, and I will be happy to show.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/100/0*TvxgpyMR7J56aRDT" /></figure><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/3-better-engineering-metrics-uses-for-managers"><em>https://sourcelevel.io</em></a><em> on March 12, 2021.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3398afb96b56" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/3-better-engineering-metrics-uses-for-managers-3398afb96b56">3 better Engineering Metrics uses for Managers</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Three signs your team needs Engineering Metrics ASAP]]></title>
            <link>https://medium.com/sourcelevel/three-signs-your-team-needs-engineering-metrics-asap-387270db00cc?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/387270db00cc</guid>
            <category><![CDATA[management-and-leadership]]></category>
            <category><![CDATA[metrics-and-analytics]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <dc:creator><![CDATA[George Guimarães]]></dc:creator>
            <pubDate>Thu, 28 Jan 2021 17:42:03 GMT</pubDate>
            <atom:updated>2021-01-28T20:54:51.628Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*LQDeDm6ITiL7kJtZ.jpg" /></figure><p>I’ve been using <a href="https://sourcelevel.io/engineering-metrics">Engineering Metrics</a> for a while, and I am amazed by the significant impacts on engineering teams. Metrics is a topic I genuinely care about. During my days at Plataformatec, we used to discuss a lot about them. At the time, we used to focus on an Agile perspective.</p><p>Our team was not satisfied in measuring Velocity in Story Points, nor we thought that estimating was helpful. So, we dug into Kanban philosophy and learned new statics techniques.</p><p>We found out that measuring the cards’ flow through the board was more accurate and useful and that forecasting using Monte Carlo could give us more realistic estimations.</p><p>Despite having many customers, we discovered that most of them had similar problems: lack of visibility and alignment. Once we introduced our metrics, the product teams had a north star.</p><p>Besides, we also noticed that many CTOs had no metric to show to the board. The CMO could prove they were bringing qualified leads, the CFO had data to show their team reduced costs, but CTOs usually had no concrete metrics.</p><p>Well, in summary, that’s the story behind SourceLevel. Over time, we received lots of valuable feedback, and we’re confident our product is in the right direction. We are helping companies to accelerate their deliveries sustainably and effectively.</p><p>For this article, I separated three signs that you need Engineering Metrics in your teams. Check if you identify with any.</p><h3>#1 — You don’t know in which step of the product delivery bottleneck is.</h3><p>For a commit to reach production, the code goes through a lot of steps. Many of them rely on human activities, like coding and peer-reviewing. The nature of this kind of work varies in quantity, time spent, and many other intrinsic variables.</p><p>When you analyze the big picture, engineers in all levels of experience collaborate to solve a diverse type of demand, from bugs to refactorings, from typos to new releases, and so on.</p><p>Systems are more complex than the sum of the parts. That’s why measuring individuals make no sense. The outputs produced vary too much in sizes, shapes, and purposes.</p><p>Besides, overseeing everything is very difficult. It increases significantly when the team scales up. So, you need to instrument each step by gathering data from commits, pull requests, and deploys — as a start -, so that you can inspect them to find improvement opportunities.</p><p>If you think there’s no bottleneck in your process or don’t know where it is, I strongly recommend instrumenting your system with Engineering Metrics.</p><h3>#2 — You don’t have any metric to report upwards.</h3><p>Every area has its standard metrics. You work for many companies, but the CMO or CFO, for instance, will always report pretty much the same metrics. However, the engineering area still doesn’t have a consolidated metric to report upwards.</p><p>I’ve seen many CTO fail because they couldn’t prove the team was making progress or that demand was over the capacity. Many executives still rely on gut feelings and outdated estimating methods.</p><p>By measuring the whole process and then being able to drill down on specific parts of the system, CTOs and managers can understand their initiatives’ impact and create better reports.</p><h3>#3 — You don’t know whether the team is making progress towards desired outcomes.</h3><p>When you focus on outputs, the results usually don’t go along with the outcomes. If the team’s productivity is measured by how many Pull Requests get merged, smart engineers will close as many Pull Requests as possible. It doesn’t matter whether the team reviewed it properly.</p><p>The organizational culture is abstract and changes frequently. Metrics are a crucial factor. Measuring the outputs, as the number of Merged Pull Requests, isn’t enough. Leaders need to measure the outcomes.</p><p>The engineering outcome is not only “code in production.” As a delivery system, we want engineering to deliver clean, well-tested, and reliable code to production faster in a sustainable — and predictable — way.</p><p>When the leaders spread this message across all teams and give the team autonomy to do whatever change they need, we have the benefits of measuring outcomes: teams are not attached to outputs to experiment and innovate. The chosen set of metrics provides the alignment.</p><p>For example, a way to deliver faster would be moving from a Pull Request approach to a trunk-based one. It can accelerate deliveries, but on the other hand, would the code still be well-tested and reliable? If the team is not mature enough, there are great chances it would not.</p><p>That said, after defining the outcomes for your engineering success, I strongly recommend looking for a set of metrics that reflects the results.</p><h3>Do you want to know more about Engineering Metrics?</h3><p>If you want to read more about Engineering Metrics, I’ve written a lot about them recently. You can find them under this <a href="https://sourcelevel.io/blog/category/metrics">category</a>.</p><p>Feel free to <a href="https://calendly.com/georgeguimaraes/call-15m">schedule a 15-min chat</a> with me to talk about the challenges at your company. Maybe, I can handle more resources for you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/100/0*fYTIWkMifRrrBhfK" /></figure><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/three-signs-your-team-needs-engineering-metrics-asap"><em>https://sourcelevel.io</em></a><em> on January 28, 2021.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=387270db00cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/three-signs-your-team-needs-engineering-metrics-asap-387270db00cc">Three signs your team needs Engineering Metrics ASAP</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Benefits of DevOps Metrics within Engineering Teams]]></title>
            <link>https://medium.com/sourcelevel/3-benefits-of-devops-metrics-within-engineering-teams-87a0f52185b9?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/87a0f52185b9</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[George Guimarães]]></dc:creator>
            <pubDate>Thu, 14 Jan 2021 18:42:09 GMT</pubDate>
            <atom:updated>2021-01-14T18:42:09.631Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PltEWGy8bMu4Zgne.jpg" /></figure><p>DevOps metrics is a trending topic among software engineering managers. These metrics became very popular after the publication of <a href="https://itrevolution.com/book/accelerate/">Accelerate — The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations</a> and the yearly The State of DevOps reports.</p><p>If you’re not familiar, here’s are the 4 DevOps Metrics proposed by the work:</p><ul><li>Delivery Lead Time, which is also known by Lead Time for Change or Cycle Time</li><li>Deployment Frequency, also known as Delivery Throughput</li><li>Time to Restore Service</li><li>Change Fail Rate</li></ul><p>If you search for “DevOps metrics,” you’ll quickly find many articles listing much more than four of them. Although I wouldn’t say they’re wrong, that’s something we need to pay attention to. Overseeing too many metrics — or DevOps KPIs, to cite a common term — at once can bring more problems than solutions.</p><p>For this article, I prepared a brief list with three benefits of using those metrics so that you can accelerate engineering deliveries at your place.</p><h3>Benefit #1 — They consider only the engineering scope.</h3><p>In the article <a href="https://leaddev.com/scaling-software-systems/primer-engineering-delivery-metrics">A primer on engineering delivery metrics — Scaling software &amp; systems</a>, Buritica states that the product conception and design phase varies too much and then defends measuring what the engineering team is responsible for: from commit to deploy.</p><p>It makes sense. The <strong>product design phase</strong> defines what should be built, and considering it as engineering work distorts its efficiency. On the other hand, focusing on the <strong>product delivery phase</strong> allows managers to understand precisely how shipping code to production works.</p><p>In short, DevOps metrics show the big picture of your whole engineering process.</p><h3>Benefit #2 — It promotes collaboration and alignment.</h3><p>I don’t believe in developer or engineer productivity. Metrics such as the number of Lines of Code added, commits, and user story points delivered usually bring anxiety, depression, and burnout — to cite a few of them mentioned in Isaac Lyman’s article <a href="https://stackoverflow.blog/2020/12/07/measuring-developer-productivity/">Can developer productivity be measured?</a></p><p>Modern Software Development requires collaboration. More than that, it relies on teamwork. It’s like a complex system that needs a hint of chaos to work appropriately. Because of that, it’s useless to measure individual productivity. If you measure each individual by inputs or outputs, the system will adapt to it, and then you’ll see a local improvement.</p><p>However, what about the other vital aspects of engineering success, such as quality, stability, and maintainability? The team probably won’t take them into account during the daily activities because what matters at the end of the day is to reach a certain number of inputs or outputs done.</p><p>In my opinion, this is a management anti-pattern. If we want engineering teams to collaborate, then we need to see how they work together. Every institutionalized practice, process, or automation changes how the system behaves altogether.</p><p>That’s why you need metrics that fully represent the big picture to understand if they have improved or worsened the team’s dynamic. As a result, teams work with high autonomy guided by the alignment provided by metrics that tell what’s expected from them.</p><h3>Benefit #3 — Improving the system is more effective.</h3><p>If you compare two individuals, given they’re humans, it very likely they won’t perform the same. Depending on the type of demand — whether it’s a bug, a new feature, or PoC -, their motivation, how clear the task, the related experiences they had, and many other aspects can cause divergences in the numbers.</p><p>In a Leaderboard, there will always have someone at the bottom. Even if you start a mentorship program to leverage individual productivity, it doesn’t mean all engineers will produce the same.</p><p>However, you can find whether a mentorship program is working by looking at the system. If the system is delivering more, with quality and reliability, it’s working. It doesn’t matter who is at the bottom or the top of the Leaderboard.</p><p>Daniel Markovitz wrote in an article for the Harvard Business Review called <a href="https://hbr.org/amp/2021/01/productivity-is-about-your-systems-not-your-people">Productivity Is About Your Systems, Not Your People</a>:</p><blockquote><em>As legendary statistician and management consultant W. Edwards Deming argued in his book Out of the Crisis, 94% of most problems and possibilities for improvement belong to the system, not the individual. I would argue that most productivity improvements belong there as well. Personal solutions can be useful, but the most effective antidote to low productivity and inefficiency must be implemented at the system level, not the individual level.</em></blockquote><p>Understanding the impact of engineering initiatives, projects, and daily activities on the system outcomes makes it much more likely to managers drive their teams to high-performance.</p><h3>You’ll probably need more metrics later.</h3><p>DevOps metrics are enough for having the big picture. But sometimes, we need to zoom in and see how the system behaves in a specific part of the process. In this case, you’ll need more metrics.</p><p>You may have a better idea of what I’m talking about reading Smruti Patel’s article <a href="https://leaddev.com/productivity-eng-velocity/debugging-engineering-velocity-and-leading-high-performing-teams">Debugging engineering velocity and leading high-performing teams — Productivity &amp; Eng velocity</a>. Breaking the process into smaller steps is fundamental to understand where bottlenecks and issues are. Then, managers can complement their view by instrumenting those steps.</p><p>These complementary metrics give managers visibility and allow the teams to detach from inputs and outputs. So, they can elaborate on sophisticated solutions that impact the whole system.</p><p>However, the team should align every action with those 4 DevOps Metrics.</p><h3>In short</h3><p>The 4 DevOps Metrics are excellent to give managers a big view. However, to debug the process, they need to instrument the system using other metrics. It’s like Observability, but for the process.</p><p>For more ideas of how and what to measure, I strongly recommend our latest e-book, <a href="https://sourcelevel.io/engineering-manager-playbook-high-performance-teams">The Engineering Manager’s Play for debuggable and observable processes</a>. It has quality content with examples of what to measure in each delivery phase.</p><p><strong>See Engineering Metrics Live:</strong> <a href="https://sourcelevel.io/engineering-metrics">Click here</a> to get a <strong>full demo</strong> of SourceLevel Engineering Metrics and how they can help your team.</p><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/3-benefits-of-devops-metrics-within-engineering-teams"><em>https://sourcelevel.io</em></a><em> on January 14, 2021.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87a0f52185b9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/3-benefits-of-devops-metrics-within-engineering-teams-87a0f52185b9">3 Benefits of DevOps Metrics within Engineering Teams</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Explore SourceLevel 2020’s highlights and what to expect from 2021]]></title>
            <link>https://medium.com/sourcelevel/explore-sourcelevel-2020s-highlights-and-what-to-expect-from-2021-2e6e8268d2fa?source=rss----ebf39c586b0e---4</link>
            <guid isPermaLink="false">https://medium.com/p/2e6e8268d2fa</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[2020]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[year-in-review]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[George Guimarães]]></dc:creator>
            <pubDate>Fri, 18 Dec 2020 14:26:23 GMT</pubDate>
            <atom:updated>2020-12-18T14:26:23.296Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZXLaQdRYHOmq7tGc.jpg" /></figure><p>Despite this challenging year, we’ve managed to polish our product and help our customers accelerate their deliveries. Better than that, we had lots of feedback telling us we’re on the right path. I am so proud of what the SourceLevel team has achieved to share some of 2020’s highlights.</p><h3>Pull Request Metrics and Team’s Analytics</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eEQWPUoH2h5gL71A.jpg" /></figure><p>Could you imagine that last year we were only an automated code review tool? In January, we announced the <a href="https://sourcelevel.io/blog/metrics-for-software-engineering-teams-have-landed-to-our-product">Metrics for Engineering Teams</a> and <a href="https://sourcelevel.io/blog/filter-sourcelevel-metrics-by-team">filters for teams</a>. Over the year, our charts changed a bit.</p><p>You can currently find three main categories of charts, following the idea of <strong>adding your processes&#39; observability</strong>. With SourceLevel, you can oversee the Work In Progress, team’s engagement, and deliveries across all organization’s repositories.</p><p>All the data can be filtered by teams so that managers can find who needs help fast and more straightforward. Learn more about them on our <a href="https://sourcelevel.io/engineering-metrics">Engineering Metrics</a> page.</p><h3>GitLab full integration — Self-Managed in Beta!</h3><p>During the year, we delivered a full integration with <a href="http://GitLab.com">GitLab.com</a>. Both tools, Automated Code Review and Engineering Metrics, integrate smoothly now. <a href="https://app.sourcelevel.io/sign_up">Sign up</a> with your GitLab account and create an organization to start using our product!</p><p>We’re extending our support for GitLab Self-Managed instances too. It’s in Beta. If you’re interested, get in touch!</p><h3>Product Hunt Launch</h3><p>In October, I wrote a blog post announcing that we <a href="https://sourcelevel.io/blog/on-product-hunt-launch-and-a-sneak-peek-into-our-roadmap">launched SourceLevel in ProductHunt</a>. We’ve already got many upvotes, and I am happy with the feedback. In the same article, I gave a sneak peek of what’s yet to come for 2021 regarding the roadmap.</p><p>We plan to start measuring from commit to the deployment. It means we want to cover the full Engineering workflow. It’ll turn SourceLevel into the <strong>perfect solution for providing State of DevOps’ metrics</strong>, as it will provide two out of the most crucial measurements: Deploy Frequency (Throughput) and Lead Time for Changes.</p><h3>GitHub Marketplace</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0KMEN00bS-HGvTzg.png" /></figure><p>GitHub’s approval for our tool to be part of their Marketplace was a significant milestone. We know some people prefer using it instead of setting up an account directly on SourceLevel. So we worked hard to integrate with their system entirely.</p><p>You can find more information on <a href="https://github.com/marketplace/sourcelevel">our GitHub Marketplace page</a>.</p><h3>What to expect from 2021?</h3><p>As I already said, we’ll keep polishing our product in 2021. As we’re very agile, we don’t have a robust roadmap for the whole year. However, we are very confident about these next steps:</p><ul><li><strong>Integrating with Slack</strong>. Slack is a trendy tool used by many companies. We want to share insights and vital data for our customers using this channel. We plan to ship daily and weekly reports, chart images, and many other features.</li><li><strong>State of DevOps / Accelerate Metrics</strong>. We’ve noticed that the market is going in this direction. Both Lead Time for Change and Deploy Frequency are becoming the industry standard. We want to catch up and provide a full overview of the development workflow.</li><li><strong>UX improvements</strong>. We’ll work on a better onboarding flow and add the ability to navigate through the entities, such as commit, pull requests, and deploys. It’ll help us make SourceLevel the perfect tool to trace all the steps of a given piece of code.</li></ul><p>Count on us for a more data-driven 2021 and an even more robust solution for accelerating engineering teams with quality.</p><p>Feel free to leave us a comment on what you think!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/100/0*cOKj-Kc1diSH9S_B" /></figure><p><em>Originally published at </em><a href="https://sourcelevel.io/blog/explore-sourcelevel-2020s-highlights-and-what-to-expect-from-2021"><em>https://sourcelevel.io</em></a><em> on December 18, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e6e8268d2fa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/sourcelevel/explore-sourcelevel-2020s-highlights-and-what-to-expect-from-2021-2e6e8268d2fa">Explore SourceLevel 2020’s highlights and what to expect from 2021</a> was originally published in <a href="https://medium.com/sourcelevel">SourceLevel</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>