<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ray Rischpater, KF6GPE on Medium]]></title>
        <description><![CDATA[Stories by Ray Rischpater, KF6GPE on Medium]]></description>
        <link>https://medium.com/@kf6gpe?source=rss-95debe19f9f3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*stkoPD1JQ5tooR-s76YSmw.jpeg</url>
            <title>Stories by Ray Rischpater, KF6GPE on Medium</title>
            <link>https://medium.com/@kf6gpe?source=rss-95debe19f9f3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 13:36:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kf6gpe/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Providing operating system compatibility on a large scale]]></title>
            <link>https://blog.flutter.dev/providing-operating-system-compatibility-on-a-large-scale-374cc2fb0dad?source=rss-95debe19f9f3------2</link>
            <guid isPermaLink="false">https://medium.com/p/374cc2fb0dad</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[continuous-integration]]></category>
            <category><![CDATA[announcements]]></category>
            <dc:creator><![CDATA[Ray Rischpater, KF6GPE]]></dc:creator>
            <pubDate>Thu, 14 Jan 2021 18:48:49 GMT</pubDate>
            <atom:updated>2021-01-15T19:40:10.678Z</atom:updated>
            <content:encoded><![CDATA[<p>Applications written using Flutter can run on Android, iOS, the web, and desktop operating systems. Because of our investment in supporting multiple platforms, a Flutter application can run on any device with the OS version (or a later version) that the application was written for without needing changes, which broadens Flutter’s cross-platform appeal.</p><p>In this article, Flutter’s core development team (we) want to share why we invest in supporting multiple platforms, how we can keep supporting multiple platforms, and how we make decisions when it comes time to add support for new platforms or drop support for old platforms.</p><h3>Looking ahead: releases of Android and iOS</h3><p>Flutter is committed to providing full support for the latest features of Android and iOS. We’re always monitoring the regular guidance from Apple and Google regarding changes in their platform APIs, tool use, and licensing terms. Support for new OS releases is part of our regular product planning, and we attempt to align our releases in such a way that stable releases are always compatible with the latest guidance from both Google and Apple.</p><p>Our commitment to you to support multiple platforms and software releases of Android and iOS, such as Android 11 or iOS 14, along with their minor releases. For major revisions to the target platforms, development of necessary features and changes begin as soon as we learn what’s needed. This typically happens in late spring, after Google announces their plans for an upcoming Android release and when Apple makes their latest announcements at their Worldwide Development Conference (WWDC). After the announcements, we assess the necessary changes to the Flutter codebase, like changes to the engine because of potentially deprecated APIs, how tooling changes affect the flutter tool and the developer experience, and changes in the design language for both platforms. We also assess the scope of work with the expectation that both platforms will be available to customers in the early fall.</p><p>We do this work against the beta releases of Android and iOS, and we make these changes available regularly through our master, dev, and beta channels. The master channel releases are continual. We plan for two to three releases of the dev channel per week (a version of the master channel tested against internal Google apps and test suites). The beta channel usually releases the first week of every month. We track our progress using GitHub issues. For a list of issues, you can search by `platform-ios` or `platform-android`.</p><p>Aligning our stable release schedule with iOS is particularly challenging because often there is very little time between a press announcement and when we get guidance about changes to the OS. We mitigate this challenge by planning one of our releases in the fall, and being prepared to hotfix our current stable release with any blocking bugs on iOS or even on Android should they occur. (This happened with Flutter 1.20 and iOS 14, and we released a <a href="https://medium.com/flutter/supporting-ios-14-and-xcode-12-with-flutter-15fe0062e98b">hotfix the same day</a> that iOS 14 shipped.)</p><p>Regardless of the work it takes to support a new platform release, our goal is to support new versions of our target platforms without deprecating old ones.</p><h3>Backward compatibility and Flutter’s value proposition</h3><p>Flutter is Google’s portable UI toolkit for building beautiful, natively-compiled applications for mobile, web, and desktop from a single codebase. To do this, we want to support the broadest collection of devices we can, not just specific types of platforms. We also want to support the broadest number of platform versions.</p><p>Consider Android: By <a href="https://gs.statcounter.com/os-version-market-share/android/mobile-tablet/worldwide">statcounter</a>, as of June 2020, Android versions in the wild consist of the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cn2P4AQs91rSOztB" /></figure><p>Looking at the numbers, Android KitKat (Android 4.x) has less than a 2% market share. The predominant share of Android devices (54%) are running Android Pie (Android 9.0) or Android 10. Supporting each version of Android requires an investment. Do you know why we invest in a platform, like KitKat, that has a low market share?</p><p>The answer is simple: raw numbers. With over a billion Android devices in use not running Android Pi or later, we want to ensure that Flutter is as broadly available as possible. We also want to support a diverse, global user base. And, because older versions of Android and iOS are often used by people in developing countries, we want to avoid deprecating support for older versions as long as we can.</p><p>Through work in Flutter’s core engine, framework, and plugins, Flutter provides abstractions for the vagaries of both OS platform and OS versions. As an example, a Material application can run on an older version of iOS or Android without being changed. In fact, developers have released commercial Material applications running on hardware that shipped at the same time that the first version of it was made available, something you can’t do on those devices with the widget set that shipped with those devices. A similar story exists for plugins. Plugins abstract away both platform and version differences, leaving you to focus on what’s important: your application.</p><h3>How Flutter supports so many targets</h3><p>Flutter brings two strengths to multiple-target support. First, Flutter relies very little on the underlying OS. Flutter’s engine works directly with the graphics APIs, and plugins provide much of the device-specific implementation for additional features.</p><p>Our continuous integration (CI) system builds Flutter and its tooling for macOS, Linux, and Windows, deploying to a suite of Android and iOS devices (both physical and emulated). Some of this CI is done using a lab run on Google’s premises; other CI tests are run on the <a href="https://firebase.google.com/docs/test-lab">Firebase Test Lab</a>, a cloud-hosted test solution operated by Google for both Google and third-party developers.</p><p>Here’s a picture of one of the racks in our test lab:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*XGMajBOXRRgyu3Pa" /></figure><p>We run relatively low-end mobile devices in our device lab, because we do our <a href="https://flutter-dashboard.appspot.com/benchmarks.html">performance testing</a> there. When testing, we want performance metrics from devices that are representative of what most users have. Doing this gives us worst-case, real-world performance. This philosophy carries over to the devices that the core engineering team uses. Most of the core engineering team isn’t doing Flutter debugging on the latest Google Pixel or Apple iPhone.</p><p>Because we want to test many types of mobile devices, we keep a device library where members of the core engineering team can check out specific devices for testing and debugging. (With COVID-19, we’re making good use of the US Postal Service!)</p><p>Because the lab can only test a handful of device types and versions, how can we be sure that we’re providing the support we claim? Read on to find out.</p><h3>Making general assertions about platform version support</h3><p>First and foremost, we test on a variety of platforms with each code commit.</p><p>In our lab today, we’re testing on the following Android platforms:</p><ul><li>Android API 24 (Android N)</li><li>Android API 28 (Android P)</li><li>Android API 29 (Android 10)</li></ul><p>This covers 57% of the market of deployed Android versions; more on how we cover the remaining devices through the use of Firebase Test Lab in a moment.</p><p>Our lab also tests iOS on every commit, on devices running:</p><ul><li>iOS 9.3.6</li><li>iOS 12.4</li><li>iOS 12.4.1</li><li>iOS 13.1.3</li><li>iOS 13.2</li></ul><p>Finally, for desktop and web, we test every commit on:</p><ul><li>Chrome 84</li><li>Firefox 72.0</li><li>Safari on Catalina</li><li>Edge 1.2.0.0</li><li>Windows 10</li><li>macOS El Capitan</li><li>Debian 10</li></ul><p>Clearly there’s more testing that needs to happen on the Android front. We rely on <a href="https://firebase.google.com/docs/test-lab">Firebase Test Lab</a> for this, testing the following additional Android and iOS configurations:</p><ul><li>Android API 19 (Android K)</li><li>Android API 21 and 22 (Android L)</li><li>Android API 23 (Android M)</li><li>Android API 26 and 27 (Android O)</li><li>Android API 30 (Android 11)</li><li>iOS 11</li><li>iOS 13.0</li><li>iOS 13.1</li><li>iOS 13.3–13.7</li><li>iOS 14</li></ul><p><strong>Together this brings our testing of Android and iOS platforms to well over 95% of the currently released versions.</strong></p><p>For other operating system versions, we provide backward compatibility with <strong>your</strong> support, the Flutter development community. This is especially true of specific device/operating system combinations. Many of you use devices that we don’t have access to: either because you have an operating system version we don’t have, or because the device isn’t available in the US. In some cases, we can mitigate this. For example, we can flash an older Android build on some Google Pixel hardware, buy an older, refurbished iOS device, or run an Android version in an emulator. In many cases, a report from one of you triggered an investigation of a specific platform issue.</p><p>This is especially true with a number of original equipment manufacturers (OEMs) of Android devices. OEMs frequently customize aspects of Android like keyboard support. In the past, we’ve been able to fix a number of text input issues that only occur in certain markets on certain devices thanks to your help.</p><p>We appreciate your help because we can’t possibly find every issue on our own, but we work hard at reducing the risk of injecting issues. We’re careful when making code changes and pay attention to what’s supported on the earliest version of the operating system. We provide options when we need to support disjointed configurations. That’s why, for example, you can still build iOS applications using either OpenGL or Metal, which Flutter automatically chooses at runtime.</p><p>For these reasons —even though we go to great lengths to support testing on OS versions —some of the devices we support are supported on a “best effort” basis. We try to write code that supports the platforms we claim support for, we rely on our team’s commitment to device diversity in ad hoc use, and then look to the community for feedback on how we’re doing in practice.</p><p>We need your help with testing devices in the best effort category. There are tens of thousands (or more!) of SKUs in this category. We test as many as we can and, at times, we source older devices from auction sites to enable us to test and fix device issues that were reported when there is no other way to duplicate the issue. If you find an issue with a particular device, please file an issue on GitHub.</p><p>Finally, some platforms, such as iOS 7, are deprecated. Perhaps they work, but we do not test on deprecated platforms and make no guarantees. We do, however, consider patches for deprecated platforms on a case-by-case basis if we can support the platforms adequately when testing after the patches land.</p><p>Flutter keeps a <a href="https://flutter.dev/docs/development/tools/sdk/release-notes/supported-platforms">web page</a> of the devices which we test on and those we look to the community for help with.</p><h3>Deciding to deprecate support</h3><p>Although we’re committed to supporting every platform version as long as we can, supporting older platforms (or platform configurations, such as OpenGL on Apple A7) comes with a cost, and follows guidance from our upstream partners, including Skia. Flutter’s core engineering team is relatively small, and we’re continually making trade-offs to ensure that what we do has the most beneficial effect for our users. At some point, the cost in terms of engineering, bandwidth for testing in our CI lab and through ad hoc testing, and technical limitations (such as the deprecation of tooling on the part of an OS vendor) can make it difficult or impossible to continue supporting a target platform.</p><p>Before we decide to deprecate support, some of the questions we consider are:</p><ul><li>How many end users would this eliminate for our developers?</li><li>What effect does this have on Flutter developers? Are there major partners whose business operations would be significantly affected?</li><li>What engineering savings are we likely to gain? For example, does the number of applications built with Flutter grow from supporting multiple OS versions? (This is the case, for example, by supporting both OpenGL and Metal in iOS builds.)</li><li>Does the decision align with our broad adoption and inclusivity goals?</li><li>Is the deprecation prompted by an external cause, such as a platform vendor deprecating support for a platform version in their build tooling? If so, is it possible to mitigate that deprecation?</li></ul><p>When evaluating whether to deprecate support, we first pose the question to you by starting an issue in GitHub and publishing an associated <a href="https://flutter.dev/docs/resources/design-docs">Flutter design document</a> that proposes the deprecation, explaining why we’re considering it, and what mitigations might be available. This is a request for comment (RFC) to our community; the public design document is socialized through both our discussion list (<a href="/service/mailto:flutter-dev@googlegroups.com">flutter-dev@googlegroups.com</a>) and our <a href="https://github.com/flutter/flutter/wiki/Chat">Discord</a>.</p><p>To begin deprecation, we start the RFC process at the delivery of a stable release, as part of the announcement of the stable release. We then leave time for public comments before reducing support for the platform or feature in the subsequent platform release. The RFC is an opportunity for you to provide feedback. Based on the feedback we receive, we will either move forward with the deprecation, or make changes to the proposal, extending the support for a platform version for a longer period. We take feedback about these prospective decisions very seriously, because we recognize that we have a responsibility to you and your product’s users.</p><h3>Request for comment: iOS 8 deprecation</h3><p>We are considering deprecating support for iOS 8. All iOS 8 devices can be upgraded to iOS 9. According to both Google and third-party analytics, the number of devices running iOS 8 is extremely small (some report “0.0%”), and Apple is gradually deprecating support for iOS 8 in their tooling.</p><p>We have published a <a href="https://docs.google.com/document/d/1G5L7ux7ofQp3bCSNAt4ovvL5-8PF_rqo2erAVIcHHeg/edit">request for comment about deprecating iOS 8</a>, and we ask for you to review it and participate in the discussion. Our intention is that Flutter 1.22 (our most recent stable release) will be the last stable release to support iOS 8. The RFC includes both the justification and what to do if you’re affected.</p><h3>Request for comment: Android Jelly Bean deprecation</h3><p>We are considering deprecating support for Android Jelly Bean because we no longer test devices with that version of Android in our lab, and sourcing reliable devices for lab use is increasingly difficult. Devices running Android Jelly Bean comprise some 0.46% of the user base of Android at this point.</p><p>We have published a <a href="https://docs.google.com/document/d/1IjlypDrIIGgF2N76P6z8QL2rT5Uuh_rBvqOgDUyhCx8/edit">request for comment about deprecating Android </a>Jelly Bean, and we ask you to review it and participate in the discussion. Our intention is that Flutter 1.22 (our most recent stable release) will be the last stable release to support Android Jelly Bean. The RFC includes both the justification and what to do if you’re affected.</p><h3>How you can help</h3><p>The easiest way to help is to get involved! We appreciate the issues you file regarding the edge cases on various devices that we haven’t encountered. In many cases, they occurred on hardware that we would never have had, even if we doubled or quadrupled our spending on hardware testing. Reporting these issues with reproducible cases and including details about software versions and hardware models is essential for us to track down the source of a problem.</p><p>In addition, we look to you to be involved with the decision making process when the time comes to reduce support for a specific platform. Your insights are invaluable when we consider Flutter’s future. Please participate in our open RFCs when you see one. You are the expert in your particular market, and are closest to your customers.</p><p>We deeply appreciate the trust you’ve given us with your users, and letting us be part of your product. We remain committed to helping you paint your vision to life on as many screens as possible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=374cc2fb0dad" width="1" height="1" alt=""><hr><p><a href="https://blog.flutter.dev/providing-operating-system-compatibility-on-a-large-scale-374cc2fb0dad">Providing operating system compatibility on a large scale</a> was originally published in <a href="https://blog.flutter.dev/">Flutter</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Managing issues in a large-scale open source project]]></title>
            <link>https://blog.flutter.dev/managing-issues-in-a-large-scale-open-source-project-b3be6eecae2b?source=rss-95debe19f9f3------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3be6eecae2b</guid>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[spotlight]]></category>
            <dc:creator><![CDATA[Ray Rischpater, KF6GPE]]></dc:creator>
            <pubDate>Fri, 17 Jul 2020 16:12:57 GMT</pubDate>
            <atom:updated>2020-07-17T18:21:23.760Z</atom:updated>
            <content:encoded><![CDATA[<h4>How the Flutter team addresses its issue backlog</h4><p>We’re honored by the amount of positive feedback we get from folks using Flutter. As one of the largest active repositories on GitHub, we have a relatively unique challenge and we thought you might find it interesting to learn our philosophy and approach to how we’re dealing with issues at this scale, what changes we’re making to deal with the project growth, and some helpful tips for filing issues to maximize their value.</p><p>Sometimes developers attempt to use the total number of public logged issues as a measure of the overall quality of the project. We think this number is poorly correlated with project health, and want to explain why, counter to expectation, a larger number of issues can be a signal of a high-quality, popular project.</p><p>Lastly, we want to use this blog post to share some concrete changes we’ve made in recent months: more active scrubbing of our backlog, accomplishing (and holding to) zero-bug-bounce for unassigned issues, and a new prioritization scheme that better aligns with how we believe our customers think about priorities.</p><h3>How Flutter uses GitHub</h3><p>It’s common in today’s software development world for teams to keep a backlog of issues submitted both by team members and users: this backlog is the sum total of bugs, feature requests, and technical debt facing the team. Flutter is no different: we use GitHub as our backlog. If it’s a bug, an idea for a new feature, or something in between, it’s filed as an issue in our issue database <a href="https://github.com/flutter/flutter/issues">on GitHub</a>.</p><p>Each of these issues starts with you, or one of Flutter’s contributors. Contributors and users file issues about Flutter or Flutter’s API documentation in the <a href="https://github.com/flutter/flutter/issues">flutter/flutter issue tracker</a>, and issues about Flutter’s website (<a href="https://flutter.dev/">flutter.dev</a>) in the <a href="https://github.com/flutter/website/issues">flutter/website issue tracker</a>.</p><p>There are three special considerations about how we manage issues on GitHub, which contributes to a large overall number:</p><ol><li>The issue repository is completely open. The core engineering and product teams, along with the entire Flutter community, files all feature enhancements, bugs, and potential future work into the open repository.</li><li>We don’t aggressively close issues, even if we don’t plan to work on them in the immediate future; we want to keep the total backlog of possible work open, so that any future contributor can work on a feature they’re interested in and see the discussion that’s already transpired.</li><li>We use one repository for <em>all</em> issues except for those involving the developer toolchain and website. Issues with Android, iOS, Windows, web, macOS, and Linux; framework and engine; API documentation and plugins, are all logged in the same <a href="https://github.com/flutter/flutter">flutter/flutter</a> repository.</li></ol><h3>Flutter’s triage process</h3><p>The <a href="https://github.com/flutter/flutter">flutter/flutter</a> issues are triaged by a member of the team: perhaps a volunteer, or one of the folks at <a href="https://blog.codemagic.io/flutter-and-codemagic-join-forces-on-github/">Nevercode</a> who have been helping us with triage, or by a Google employee (or an employee of another company). In triage, we assign as many labels to the issue as we can.</p><p>Some labels direct the issue for secondary triage. For example, the <a href="https://github.com/flutter/flutter/labels/engine">engine</a> label directs the issue to the engine team for secondary triage. Other labels indicate additional attributes, such as whether the issue is a feature request or a possible enhancement to increase the team’s velocity (as I write this, there are <a href="https://github.com/flutter/flutter/labels/team">over 500 issues with that label</a>).</p><p>Between primary and secondary triage, we also assign a priority label for issues filed against the code base or API documentation. Similar to other bug trackers, we use a ranked priority scheme, with priorities ranging from P0 to P6:</p><ul><li>The <a href="https://github.com/flutter/flutter/labels/P0">P0</a> label indicates top-priority issues such as build breaks or severe performance regressions that must be addressed immediately.</li><li>The <a href="https://github.com/flutter/flutter/labels/P1">P1</a> label indicates that the issue requires timely attention, such as breakage in a major feature used by the majority of our users, or an issue blocking a strategic partner. We aim to fix or remediate P1 bugs within the current milestone.</li><li>The <a href="https://github.com/flutter/flutter/labels/P2">P2</a> label indicates major features or issues that affect a significant subset of our users. Like P1 issues, we aim to fix or remediate these within the current milestone.</li><li>The <a href="https://github.com/flutter/flutter/labels/P3">P3</a> label indicates an issue currently on our timeline for an upcoming release that is at the top of our work list. Many issues we are actively working on bear this label, and most should have a milestone indicating when we think they’ll land.</li><li>The <a href="https://github.com/flutter/flutter/labels/P4">P4</a> label indicates issues that we agree are important to work on, but not at the top of the work list. This is the default level for bugs.</li><li>The <a href="https://github.com/flutter/flutter/labels/P5">P5</a> label indicates issues we think are valid but not critical. This is the default level for new feature requests.</li><li>The <a href="https://github.com/flutter/flutter/labels/P6">P6</a> label indicates valid issues that are unlikely to ever be worked on, but kept open in the event that a contributor might want to tackle it.</li></ul><p>This schema is relatively new, replacing our three-axis system of committed milestones, `customer:` and `severe:` labels. In the process of establishing it, we auto-prioritized a large number of issues based on committed milestones and other labels.</p><h3>Measuring quality by bug count</h3><p>Because Flutter uses GitHub as a fully open issue tracker, with both bugs and feature requests, there’s no direct correlation between issue counts and product quality. Other open source projects, such as <a href="https://bugs.chromium.org/p/chromium/issues/list">Chromium</a> and <a href="https://github.com/tensorflow/tensorflow/issues">TensorFlow</a>, also developed fully in the open, have large issue counts as well. If anything, the large number of issues suggests that the project is active and vibrant as users engage in the product finding both bugs and things they’d like to improve.</p><p>It’s difficult to make apples-to-apples comparisons, though. Some projects proactively close open issues they’re not going to address; others keep their issue database in secret, and others use different projects for different kinds of issues. As already noted, we track feature enhancements and bugs in the same repository; we also use one repository across tools, Android, iOS, first-party plugins, and so forth.</p><p>A better metric to gauge the health of an open-source project is to look at the number of issues closed vs. the number of issues currently open. As of this writing (early July 2020), we have 7,757 issues open and 32,485 issues closed. The rate of closure has increased over the last year, although has flattened somewhat in recent months:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E-lTv57-czvPhZre" /></figure><p>The dip in December is due to the holiday season; many contributors at Google and elsewhere take a vacation in that month. Regardless, the year-over-year average is 1314 issues closed, and if you look at the six-month average, you see that it’s considerably higher, at 1604 issues closed every month.</p><h3>Understanding our open issues</h3><p>To get a better understanding of the kinds of issues we face, the Flutter leads recently took a random sample of 1,200 open issues and retriaged them. In the process, we learned the following:</p><ul><li>32% of the issues filed came from core contributors on the project. Many of these are future work items, such as features, ways to improve the product, or improvements to our team’s tooling and infrastructure that would increase our own developer velocity.</li><li>The average Flutter contributor filed 7.4 bugs, while the average user of Flutter who had filed any bugs had filed 1.2 bugs.</li><li>Of the issues we examined, some 25% were either support requests, clearly unactionable, or otherwise no longer valid (i.e., subsequent work fixed the issue or new product directions made the concern of the issue obsolete), which we were able to close.</li></ul><p>We’re continuing to work with Nevercode on grooming our backlog, both with recently filed issues and older issues. They have been very helpful in several ways:</p><ul><li>They actively create reproducible code for issues, helping other engineers look for ways to fix bona fide bugs in Flutter.</li><li>They deduplicate bugs, closing duplicates after crosslinking them.</li><li>They close non-reproducible bugs, as well as requests for support (which should be directed to one of the channels listed at <a href="https://www.flutter.dev/community">https://www.flutter.dev/community</a>).</li><li>They request additional information for unclear issues, closing those that are unactionable.</li><li>As time permits, they help us cull our backlog of old issues, answering the same questions: Is it still an issue? Does it have a reproducible case? Is it a duplicate?</li></ul><p>Together, we’ve learned some interesting things about the issues people file: Over the last two months, fully 55% of the issues filed don’t meet our criteria — they’re either requests for support or don’t have reproducible cases.</p><p>For older issues, the Nevercode team has found that fewer issues were invalid or duplicated, likely explained by survivorship bias (issues that survive previous triages are likely not invalid or duplicate issues). Nonetheless, in their sample, 18% of the issues were invalid (either support requests or unactionable), and another 15% were duplicates. The lion’s share — up to 50% — reflects issues that have been subsequently addressed, suggesting that we can do a better job closing old issues as we add functionality and fix bugs.</p><h3>Issue prioritization</h3><p>As of this writing (early July 2020), here’s the breakdown of P0-P2 issues:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aO0bWR8VrmusQNRi" /></figure><p>This chart shows a healthy number of issues that we’re actually working on with urgency. As you’d expect from a popular open-source project, there are a <em>lot</em> of other pieces of feedback in our issue database: here’s the breakdown of P3-P6 issues:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*shcSGNkownGkrpoM" /></figure><p>The team is actively working on many of the P3 issues, as well as the higher-priority P0-P2 issues.</p><p>We still have a historical backlog of triaged unprioritized issues. Of these, we believe that most will likely fall into the P5 or P6 category, because as part of Nevercode’s triage efforts, they’ve escalated those that deserve immediate attention.</p><p>Just because an issue makes it to secondary triage does not mean that the core engineering team has bandwidth to work on it. In secondary triage, we look at several things to determine what to do with an issue, including:</p><ul><li>What other work have we committed to?</li><li>How severe an issue is this?</li><li>How many people does it affect?</li><li>Is this issue for a specific customer?</li><li>How does working on this issue affect our roadmap and architecture?</li></ul><p>For details on how we accomplish this, you can see our previous blog post on the topic, <a href="https://medium.com/flutter/https-medium-com-flutter-issues-bugs-and-backlogs-5fb3adab5e25">“Issues, Bugs, and Backlogs</a>”.</p><h3>How you can help</h3><p>The Flutter issue database on GitHub isn’t just the team’s issue database, it’s the issue database for our entire community, so we all need to play a part in its health. Here are some things we can all do to help keep a check on the quality of issues in the database:</p><ul><li>Don’t file an issue for support requests. Support requests should be raised in one of the channels we describe at <a href="https://flutter.dev/community">https://flutter.dev/community</a>. We actively close requests for support raised on GitHub.</li><li>File issues in the appropriate database: Flutter bugs, API documentation bugs, and feature requests in the <a href="https://github.com/flutter/flutter/issues">flutter/flutter issue tracker</a>, and feedback about the Flutter website or codelabs in the <a href="https://github.com/flutter/website/issues">flutter/website issue tracker</a>.</li><li>When filing an issue, search to see if one already exists for the issue you’re having. If so, upvote it and comment if appropriate. The development team uses upvotes as a measure of interest when ranking issues for future work.</li><li>Cross-linking is good! Feel free to crosslink related issues, either when filing new issues or when upvoting an issue you’ve encountered. Like upvoting, the team uses crosslinks in their investigations, and there’s a good chance that you see a relationship that others have missed.</li><li>Make sure that your bug contains everything the team needs to reproduce it. A minimally reproducible case is crucial for the team to be able to quickly get to the root of a bug. Explaining why a feature is important makes it more likely that the team will prioritize the work quickly.</li><li>Consider helping the triage effort. See a bug you have time to reproduce? Try reproducing it on the latest stable and master, and let us know if it’s still a problem. See a related issue? Crosslink it. Want to write some code? Submit a PR with a unit test exhibiting the issue, or better yet, a unit test with a fix for the issue. We welcome help on managing issues, so if you’d like to help, see our <a href="https://github.com/flutter/flutter/blob/master/CONTRIBUTING.md">contributing guide</a> for detailed information on how you can join us in the triage process.</li></ul><p>Speaking for those working on Flutter, we’re in awe of the support you continue to give us in our vision to build ways to bring beautiful, performant applications to your users. Thanks so much for all that you do!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3be6eecae2b" width="1" height="1" alt=""><hr><p><a href="https://blog.flutter.dev/managing-issues-in-a-large-scale-open-source-project-b3be6eecae2b">Managing issues in a large-scale open source project</a> was originally published in <a href="https://blog.flutter.dev/">Flutter</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Issues, Bugs, and Backlogs]]></title>
            <link>https://blog.flutter.dev/https-medium-com-flutter-issues-bugs-and-backlogs-5fb3adab5e25?source=rss-95debe19f9f3------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fb3adab5e25</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[issues]]></category>
            <category><![CDATA[bugs]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[tutorial]]></category>
            <dc:creator><![CDATA[Ray Rischpater, KF6GPE]]></dc:creator>
            <pubDate>Mon, 25 Nov 2019 17:12:55 GMT</pubDate>
            <atom:updated>2019-11-25T18:20:06.292Z</atom:updated>
            <content:encoded><![CDATA[<h4>Managing feedback in a large open source project like Flutter</h4><p>The growth of Flutter as a community-driven open source project is an ongoing source of delight to us here at Google. Whether measured in <a href="https://twitter.com/timsneath/status/1189594253690691584">popularity on GitHub</a>, number of <a href="https://www.reddit.com/r/FlutterDev/comments/dsnzbq/githubs_2019_octoverse_report_is_out_flutter_is/">projects created</a>, or <a href="https://adtmag.com/articles/2019/03/29/linkedin-skills.aspx">skills growth</a>, 2019 has been a defining year for the project, and we’re ever thankful to you all for your support and contributions to make Flutter the project it is. We build Flutter with you and for you, and we hope that comes across in everything we do.</p><p>As we’ve grown, the number of issues we need to track grows, too! We use issues on GitHub in a variety of ways: not just to report bugs, but any unit of work pertaining to the project. Anyone can submit an issue, and these issues fall into a number of categories:</p><ul><li>Feature requests: things a user or a contributor wish that Flutter could do, or do better.</li><li>Support issues: questions from users as to how Flutter works or how to do things. While these are better asked on Stack Overflow, many point to ways that we could improve our documentation, too.</li><li>Bona fide defects: things that don’t work as they should. This includes serious issues like crashes and performance regressions, but also those pesky fit-and-finish bugs that are common in any large software system.</li><li>Untriaged items that haven’t been examined and labeled.</li></ul><p>Thus, our issues aren’t just a collection of defects; they’re our backlog. Anything we think of that we may want to work on should be represented as an issue, appropriately labeled, so that as we plan our goals and milestones we have a place from which to start.</p><p>Some projects use the number of open bugs as a proxy for gauging release quality, and classify bugs as either defects or issues. <a href="https://github.com/flutter/flutter/wiki/Issue-hygiene#issue-philosophy">Flutter doesn’t do this; we choose to track bugs and issues the same way, in GitHub, keeping everything in the open</a>. As a result, there will always be far more things that we <em>could</em> be working on than we actually <em>are</em> working on. This is true for many healthy open-source projects; one need only look at others that have been around for a while such as <a href="https://github.com/tensorflow/tensorflow/issues">Tensorflow</a>, <a href="https://bugs.chromium.org/p/chromium/issues/list">Chrome</a>, <a href="https://github.com/dart-lang/sdk/issues">Dart</a>, <a href="https://github.com/golang/go/issues">Go</a>, or <a href="https://github.com/Microsoft/vscode/issues">VSCode</a>.</p><p>Nonetheless, we want to be sure that our incoming issues are well-labeled and do the necessary gardening work so that our issue database is an accurate reflection of our product status. To this end, we’ve engaged with the community: there are a number of volunteers helping us with our front-line triage, and we’re <a href="https://blog.codemagic.io/flutter-and-codemagic-join-forces-on-github/">pleased to announce that we’ve partnered with Nevercode</a>, the providers of <a href="https://codemagic.io/">Codemagic</a>, a leading CI/CD system for Flutter, to help us with our front-line triage as well.</p><h3>The Lifecycle of an Issue</h3><p>We welcome new issue submissions! Our issue triage process is described in <a href="https://github.com/flutter/flutter/wiki/Triage">Guidelines for triage</a>. Here’s how it works in practice:</p><p>An issue starts with you: a user of Flutter, or an open-source contributor. Once you file it (hopefully with a reproducible case if it’s a bug, or a clear outline of what you’re proposing and why, if it’s a feature request), it goes to <em>front-line triage</em>.</p><p>In front-line triage, a community participant — perhaps a volunteer, perhaps someone at Nevercode, or an engineer working on Flutter — examines the issue you’ve filed, and asks several questions:</p><ul><li>Is it clearly defined?</li><li>If a bug, does it have a reproducible case and enough to go on?</li><li>If a feature enhancement, do we understand enough about what you’re asking for so that we can gauge its contribution to the platform?</li><li>Does it duplicate a previously filed issue?</li></ul><p>As we do this, our front-line triage applies as many labels to the issue as we can. We use these labels in lots of ways, such as to establish relative priority, determine how to route an issue to a particular team, and whether to include the issue in an upcoming milestone. We use both GitHub queries and some custom tools to mine the issues for signals as to what the community is looking for and why.</p><p>From there, it goes to <em>secondary triage</em>, where an assigned team looks at the issue, and asks questions such as how the issue fits with the current work that they’re doing, and when they can schedule the work for completion. Again, more labels may be added or changed, as the labels provide us with the best possible snapshots as to the work we want to do and who can do the work.</p><p>Eventually, an engineer offers to work on the issue. Unlike many software projects, we generally don’t assign issues to contributors: whether a contributor works for Google or not, contributors offer to tackle issues, rather than get assigned issues from the backlog. By letting developers offer, we distribute load-balancing down to individual contributors; each contributor self-assigns only the issues they’re actively working on, and gives milestones to those issues so that we know when they’ll land on the master branch. Leads may ask particular people to work on issues, of course, but most of the time it’s just that: a request for help, not an ultimatum or an assignment.</p><p>Once an issue has been completed to our satisfaction, it is closed. Often this includes a link to the pull request addressing the issue, but there are other reasons we close issues, including:</p><ul><li>Is this a request for support? We direct the reporter to a support channel such as the <a href="/service/mailto:flutter-dev@googlegroups.com">flutter-dev@googlegroups.com</a> mailing list, the <a href="https://reddit.com/r/flutterdev">r/FlutterDev</a> Reddit, our Discord communities (<a href="https://discordapp.com/invite/N7Yshp4">user chat</a>, <a href="https://github.com/flutter/flutter/wiki/Chat">community chat</a> used primarily by contributors), or <a href="https://stackoverflow.com/tags/flutter">Stack Overflow</a>.</li><li>Is this a duplicate issue? Before closing, we link to the original issue, which also updates the original issue.</li><li>Does the issue have enough information to reproduce, and have we been able to reproduce it? If not, odds are that we can’t do anything and will close the issue.</li></ul><h3>Our Progress Thus Far</h3><p>As you can imagine, as our popularity has grown, so has the number of opened and closed issues for <a href="http://github.com/flutter/flutter">github.com/flutter/flutter</a> (this contains all issues except those for the web site, which are logged at <a href="http://github.com/flutter/website">github.com/flutter/website</a>):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/616/1*D_MCtnl2h_spFgoORikDcA.png" /><figcaption>Closed vs. open bugs for month-ends since Jan-2018</figcaption></figure><p>Equally exciting is the number of issues <em>not</em> bearing a label corresponding to one of our secondary triage teams, such as <a href="https://github.com/flutter/flutter/labels/framework">framework</a>, <a href="https://github.com/flutter/flutter/labels/engine">engine</a>, or <a href="https://github.com/flutter/flutter/labels/plugin">plugin</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/615/1*9ZXPKWTBT01b_6zsFtundg.png" /><figcaption>Issues not labeled for secondary triage, Mar-2019-present</figcaption></figure><p>You can clearly see where we started to engage Nevercode in our triage process, first in early September, with great progress by mid-September as they got up to speed.</p><p>This emphasis on triage reflects our goal: not to have zero <em>open</em> issues, but to have zero <em>unlabeled</em> issues to provide adequate signals from our community, so that we can best prioritize our work. As Flutter continues to grow in popularity, we expect to see continued growth in the number of open issues that require triage, many of which will be requests for new features from the community. We’ll continue to use labels to help us determine which are bugs that require immediate attention, which are bugs we can defer to our next beta or stable release, and which are new feature requests.</p><h3>How You Can Help</h3><p>You can help keep our issue database clean and tidy with actionable issues. When filing an issue, please consider the following :</p><ul><li>Don’t use GitHub for support. As part of our issue triage, we’re now closing requests for support that come up in GitHub, redirecting folks to better channels. In those channels you’ll likely find someone able to answer your question, and the questions and answers are easier for other users to find as well.</li><li>Help with reproducible cases: if it’s your own issue, make sure you have one. Even if it’s not your issue, we’ll gladly take reproducible cases from you, too! Writing reproducible cases for bugs is a great way to start learning how to use Flutter with real-world examples.</li><li>Update and upvote issues that are important to you.</li><li>Contribute test cases to the Flutter repository. This is another way to get your feet wet using Flutter and join the community. It also helps us prevent regressions: while all new code is accompanied by test cases, we strive to increase our test coverage as a matter of good practice. If you’re interested in contributing in this way, you can take a look at issues with the <a href="https://github.com/flutter/flutter/labels/a%3A%20tests">a: tests</a> label.</li><li>Consider helping us triage issues that others have filed.</li></ul><p>We’re deeply appreciative of the support and trust you’ve given us in investing your time and application ideas with Flutter. We welcome community involvement, whether it be filing a bug or feature you’d like to see addressed, or creating a pull request to make Flutter the platform you want to work with. Thank you!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fb3adab5e25" width="1" height="1" alt=""><hr><p><a href="https://blog.flutter.dev/https-medium-com-flutter-issues-bugs-and-backlogs-5fb3adab5e25">Issues, Bugs, and Backlogs</a> was originally published in <a href="https://blog.flutter.dev/">Flutter</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>