Re: [vibration] Update implementation report (#33)

I want to bring to this discussion the following consideration. Perhaps @cwilso and the AB folks have already discussed this, in which case I'm happy to redirect this to a more appropriate place. This comment was inspired by @saschanaz's important question on what is an independent implementation.

Also, hopefully piggy-packing on this issue doesn't offend anyone. This case at hand just happens to make this consideration more concrete. Let's go:

For certain hardware-centric features, the majority of the implementation (say, in terms of lines of code, or in terms of complexity) is on the layers below the rendering engine. Think of this stack: application, middleware, libraries, OS drivers, OS kernel, OS HAL, firmware and hardware. To simplify, rendering engine is the application, the topmost layer. This topmost layer can be a thin wrapper from a perspective of a particular hardware feature. On all of these layers we can find independent implementations. However, when working on software only features (things we can test end-to-end without specific hardware), we are used to look for independent implementations on the topmost layer only.

After reading the [implementation experience](https://www.w3.org/2023/Process-20231103/#implementation-experience) definition and the latest AB discussion https://github.com/w3c/AB-public/issues/120 I'm wondering whether the independence of the layers below the topmost layer is a more substantial consideration for hardware-centric features? What if the topmost layer is the same, while all the layers underneath have multiple independent implementations, and we can demonstrate interoperability? What if we flip this: the topmost layer has independent implementations, but the layers below that, that make up the majority of the implementation, are the same?

To make the latter case more concrete, an interesting case study is the WebRTC API. For that API, there are multiple independent rendering engine implementations, but all are using the same open-source library underneath that is the largest part of all the end-to-end implementation. This specification is a Recommendation so it has passed the implementation experience test. Does the same hold if we have the same topmost layer, but demonstrate independence on the layers below, including interoperability?

I was unable to find a good answer to @saschanaz's question. That started to bug me, so I wanted to share this thought. Perhaps the answer is this will be considered on a case by case basis. Thanks for reading.

-- 
GitHub Notification of comment by anssiko
Please view or discuss this issue at https://github.com/w3c/vibration/issues/33#issuecomment-2153028679 using your GitHub account


-- 
Sent via github-notify-ml as configured in https://github.com/w3c/github-notify-ml-config

Received on Thursday, 6 June 2024 17:15:00 UTC