The black magic of scoping the effort in software projects

The software industry is notorious for missed schedules and project budgets that end up being double, triple or even higher than original estimates. One of the first managers I worked for, early in my career, joked that when an engineer gives you an estimate, you should double it and then move to the next unit of measure. In his mind, a two weeks estimate thus became four months. This was obviously an exaggeration, but it does point to the magnitude of the problem.

Three reasons for missing an estimate

There are multiple sources for missed estimates. First, there’s the shear complexity of scoping the effort of large projects. 

Second, engineers often think “dev done / it sort of works” as the end point when estimating the time it will take them. 

Lastly, there is the explicit or implicit pressure most engineers feel to come up with an estimate that will be palatable to upper management. The problem is even greater, I believe, if you consider the long hours engineers put in every day, plus many weekends and sometimes even holidays, in order to attempt to make the impossible schedules they’ve signed up for.

Missing schedules and blowing up budgets is not a luxury a professional services company has. Roughly 85%-90% of our projects end up under budget, and even the few that end up over budget are for reasons outside of our control. While there is no precise formula to use to properly scope the effort, I’ll share just a few notes that developers in our space may find useful.

Make sure you make the right assumptions

Your estimates are based on assumptions: 

  • working hardware (no glitches with the components or the PCB itself), 
  • deliverables owed to you by the customer, 
  • documentation that you might not be able to obtain easily and the customer will have to get it for you (due to strict NDAs, for example), 
  • any possible software deliverables by the customer to you, and so on. 

Start by listing your assumptions and make it known that if any of them prove wrong, additional time and budget will likely be required.

Look at specific tasks in the project and lean on past experience when you can

Break down the project into manageable tasks that you think you can estimate but lean back on past experiences with similar projects. One example that developers in the embedded Linux space will recognize is uplifting a BSP from a certain kernel version to the latest stable (same hardware, no new board spins to deal with). It’s easy to look at the list of, say, 10 device drivers that “should just work” and estimate that each one will take a day or two only, and 90% of the time you’ll probably be wrong. 

What we know from experience is that when doing similar work, it took on average, for example, one week per driver. Some may take a few hours; but others will take two weeks, and you don’t know which ones ahead of time. Don’t let the customer pick your estimates apart. Group this effort into a single task, “Uplifting the following device drivers:” and provide only a single estimate for the task.

Take a high level view

If you can’t break down the project into small tasks or perhaps it’s hard or impossible to estimate them, then step back and take a very high level view, or use a mix of approaches. 

We recently completed a project that included, among other tasks, bring-up of brand new hardware and writing some new, rather complex, Linux device drivers from scratch. The drivers we estimated separately, based on prior experience with these types of drivers and the corresponding Linux subsystem. As always, we listed our assumptions. 

The hardware bring-up, on the other hand, is impossible to estimate with precision. Instead, we used completely different high level heuristics once again based on 20+ years of industry experience: looking at past projects of similar complexity, how much time the customer took to go from first board spin to production, how much time we needed to get our work done, how much time the customer required for support and so on. 

Using such heuristics, we came up with an estimate for bringing up the hardware through the first spin (there is always a respin of new boards) and the writing the new drivers. We beat that estimate by a couple of weeks. 

Consider making the estimate Phase 0 of the project

Sometimes you just don’t know until you start working on the project and you’re two or four or more weeks into it. If that’s the case, make that a Phase 0 with the deliverable being a well defined and fleshed out effort estimate and project schedule, one that you can sign up for with a higher degree of confidence. 

These are a few of the ways we look at estimating a software project. As you can see, it’s not “black magic” after all but a multi-faceted approach to accurately scoping the effort. Contact us to learn more and prepare an estimate for your project.

Konsulko Group engineers to speak at ELC Seattle

Embedded Linux Conference, September 27- 30, 2021

Hyatt Regency Seattle | Seattle, Washington + Virtual

For over 15 years, Embedded Linux Conference (ELC) has been the premier, vendor-neutral technical conference for companies and developers using Linux in embedded products. Recent ELCs have expanded the scope to include both the user-space developers building applications on embedded Linux as well as the architects and developers working to deliver smart connected products and industrial IoT solutions.

At the upcoming Embedded Linux Conference, September 27- 30, 2021 at the Hyatt Regency Seattle (with a virtual option available), Konsulko Group engineers will give detailed technical talks on building RISC-V Linux systems, and Linux A/B upgrades.

Building a Low-key XIP-enabled RISC-V Linux System

Tuesday, September 28 • 4:00pm – 4:50pm

Principal Software Engineer (and GM Konsulko AB) Vitaly Vul (aka, Vitaly Wool) will discuss new hardware designs based on RISC-V, an open standard instruction set architecture. In modern times, RISC-V SoCs quite often have QSPI flash onboard which makes them perfect candidates to use XIP (eXecute In Place) technology to execute directly from flash without copying the code to RAM first. That allows to optimize memory footprint very tightly and thus opens up to really low-power IoT Linux appliances. Vitaly will present a demo how to run a mainline kernel configured for XIP on a RISC-V board, and discuss extending XIP support for RISC-V to 32-bit and MMU-less systems for low-key battery-powered RISC-V systems with RAM shortage.

Practical Experience with Linux A/B Upgrades

Wednesday, September 29 • 1:30pm – 2:20pm

Senior Software Engineer Leon Anavi will discuss deploying software upgrades to fleets of embedded Linux IoT devices, using A/B redundant systems with two identical partitions using popular open source solutions (like Mender or RAUC). Although they provide great features out of the box there are still plenty of technical obstacles to overcome for real-world use cases. In this presentation, we will walk through practical experiences using both Mender and RAUC with Yocto Project and OpenEmbedded. Leon will discuss BSP integration and porting efforts for new devices, bootloader requirements and configurations, tips and tricks for ARM and x86-64 systems, read-only file systems, partition layouts, storing persistent data during upgrades, managing single-file artifacts, simultaneous setup with Docker and other containers.

Join us in Seattle or virtually for this always informative, educational and fun conference for commercial and community embedded Linux developers.