JAXenter: Progressive Enhancement is something you hear quite often in the context of PWA. What exactly is it referring to?
Thomas Steiner: Back in March 2003, Nick Finck and Steven Champeon stunned the web design world with the concept of progressive enhancement:
“Rather than hoping for graceful degradation, [progressive enhancement] builds documents for the least capable or differently capable devices first, then moves on to enhance those documents with separate logic for presentation, in ways that don’t place an undue burden on baseline devices but which allow a richer experience for those users with modern graphical browser software.”
While in 2003, progressive enhancement was mostly about using presentational features like at the time modern CSS properties, unobtrusive JavaScript for improved usability, and even nowadays basic things like Scalable Vector Graphics; I see progressive enhancement in 2020 as being about using new functional browser capabilities.
SEE ALSO: Python web framework JustPy – interactive websites without JavaScript
JAXenter: Project Fugu is a major player in the development of a PWA standard. What is that, who is behind it?
Thomas Steiner: The Capabilities Project (or Project Fugu) aims to bridge what we call the app gap: We want to enable the web to access native app capabilities without having to compromise user security, privacy, or trust, or having to package entire app runtimes. Giving developers these new tools will empower the open web as a place where almost any experience can be created, and make it a first-class platform for developing apps that run on any browser, with any operating system, and on any device. We design and develop these new capabilities in an open and transparent way in the W3C’s Web Incubator Community Group (WICG) using the existing open web platform standards processes while getting early feedback from developers and other browser vendors as we iterate on the design of these features to ensure its interoperability.
This work is a cross-company effort, with contributors from Google, Microsoft, and Intel. The monthly meetings are open to active contributors and have shared notes, accessible to anyone in the Chromium organization.
JAXenter: How are new APIs developed at Project Fugu?
Thomas Steiner: We have identified and prioritized an initial set of capabilities we heard partner demand for and that we see as critical to closing the gap between web and native. People interested in the list can review it by searching the Chromium bug database for bugs that are tagged with the label proj-fugu. Regarding the project’s code name: Fugu is a pufferfish that is considered a delicacy, however, if not carefully prepared, it can be lethally poisonous. This analogy works quite well with many of the capabilities we deal with.
We have developed a process to make it possible to design and develop new web platform capabilities that meet the needs of developers quickly, in the open, and most importantly, without moving feature development outside the standards process.
(1) Identify the developer need:
The first step is to identify and understand the developer’s needs. How are they doing it today? And what and whose problems or frustrations are fixed by this new capability?
Typically, these come in as feature requests from developers, frequently via bugs filed on bugs.chromium.org.
(2) Create an explainer:
After identifying the need for a new capability, create an explainer, essentially a design document that is meant to explain the problem, along with sample code showing how the API might work. The explainer is a living document that will go through heavy iteration as the new capability evolves.
(3) Get feedback and iterate on the explainer:
Once the explainer has a reasonable level of clarity, it is time to publicize it, to solicit feedback, and iterate on the design. This is an opportunity to verify the new capability meets the needs of developers and works as expected and to gather public support and verify that there really is a need for this.
(4) Move the design to a specification and iterate:
Once the explainer is in a good state, the design work transitions into a formal specification, working with developers and other browser vendors to iterate and improve on the design. Once the design starts to stabilize, we use an origin trial to begin prototyping and to experiment with the implementation. Origin trials allow developers to try new features with real users, and give feedback on the implementation.
(5) Ship it:
Finally, once the origin trial is complete, the spec is mature, and all of the other launch steps have been completed, it is time to ship it to stable. We still iterate with other implementations and developers to refine the spec, explore improvements and fixes to the design with other vendors, and work toward promoting the spec to a formal standard. Note, many ideas never make it past an explainer or origin trial stage. Not shipping a feature because it does not solve the developer’s need is fine. Key milestones here are formalized with public discussion and approvals via Chromium’s API launch process.
Source: https://github.com/tomayac/from-fugu-with-love/blob/master/fugu.pdf
JAXenter: Which feature would you like to see in a PWA standard supported by all browsers?
Thomas Steiner: If I had one wish, it would be everything we have on our API tracker. If I had to pick one, I really like the Native File System API, since it opens truly new possibilities for app developers, but I don’t want to stop there.
SEE ALSO: WebAR: The augmented reality for your browser
JAXenter: There seem to be some challenges in getting such standards supported by all major browser vendors. Why is that?
Thomas Steiner: Feature support for core JavaScript language features by major browsers is great. Kangax’s ECMAScript 2016+ compatibility table is almost all green, and browser vendors generally agree and are quick to implement. In contrast, there is less agreement on what we colloquially call Fugu features. 
To get an impression of the debate around these features when it comes to the different browser vendors, I recommend reading the discussions around the request for a WebKit position on Web NFC or the request for a Mozilla position on screen Wake Lock (both discussions contain links to the particular specs in question). In some cases, the result of these positioning threads might be a “we agree to disagree”. And that’s fine.
JAXenter: Is there any advice you can give to developers who want to start working on their first PWA?
Thomas Steiner: If this is your first time working with PWAs, make sure you understand the service worker’s lifecycle. We have a great codelab that covers all the details. For Fugu features, my tip is to file feedback early. If something seems weird, don’t hesitate to reach out via GitHub or even just by pinging me, I’m happy to relay your feedback. Also always try your app on real devices and real browsers, don’t just simulate a mobile device with DevTools. And finally: really internalize progressive enhancement and enjoy hacking.
The post Project Fugu interview: Bridging the app gap appeared first on JAXenter.
Source : JAXenter
