We currently provide our users with a very poor experience when updating their operating system.
Our current package-centric view of OS software updates is less than ideal. Most people are not interested in learning about updates to hundreds of tiny packages they have never heard of.
These myriad individual updates aren't even well coordinated. They arrive at the user's computer and pester her to update them in a random and seemingly continuous stream. This does not show respect for the user's time.
The many combinations of packages that are possible due to this lack of coordination means that we don't actually test any of them. There is no set that is canonical or even most likely.
So, basically, what we have today is:
- Uncoordinated and disruptive
- Often broken, fragile, and largely untested
A very poor user experience.
This section applies to all rawhide releases, and stable releases.
- System components must be tested as a single unit before release
- System components must be presented to the user as a single install unit
- System updates must not break any application that we define as critical (Firefox, etc)
- Users should be able to detect whether updates are available from within the app they are using
- Application updates should appear to the user as a single object (ie. not a set of loosely related packages)
- Applications must not install updates on their own but should work in concert with a central update installer.
- To limit the number of potential reboots after installs
- To offer the option of opting out of certain types of updates
- To not have to prompt the user repeatedly in different ways
- So applications don't expect that they can do whatever they wish
- So we can better test the combinations of software
- Allow users to discover or be reminded of pending updates
- To allow users to batch update disruptions
- Release engineering may be free to withdraw or block a package if it breaks the integration tests
- System must have a way to defer or queue updates to currently running software
- System must be able to download updates in the background using idle time and bandwidth
- System must be capable of installing update non-interactively (no prompting)
- System must be capable of installing the updates that require restarting at shutdown time
- This is a natural break in the user's flow
- The process can be left unattended and it will power off the machine when complete
- Batched updates must occur and appear to the user no more often than once per week
- Tuesday suggested as the update day
- System updates should only:
- fix critical bugs or security vulnerabilities
- provide hardware enablement
- System updates may only be deferred for a short time after which they will be installed automatically
- System updates should be able to run autonomously when the user requests a shutdown (but not necessarily on reboot since a reboot means that the user wants to resume operation and is not done with the computer)
- Application updates may be deferred or permanently ignored at the user's discretion
- One reason for this is that for the user the system is working fine and changes may be known to break workflows or habits or devices.
- Application updates may add new features even in a stable release at the upstream brand's discretion as long as someone can be held responsible for fixing problems
- Should perform more testing on or elimination of "zero-day" updates after a release
- Thorough testing of a release is less relevant if the system is never in that state due to zero-day updates.
- Nightly composes should be tested to boot, start a graphical user session, and load a web page before being pushed out
- There should be a weekly or bi-weekly snapshot stream/repo for early adopters that do not want the nightly changes
- Weekly snapshots should receive more testing than the nightly and a broader category of functionality should be confirmed to work
- It should always be dog-foodable and should never be known to be severely broken
- We should take our Alpha, Beta, etc releases more seriously
Having well defined and agreed upon checkpoints is one of the only ways to manage large open source communities. We agree that using a time based release process for stable releases is worthwhile but we give up on that the moment the release goes out the door.
By elevating Rawhide to something that people can actually use we can bring the community back into the Fedora development process.
The Quality Assurance team's job becomes tractable. The OS can be tested as a well defined unit. If someone wants to deviate from that - they are in uncharted waters. But right now we're all in charted (untested) waters. And that is scary.
Giving QA a job they can actually do is only one part of this. Having a larger community testing and using (dog-fooding) Rawhide before a release is also essential. As it stands, we don't even have a majority of the core Desktop design and development teams using Rawhide until shortly before the release.
Documentation teams will have opportunity to document release updates where required.
Increased visibility into the design and creation process (during Rawhide) should also be a big win.
Obviously, being able to avoid embarrassing oversights is an important goal. So is being able to tell a story about why Fedora is good for you.
Certainly, having well defined checkpoints allows a marketing team to schedule work more easily.
Having marketing folks be closer to the design and development phases of Fedora should facilitate building roadmaps for future releases and creating good stories about current ones.
Increasing visibility into the Rawhide cycle allows more viral marketing to occur - and to build anticipation for a release.
Being able to give (third-party) software developers some idea of what they can expect to use and depend on in Fedora would be helpful. Giving developers a chance to test their own apps with newer releases is important.
There is a lot more we can and should do here.
Making Fedora the best choice for working on upstream software really requires making Rawhide more usable. This helps build the Fedora development ecosystem.
Want to be able to test changes before they hit users. Want better documentation of changes. Want to see what is coming in future releases before they arrive. Have a strong incentive to see that updates are automatically or timely applied. Are overworked and would love to set up things on autopilot provided they never break things. In many cases wish to or need to delegate some authority to users to install apps or to perform updates. I hope that we can address each of these things.
Basically just want things to work and not disrupt or annoy them. Which means they trust us. Until they don't - and then they are gone.
NOTE: THIS PART IS SKETCHY
All snapshots (including nightly Rawhide) should ensure they don't break the following: System boots and can get to a web page to get help for minor issues if needed
In detail this means the following must work:
- process input
- detect monitor
- display output
- support root filesystem
- support home filesystem
- mount root filesystem
- only for encrypted disks?
- process input
- detect monitor
- display output
- autologin user
- since nothing starts without it
- handles logout
- displays network applet
- allows starting web browser
- connect to wireless
- load website