Tag Archives: project life cycle

In defense of Fedora’s release cycle

Posted on by
3

Earlier this week, Thorsten Leemhuis published a thoughtful post about what he’d change if he magically became the supreme leader of Fedora. In that post and subsequent commentary on Mastodon and Fedora Discussion, he talked about changing Fedora’s release cycle. Since the Fedora Linux release process is my job, I figured I should explain why I disagree.

Integration projects are different

If you haven’t read the post, you should. But here’s the short version: Fedora Linux uses a release model rooted in the 1990s and should move to a “modern” model. Thorsten suggests a one-month cadence for those who want the latest versions and a one-year “steady” release. Such a model has worked well for Firefox, he argues, and so it should work for Fedora.

The key reason I think this is wrong is because Firefox is a development project whereas Fedora is an integration project. Integration projects don’t write a lot of code, they take the work of others and turn it into a coherent whole. This is a fundamentally different kind of work and it takes longer by necessity.

You can’t reliably integrate disparate pieces when they’re in constant motion. That’s why we have freezes leading up to the beta and final releases — they give the QA team time to test against a stationary target. It takes time to run through all of the test cases that make Fedora Linux a reliable operating system. So the choice becomes reducing the pre-release testing or spending a significant portion of the cycle in a freeze, which limits the the usefulness of the one-month cycle.

You can solve some of this with automated testing. And the QA does do a lot of automated testing. But those tests still take time, and there are a lot of interrelated parts in a Linux distribution.

Six months isn’t magic

There’s nothing objectively correct about a six month release cycle. It’s mostly because that’s how you get two releases a year. If the calendar had 10 months, the release cycle would be five. But there is a lower bound where you’ve become a de facto rolling release, even if you still have discrete releases. I don’t know where exactly that boundary is, but I suspect that one month is at or just beyond it.

Similarly, there’s an upper limit where you’re now a slow, plodding project. Again, I can’t say where the line is. Six months may be uncomfortably close to it, but I suspect it’s closer to a year. And, of course, it depends on the nature of the specific project.

So there’s no particular reason Fedora Linux couldn’t move to a shorter release cycle. Five months is totally doable. Four is possible. Three would require a tremendous amount of work before it could be considered. But what’s the benefit of going to a shorter cycle? Does five months instead of six make a meaningful difference? At least with six months, you know there’s a release targeted for April and October. Predictability is nice.

Solving the actual problem

The bigger issue, though, is that I don’t think people actually want this. Yes, you might want your web browser and other applications to update frequently. But that doesn’t mean you want your compiler or Python interpreter or C libraries to update frequently. Most people will avoid this in favor of the “steady” stream. This eliminates the intended benefit to upstream projects.

The people who do want everything to update quickly use a rolling release distribution, something that Thorsten explicitly says his proposal is not.

Fundamentally, the proposal looks at the problem the wrong way. The problem isn’t that a six month cycle is too long. The problem is that application delivery is coupled to operating system delivery. Most people want the latest versions of the applications they care about and for everything else to remain unchanged. The challenge, of course, is that not everyone draws that distinction in the same way.

We unsuccessfully tried to solve this with Modularity. Flatpak, at least for graphical applications, offers another attempt to solve this problem.

Historically, the system and application layers have been distributed together. Figuring out how to decouple these (including how to draw the line between them) is the interesting work. And it provides real value to the end users.

The life of a project

Posted on by
Reply

A picture on Twitter caught my eye earlier tonight. “The life of a project” captures a person’s mental state through the life of the project. It was particularly meaningful to me because it basically describes what I’ve gone through this past week at work. I’ve been working on a very high stakes proof of concept for a customer with a lot to lose, and it’s been pretty taxing. You can ask my family; I haven’t been much fun to be around the past few days. Fortunately, we’re on the upward slope now: lessons have been learned for phase 2 and the prototype cluster is basically working at this point.

It occurs to me that many projects I’ve been involved with or aware of follow this general pattern. I stopped to think about why that is. For this project, the business requirements weren’t incomplete, although that is often an issue for projects. The technical requirements were missing, though. As it turns out, a few extra DLLs (yes, this is a Windows execution environment) were needed. The software used for this project is pretty awful, and so the error messages weren’t particularly helpful. It took the better part of a day just to leap that particular hurdle.

Another contributing factor was not knowing where we were starting from. (As the old saying goes, “I don’t know where we are, but we’re making good time!”) I thought we were basically cloning a similar project we had done for another customer, and started my work based on that assumption. As it turns out, the environment we were starting from was not nearly as robust and automated as I had been led to believe. The result was two days of effort getting to where I thought we would be after a couple of hours. This wasn’t entirely bad. It gave me an opportunity to work with parts of our product stack that I haven’t worked with much, and it pointed out a lot of areas where future such projects could be done much better. But it was also a great way to add to the already high levels of stress.

Even in a small company, nobody is familiar with everything. Time spent re-explaining what I was trying to do when I had someone new helping me didn’t move the project forward. Likewise, having to hop from person to person in order to get the right expertise was a barrier to progress. I was fortunate that all of my coworkers were extremely willing to help, and I certainly can’t blame them for not knowing everything. Nonetheless, it was frustrating at times.

Certainly the long downward slide that characterizes most of the life of a project can be mitigated. Starting with a more complete understanding of requirements, knowing what you’re starting from, and having the right expertise available can reduce the surprises, frustration, and sadness of a project. Still, I think it’s human nature to experience this to some degree. We always start out confident in our abilities and blissfully ignorant of the traps that are waiting for us.