Beyond story points and ticket status
Engineering Metrics
Oct 12, 2023
In the dynamic realm of software engineering, metrics have always been the compass guiding teams towards success. They offer a tangible measure of progress, efficiency, and areas that require attention. However, as the industry evolves, there's a growing realization that traditional project management tools, which often revolve around story points and ticket statuses, might not be the best indicators of genuine progress. Let's explore this further.
The Limitations of Traditional Tools
Project management tools are fundamentally plan-first tools. They're designed to map out a project's trajectory, breaking it down into manageable chunks, often represented by story points or tickets.
The Disconnect: These tools, while invaluable, often don't align seamlessly with the real-world progress of an engineering team. The true essence of any software project lies in its code, pull requests metrics, and the engineering process. A disconnect between these can lead to inefficiencies and misaligned expectations among stakeholders and team members.
Code: The Heartbeat of Progress
While story points provide a high-level overview, the granular details are embedded in the code.
Pull Requests Metrics: These are pivotal to any software project. They offer insights into code review processes, cycle time, and the overall performance of the development teams. By focusing on these metrics, engineering leaders can ensure optimization and continuous improvement in the workflow.
The Ambiguity of Ticket Status
Solely relying on ticket status can be misleading.
Lack of Context: A ticket marked as 'done' doesn't necessarily mean the associated engineering tasks are complete. It might address multiple business tasks or new features, making it a poor indicator of actual progress.
The Need for Good Hygiene: Without regular updates and accurate data input, metrics derived from ticket statuses can become meaningless. It's crucial for team members to maintain good hygiene when updating ticket statuses and ensuring that engineering metrics reflect the true state of the project.
Bridging the Gap
Project management tools represent only one side of the coin. They contain business tasks that need completion. However, they don't always map cleanly to the engineering tasks that address the broader engineering projects.
Engineering Metrics: These delve deeper, focusing on lines of code, benchmarks, and the intricacies of the engineering process. They provide a more comprehensive view, ensuring that the engineering organization is aligned with business goals and stakeholders' expectations.
Streamlining the Process
To truly optimize an engineering team's workflow, it's essential to bridge the gap between project management tools and actual code metrics.
Dashboards: These are invaluable. By consolidating data from both realms, dashboards provide a holistic view, aiding in decision-making and continuous improvement.
Automation and DevOps: In today's age, automation plays a pivotal role in streamlining processes, reducing downtime, and ensuring projects are delivered on time within the set timeframe. The rise of DevOps further emphasizes the need for a seamless integration between development and operations, focusing on metrics that matter.
Conclusion
While project management tools offer a structured approach to software development, integrating them with real-time code metrics is crucial for a holistic view of progress. Tools like BuildPulse Engineering Metrics can provide the insights needed to bridge this gap, ensuring that engineering teams are always aligned with business objectives and are working efficiently towards their goals.
FAQ
What is the difference between a flaky test and a false positive?
A false positive is a test failure in your test suite due to an actual error in the code being executed, or a mismatch in what the test expects from the code.
A flaky test is when you have conflicting test results for the same code. For example, while running tests if you see that a test fails and passes, but the code hasn’t changed, then it’s a flaky test. There’s many causes of flakiness.
What is an example of a flaky test?
An example can be seen in growing test suites - when pull request builds fail for changes you haven’t made. Put differently, when you see a test pass and fail without any code change. These failed tests are flaky tests.
What are common causes of flakiness?
Broken assumptions in test automation and development process can introduce flaky tests - for example, if test data is shared between different tests whether asynchronous, high concurrency, or sequential, the results of one test can affect another.
Poorly written test code can also be a factor. Improper polling, race conditions, improper event dependency handling, shared test data, or timeout handling for network requests or page loads. Any of these can lead to flaky test failures and test flakiness.
End-to-end tests that rely on internal API uptime can cause test flakiness and test failures.
What's the impact of flaky tests?
Flaky tests can wreck havoc on the development process - from wasted developer time from test retries, to creating bugs and product instability and missed releases, time-consuming flaky tests can grind your development process to a halt.
What is the best way to resolve or fix flaky tests?
Devops, software engineering, and software development teams will often need to compare code changes, logs, and other context across test environments from before the test instability started, and after - adding retries or reruns can also help with debugging. Test detection and test execution tooling can help automate this process as well.
BuildPulse enables you to find, assess impact metrics, quarantine, and fix flaky tests.
What are some strategies for preventing flaky tests?
Paying attention and prioritizing flaky tests as they come up can be a good way to prevent them from becoming an issue. This is where a testing culture is important - if a flaky test case is spotted by an engineer, it should be logged right away. This, however, takes a certain level of hygiene - BuildPulse can provide monitoring so flaky tests are caught right away.
What type of tests have flaky tests?
Flaky tests can be seen across the testing process - unit tests, integration tests, end-to-end tests, UI tests, acceptance tests.
What if I don't have that many flaky tests?
Flaky tests can be stealthy - often ignored by engineers and test runs are retried, they build up until they can’t be ignored anymore. These automated tests slow down developer productivity, impact functionality, and reduce confidence in test results and test suites. Better to get ahead while it’s easy and invest in test management.
It’s also important to prevent regressions to catch flakiness early while it’s manageable.
What languages and continuous integration providers does BuildPulse work with?
BuildPulse integrates with all continuous integration providers (including GitHub Actions, BitBucket Pipelines, and more), test frameworks, and workflows.
Combat non-determinism, drive test confidence, and provide the best experience you can to your developers!
How long does implementation/integration with BuildPulse take?
Implementation/integration takes 5 minutes!