DEV Community: Alex Circei

How is Software Development Analytics increasing Engineering Efficiency?

Alex Circei — Tue, 19 Oct 2021 09:43:22 +0000

How do you make “Agile” more, well, agile?

Simple:

You allow the data to lead the way.

Twenty-five years ago, this was not even a pipedream (except, perhaps, for prescient, rockstar developers who are always looking ahead). Twenty-five years ago, we had waterfall development, changes occurring in months and even years, and private, walled-off IP.

Today, we’re right on the precipice of a reality that’s more agile than Agile — as we move from Agile development and a DevOps culture to autonomous development.

Today, systems are event-driven, and feedback occurs in hours, even minutes. Out here, the ability to move forward is actually decided by humans (though we’ll soon release that responsibility to AI/autonomous systems). And, in this reality, code is no longer protected — rather, it’s the tool used to coordinate people and power up great products.

But the future of software development rests in a shift toward the autonomous, a context in which machines connect systems, feedback is instant, and automation goes as deep as the data does.

And the arrival path to this Promised Land is paved with first increasing engineer efficiencies with data, freeing up human engineers to focus on what they do best — the work — in a more aligned, optimized, and accurate way.

What Is Data-Driven Agile?

Simply put, data-driven Agile is a three-word way of describing the very real need engineering or DevOps teams (within a CI/CD lifecycle, powered by Agile processes like sprint planning) have to become more streamlined over time.

In short, these teams have an increasing need to measure and improve their performance with the power of real-time, objective metrics and reports. The data should (and does) come from Git repositories, and organizing this data gives teams insights into “where to cut the gravy train,” so to speak.

Unlike Waterfall’s fall (pun intended) and the eventual adoption of Agile methodology, data-driven Agile is more than just agile. In fact, it adds a layer of quality control and measurement to the processes of an Agile development team rather than entirely supplanting the approach.

And that’s how you should think about the benefits it brings.

See, if you’ve been reading the tea leaves over the developer-led landscape in the past decade, you already know that the moment of Agile’s own evolution was inevitable.

It’s not simply because Agile, as a philosophy, drives toward progressive iteration — a concept widely embraced in everything from software development to human development (think, James Clear’s 1% improvement for building habits).

It’s also not simply because the United States Senate passed a bill that essentially labels technology and software as critical components of public infrastructure.

And, it’s certainly not only because we’re doing away with what Harvard identified as the “Highest Paid People’s Opinions” — also known as HiPPOs — for decision-making and, instead, allowing data-driven decision-making to lead the way.

An example of this is Tata Health’s method of collecting data about their engineering teams’ output. By eliminating self-reporting, software engineering managers could gain granular visibility and truly objective data.

They then used this data to optimize the decision-making process and help them identify growth opportunities for their team members.

All of the above shifts are pieces of the puzzle, certainly. But, together, they still don’t entirely complete the picture.

The fact is that our move toward a data-driven approach must hit Agile and transform it because there’s a very real problem to be solved:

Now more than ever, engineering teams and the development lifecycle need insight and intelligence to support sustainable development, autonomous teams, and aligned business decisions.

For example, one of (old) Agile’s key principles was “Simplicity is essential.” That means, where possible, maximize the amount of work not done (because it didn’t have to be done). The “new,” data-driven Agile agrees with simplicity, keeps it intact, but adds a layer:

“Optimize the work in progress.”

Doing so is absolutely crucial because it allows engineering leaders to spot and eliminate places where the development lifecycle is getting bogged down.

Essentially, what has become clear as we shift into this “new,” more agile Agile is that there’s a clear line in the sand: the “old” Agile processes worked when Agile was the new kid on the block, and developer-led tools, platforms, and techniques were an exception.

But the global demand for digital services, though ever-increasing, has been here for over a decade. So we’re now in an age where there’s an increased and real need for anything that can improve the velocity of software development while reducing the risk of burnout.

And that’s where data-driven engineering leadership can transform everything from how managers communicate and offer feedback (through one-to-ones, supported by individual data and reports) to how frequently software is deployed (i.e., with a steady cadence).

How Dev Analytics Increase Engineering Efficiency

The data-driven Agile method delivers three significant whammies:

First, it generates objective reports about the software’s dev cycle, without the need for manual input from engineers.
Second, it does so by analyzing codebase, pull requests, and tickets to collect raw data and improve engineering efficiency.
And, third, this data, over time, empowers data-driven innovation, feedback, and leadership when it comes to better software deployed at a greater velocity.

Measuring Engineering Performance Where It Truly Matters

Show, not tell — that’s what data-driven engineering management empowers, and that’s what dev analytics platforms’ functionality focuses on.

So, let’s take a look at an engineering KPI measured by software development analytics platforms: Impact.

One aspect of developer or engineer productivity is to look beyond the lines of code when measuring code activity. “Impact” gives engineering management a clear way to do that. As a metric we came up with, it includes multiple data points such as:

Ratio of old code edits to total work done
Number of edit locations (Can code get more efficient?)
Number of affected files (Do we have bloat somewhere in the pipeline?)
Severity of changes to old code (Did we fail to conceive of an issue in our initial code deployment? Are user stories accurately aligned with feature requests? etc.)
Historical code changes

So, the end result of this type of data is pretty powerful because not only does it amplify the magnitude of code changes, but it also ultimately gets engineering teams to take a critical stance on their own processes when reviewing that data.

Ideally, the intelligence and insights from data-driven Agile can help engineering leadership create a new baseline for development metrics. In the short term, what it can tangibly improve is software delivery and code accuracy.

Greater Visibility Equals Better Product Quality

Being a product-first software company with product-led growth is precisely the way it should be — this is one of the most significant transformations of a developer-led landscape in the past decade and a half.

However, product-led growth is only as good as the processes that support it and the engineers who build it.

The sophistication of the developer-led software market has also increased the pace of software development. Teams need to code faster, deliver features more quickly, and constantly update or modify their code while gaining clear insight into the nature of the changes.

The result is that changes can become opaque. It’s almost impossible to, for example, check to see if all code areas have been tested. It’s highly plausible, and even likely that this lack of visibility then means risking the release of buggy, sub-optimal software.

Instead, reports like Project Timeline are essential to gaining deeper insight and visibility into the signals of notorious process blockers. With an emphasis on the following metrics, teams can gain clarity about how to evaluate performance:

*Commits volume

Average number of commits per team
Total impact of changes to the codebase

…and more.

Accelerates Overall Velocity of Production

Let’s take a look at this situation:

If you’re not only aiming toward but actually implementing an environment that is dedicated to increasing software production velocity, you’ll likely experience two specific instances:

First off, Scrum teams might combine business analysis, development, and testing. Everyone becomes responsible for delivering high-quality software. This also means everyone is accountable in the event of production issues.
Conversely, shorter development cycles, faster releases, and early bug detection also mean a loss of control and visibility. Integrated teams mean engineering management has little insight into the status of the product.

And this begs the question: can you accelerate velocity as an end goal while still maintaining transparency?

The answer is, of course, that you can — with the right tools.

The key lies in the processes, the details of data-driven decisions. Implementing a data-driven Agile approach means you’re also opening the door to a data-driven Scrum framework. On the surface, it seems as though “extra” data complexifies things like sprint planning and execution.

But, the right data about performance and productivity, coupled with real-time, objective reporting, actually helps to eliminate the ambiguities in the development process. You’ll still be able to maintain smaller iterations, conduct daily Scrum meetings, and participate in sprint reviews.

But adding data to back these up means you can eliminate some of the real issues with Scrum and Kanban. Instead, you’ll have a framework that allows teams to “follow the data” to the highest priority tasks (and effectively reprioritize tasks where necessary).

If it’s necessary, for example, to implement an iteration that lasts a day rather than three weeks (and vice versa), the data justifies that flexibility.

You need not stick to Scrum’s fixed-length sprints. Data-Driven Scrum also resolves the issue of inherently unreliable task estimation because you have real data to back up precisely how much time tasks take.

These are the granular details that significantly improve a development team’s process. This gushes up for the ultimate alignment between a production team’s outcomes and business priorities.

In other words, why we’re doing the work and how we’re doing the work are in harmony when data is around.

Conclusion

One major takeaway that should be really clear is how software development analytics starts off by increasing engineering efficiency — i.e., improvements to process — but what it really supports is a better team and peer-to-peer collaboration.

Development analytics platforms essentially pave the way for autonomous software engineering teams because there’s first a culture of autonomy. In other words, before software development can become autonomous, we need teams to be autonomous. And teams can do that when they have reliable, specific data to back up their decisions and actions.

When you’re ready to translate data into greater visibility, and this visibility into faster, more efficient teams, you can start looking at development analytics platforms like Waydev.

Remote Work for Engineering Managers

Alex Circei — Fri, 27 Mar 2020 23:14:24 +0000

It’s been two weeks since we took action and made working from home mandatory for all the team members. Our top priority remains the health and safety of our team members. We have a responsibility to support our communities through the health crisis caused by COVID-19.

Moving to a 100% work-from-home policy in such a short time frame is not easy, but there are companies that thrive in a remote environment. The best example is GitLab. GitLab is the world’s largest all-remote workforce, with over 1,200 employees spread across 67 countries. We are one of the few GitLab partners in the Performance Measurements field.

GitLab has been able to grow continuously because they have a process put in place. One of the key elements of focusing on the process is measuring the process. Git Analytics tools, such as Waydev or Gitprime (Pluralsight Flow) help engineering leaders manage remote teams effectively by providing actionable metrics and features that translate into visibility, velocity, and productivity enhancement.

Waydev’s & Gitprime's features help engineering leaders to run nondisruptive daily stand-ups, effective one-on-ones and enable a healthy code review workflow.

For Daily stand-ups, the Work Log provides a high-level view of your engineering team’s activity, such as commits and pull requests, so both engineering managers and engineers don’t need to waste time on questioning and reporting.

For One-on-ones, the Developer Summary offers a low-level view of the activity of each engineer, so engineering managers can see what are their engineers working on, spot and eliminate any blocker that might be holding down their team.

For Project Health Checking, the Project Timeline helps engineering leaders to see how work focus and volume shift over time. You can see whether your engineers focus on creating new code, refactoring old code or on helping others. You are able to view and correlate how events impacted your team’s velocity and performance, and direct your data-driven decisions.

We divide our metrics into:

The code-level metrics provide engineering leaders with insights regarding their engineers’ efficiency and productivity.

Impact is a way to measure the amplitude of code changes that happen, in a more complex manner than measuring raw lines of code. The algorithm behind the Impact is similar to Google’s Page Ranking algorithm. It comprises multiple data points that translate engineers’ output into both business value and cognitive load.

Churn represents the percentage of code that has been rewritten or deleted shortly after being written. Of course, nothing works perfectly from the first try, but if this percentage experiences spikes, you might want to analyze that. It might have only been a change in specifications, but it could also mean that an engineer got the requirements wrong, or that a manager wasn’t clear enough. This can help you diagnose issues early and fix them in a timely manner.

Technical Debt represents the amount of refactoring code done by an engineer. Usually, the process of paying down technical debt is a less shiny process than releasing new features, but it is more complex and it carries a higher cognitive load. Paying down technical debt might enable engineering teams to release a new feature or fix a long-running flaw that had the potential to affect the whole project.

Code collaboration metrics provide an understanding of the code review process. They quantify the effectiveness of the engineers’ collaborative work and knowledge sharing.

Review coverage calculates the percentage of pull requests that had been reviewed before being merged. This metric helps you gain a better understanding of your team’s code review process and aids you in spotting unhealthy code review patterns. A low review coverage translates into a higher chance of putting buggy code into production, whereas a high review coverage decreases the chances of buggy code to be put into production.

Time to Resolve measures the velocity of the code review activity. It represents the average time it takes to close a pull request.

Sharing Index measures how broadly information is being shared amongst a team.

We know Waydev and Gitprime is particularly useful for tracking your engineers’ output when they are working remotely, and after seeing increased usage in the regions hit hardest by the virus, we’re taking immediate action to ensure our product is accessible to as many people as possible.

Photo source: https://circleci.com/blog/how-to-successfully-work-from-home-strategies-for-remote-work/

Meet Waydev’s new tool for engineering managers

Alex Circei — Mon, 03 Feb 2020 23:56:26 +0000

According to a report published in 2018 by Stripe, the majority of 1,000 + developers, technical leaders, and C-level executives polled felt that access to developers is more important than access to capital. However, the issue might not be about how many developers you have available but about how they use their time and skills. With 17 million developers active in 2018, their study points to approximately $ 300 billion Global GDP loss from developer inefficiency annually.

When looking to increase developer productivity for your team, a logical step for an engineering manager would be first to have some insight into what the team is spending their time on.

Code management is now in the cloud on GitHub, GitLab, Azure DevOps, or Bitbucket, and it has become possible to track the engineering team output. Unfortunately, most of the technology companies still look at reports created with manual input from the engineers. Nevertheless, if an engineer didn’t log the work in the report, it’s inefficient and often not accurate.

That’s where Waydev comes in.

Waydev is the newest agile data-driven way to truly understand your engineers. It automatically analyzes your codebase and generates reports with no input needed from engineers.

“Our product makes life easier for engineering managers by providing them with comprehensive data on how the team is doing, helping to identify potential issues before they become actual problems, to redirect resources, etc. Waydev is now trusted by 300+ companies and has had excellent feedback so far. We’re growing +40% month over month in terms of revenue, and we also have a retention rate of over 40% in eight-week timeframes. We plan on expanding our team in 2020 and refine both the product and our offer even further,” said Alex Circei, Waydev’s co-founder.

Waydev closes that gap by providing reliable metrics for engineering leaders, reinventing the way engineers’ output is tracked to help engineering managers make objective decisions. The team looked at how teams work and created features for each use-case. The product provides complete visibility over teams’ output, so engineers don’t have to worry about their daily stand-ups. Engineering managers can now zoom in on any commit or pull request to see where the work focus went, eliminate blockers, and use data to increase engineer effectiveness.

“Our product’s focus is evenly distributed across the code-level metrics and the code review process. We came up with a way to quantify the code review process into actionable metrics that can enhance a manager’s visibility over his team collaborative activity. These insights can be used to spot a blocked pull request, incentivize engineers to collaborate more or adjust the workload. Our code-level metrics are directly related to engineering productivity, while the code review process is quantified in collaborative metrics,” Alex added.

Waydev stats can be used in:

One-on-ones

“Developer Summary” helps spot the right time for one-on-one and get valuable insights that can effectively guide you through one-on-ones.

Code Review Workflow

The time it takes to close a pull request relates to the time in which an engineer could’ve created excellent output. Even worse, a pull request that is merged without review could raise critical issues. “Review Workflow” offers a bird’s eye view over pull request activity. Managers can zoom in on any pull request to see comments, commit data, work focus, and more valuable information.

Monthly Reports

“Retrospective” evaluates release success and compare sprints. Managers can assess both team focus and volume and see how different events impacted the overall team performance with “Project Timeline.” Automatically generated weekly and monthly reports will keep you up to date.

Benchmarking

Waydev provides accurate data so that managers can focus on making the right decisions. The “Dashboard” feature offers a comprehensive view of any team and engineer stats while “Compare” helps benchmark team and engineer performance.

The product helps engineering managers answer questions like:

By providing visibility on individual and team contributions, Waydev helps managers identify where the most significant impact is being made, see how process changes impact team effectiveness, and spot opportunities to give relevant, data-based, and constructive feedback.

Waydev is now enterprise-ready, offering an on-prem solution and features like role and stats management as well as API & SSO integrations.

Also, you can go to Waydev’s website for a more in-depth analysis of what Waydev can offer and how it differs from other similar products like Gitprime or Code Climate.

The future of development analytics

Alex Circei — Wed, 09 Oct 2019 10:38:56 +0000

Waterfall vs Agile vs Data-driven: how the engineering leaders will track their teams1990+

Waterfall Method

What is the waterfall project management methodology?
Waterfall project management is a sequential, linear process of project management. It consists of several discrete phases. No phase begins until the prior phase is complete, and each phase’s completion is terminal — waterfall management does not allow you to return to a previous phase. The only way to revisit a phase is to start over at phase one.

Waterfall process model is probably the most popular methodology of software development. Teams and company’s all over the world use it to manage their projects. However, there are still programmers who want to know more about its features.Waterfall is often called the traditional methodology of software development. It originated in the 1950s. The methodology was initially used in hardware development, but after the invention of software development, it was applied to this industry.

Today Waterfall remains one of the most popular process models. It is strongly criticized by some programmers that prefer to use Agile methods. However, most software development companies still use Waterfall because it is well known.

As you can imagine, proper planning is a must in the waterfall system. A project’s requirements must be clear up front, and everyone involved in a project must be well aware of those requirements. Each team member should also understand what their role will be in the project and what that role entails.

Phases of waterfall project management The specific phases of the system vary somewhat from source to source, but they generally include:

Requirement gathering and documentationIn this stage, you should gather comprehensive information about what this project requires. You can gather this information in a variety of ways, from interviews to questionnaires to interactive brainstorming. By the end of this phase, the project requirements should be clear, and you should have a requirements document that has been distributed to your team.
DesignUsing the established requirements, your team designs the system. No coding takes place during this phase, but the team establishes specs such as programming language or hardware requirements.
ImplementationCoding takes place in this phase. Programmers take information from the previous stage and create a functional product. They typically implement code in small pieces, which are integrated at the end of this phase or the beginning of the next.
TestingOnce all coding is done, testing of the product can begin. Testers methodically find and report any problems. If serious issues arise, your project may need to return to phase one for reevaluation. In this phase, the product is complete, and your team submits the deliverables to be deployed or released.
MaintenanceThe product has been delivered to the client and is being used. As issues arise, your team may need to create patches and updates may to address them. Again, big issues may necessitate a return to phase one.Waterfall model is based on three main principles: low customer involvement, strong documentation, and sequential structure. Let’s look at them in greater detail.

The Pros

• Project progress is easily measurable as all involved understand the schedule and key deliverables in advance of the project’s start.

• Alignment between clients and project developers occurs at the earliest stages of the development cycle. As such, clients can take a more hands-off approach as the project progresses by taking part in reviews and status updates without having to continually collaborate with developers.
• The methodology allows for some flexibility. For example, testers can prepare relevant scripts while development is underway using the documentation created in earlier stages.
• As the design is generally a separate stage, Waterfall allows for the intricacies of complex projects to be properly planned out prior to the beginning of development.
• The risk of having to spend time tinkering with pieces of code to add it into the large project application is reduced as all stakeholders in the project are fully aware of the project’s demands and the technologies used in its creation from the offset.

The Cons

• Waterfall, by its nature, requires project planners to gather specific details and documentation from the off, which can prove intimidating to clients who have little experience in software development. As such, the methodology raises challenges in terms of helping clients understand what they are actually getting and how the information provided helps the project reach its goals.
• Changes in project requirements are often difficult to implement, particularly once development is underway, as the entire project is carefully planned based on the documentation and requirements gathered in the early phases.
• As testing tends to occur as a single stage at the end of the development lifecycle, early bugs go undetected, potentially affecting later code to the point where they create large problems.
• Projects can end up being delayed if a particular stage is not completed within the expected timeframe, which prevents the next stage from proceeding.
• Developers can often not go back to the previous stage if an issue is discovered when using the Waterfall methodology. In some cases, a single problem can cause the entire project to go back to the first stage.2000+ Agile Method

What is the agile project management methodology?

Agile software development is an approach to software development under which requirements and solutions evolve through the collaborative effort of self-organizing and cross-functional teams and their customer(s)/end user(s). It advocates adaptive planning, evolutionary development, early delivery, and continual improvement, and it encourages rapid and flexible response to change.The term agile (sometimes written Agile) was popularized, in this context, by the Manifesto for Agile Software Development.

The values and principles espoused in this manifesto were derived from and underpin a broad range of software development frameworks, including Scrum and Kanban.

There is significant anecdotal evidence that adopting agile practices and values improves the agility of software professionals, teams and organizations; however, some empirical studies have found no scientific evidence.Agile project management method is an iterative, team-based approach to development.

This approach emphasises the rapid delivery of an application in complete functional components. Rather than creating tasks and schedules, all time is “time-boxed” into phases called “sprints.” Each sprint has a defined duration (usually in weeks) with a running list of deliverables, planned at the start of the sprint. Deliverables are prioritised by business value as determined by the customer.

If all planned work for the sprint cannot be completed, work is reprioritised and the information is used for future sprint planning.As work is completed, it can be reviewed and evaluated by the project team and customer, through daily builds and end-of-sprint demos. Agile relies on a very high level of customer involvement throughout the project, but especially during these reviews.

Principles behind the Agile Manifesto

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
Business people and developers must work together daily throughout the project.
Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
The most efficient and effective method of conveying information to and within a development team is a face-to-face conversation.
Working software is the primary measure of progress.
Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Continuous attention to technical excellence and good design enhances agility.
Simplicity — the art of maximising the amount of work not done — is essential.
The best architectures, requirements, and designs emerge from self-organizing teams.
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.Let’s look at them in greater detail.

The Pros• Clients are engaged throughout the entire development lifecycle, offering a greater understanding of the work being delivered and allowing for faster decision-making where required. Further, this engagement allows clients to take greater ownership of the project, thus making them more invested in its success.

• The flexibility of Agile allows for changes in project requirements to be implemented more effectively, thus preventing these changes from holding up other aspects of the development cycle.

• The iterative nature of Agile allows developers to create more basic versions of software that can be enhanced through later development work, thus allowing clients to begin marketing software earlier and provide it quicker, with later developments enhancing the product for the early user base while making it more attractive to latecomers over time.
• The increased collaboration at the heart of Agile fosters transparency on the parts of both client and developer.
• Testing is usually implemented into each Agile sprint, meaning bugs are spotted earlier and thus don’t cause problems later on.The Cons• Not all clients wish to engage in development processes as frequently as Agile requires, which can lead to frustration on the client’s part, resulting in dwindling interest as the project progresses.
• Agile methodologies can sometimes be more difficult to explain that the Waterfall model, particularly when it comes to the concept of sprints and how the various traditional stages of development intermingle when using Agile.
• Costs can spiral if certain requirements are not completed within their assigned sprints, with too many missed requirements leading to new sprints being created that delay the project. Further, increased client involvement can have the downside of creating constant changes that lead to higher costs.
• Poor project management and anything less than a full commitment from all stakeholders can scupper Agile development, as disengagement leads to delays. For example, many projects employing Agile find they run into difficulty if the various teams involved in the project are not located within close proximity to one another, thus making the communication that lies at the core of the methodology more difficult.
• The focus on creating working software quickly can lead to poor documentation of what the end user actually needs to know to use it.2020+ Data-driven Method

What is the data-driven project management methodology?

Software is eating the world, but we are not data-driven in understanding software development.

Data-driven method gains popularity in the last years with the help of Git popularity, when Github, Bitbucket and Gitlab convinced millions of engineers to store code in the could and open the opportunity for companies like Waydev, Gitprime, Codeclimate to track the output of the engineers and help managers make decisions based on real data and not by their gut.The actual way, and how most of the engineering managers track their teams is by the Agile method or Waterfall method but the data-driven method doesn’t replace any of these methods and comes as an add-on with a real-time view of the actual work.Either if you use an Agile method or a Waterfall method it will be impossible to see how the work is performing until the end of the sprint, at least one week, with a data-driven method you can see how the team is performing, day-by-day and come prepared in your daily sprints with concrete feedback on the actual work of the team.Below it is an example from Waydev, is their Work-log feature where you can see the output of each engineer, in real-time.

At the core of these features they use core metrics like new work, churn, legacy refactor, helping others and impact. All the players in this market have different features of tracking the output, but all of them are focusing on the most important aspects of having a successful team. The most common features are for daily-standups, one-to-one meetings, history of the work and benchmarking your starts with the industry. I don’t see how an engineering manager will not start using valuable data in his decisions, My suggestion is to try any of the products, either is Waydev, Gitprime or Codeclimate and choose to use one who fits better for your needs, like this you will see how much the productivity will grow.

(Article originally published at https://waydev.co/)