New chat

TODO: collapasable, copyable, download, etc

Why don’t websites and js libraries expose protobufs?When discussing why websites and JavaScript libraries don't frequently expose Protocol Buffers (protobufs), there are several reasons to consider:

1. Complexity for Web Browsers: Protocol Buffers are a binary serialization format. Web browsers and the web at large have historically been built around text-based formats like XML and JSON. This makes handling binary formats slightly more complex on the web.

2. Ubiquity of JSON: JSON (JavaScript Object Notation) is deeply integrated into JavaScript and has been the de facto standard for web-based APIs for a long time. It's lightweight, easy to read, and works seamlessly with JavaScript, making it a natural choice for web developers.

3. Human-Readability: JSON is text-based and can be easily read by humans, whereas protobuf is a binary format and is not human-readable. This makes debugging and ad-hoc testing of APIs more challenging when using protobuf.

4. Tooling: Most browsers and developer tools have built-in support for viewing and debugging JSON. Protobuf would require additional tooling or plugins to achieve similar functionality.

5. Client Support: If a website or service exposed data in protobuf format, every client (browser, mobile app, etc.) would need to have a protobuf decoder to understand it. With JSON, decoding is built into almost every modern programming language out of the box.

6. Size Overhead: While protobuf can be more compact than JSON, for many web applications, the size difference doesn't justify the increased complexity of implementing protobuf.

7. Evolution and Compatibility: Protobuf requires schemas to define message formats. Changes in schemas need to be carefully managed to ensure backward and forward compatibility. With JSON, schemas are often implicit, allowing for more flexibility (though potentially less rigor) in evolving data formats.

8. Limited Libraries: While there are protobuf libraries for many languages, the ecosystem around JSON is simply more mature, with countless tools, libraries, and utilities available for handling, transforming, and visualizing JSON data.

That said, in specific contexts where performance and data size are critical (like in some high-performance backend systems, microservices communication, or IoT devices), protobuf can be beneficial. However, for public-facing websites and most JS libraries, the convenience and familiarity of JSON generally outweigh the benefits of protobuf.Could you build an iOS app that can rearrange app icons on the home screen? Is there an APzi for that?No, as of my last update in January 2022, iOS does not provide an API that allows third-party apps to programmatically rearrange app icons on the home screen. Apple has strict guidelines around user privacy, system integrity, and user experience, and allowing third-party apps to change the home screen layout without explicit user action could be potentially disruptive and intrusive.

If you want to rearrange your app icons:

1. Manual Rearrangement: Users can tap and hold an app icon until it starts to jiggle, then drag it to its desired position.

2. Using Shortcuts: The "Add to Home Screen" action in the Shortcuts app lets you create custom icons that link to various actions or apps. This provides some flexibility in designing a custom look, but it's not the same as directly rearranging actual app icons.

3. Using Widget Apps: With the introduction of iOS 14, Apple introduced home screen widgets. This has led to a surge in third-party apps offering customizable widgets to further personalize the iOS home screen.

Remember that Apple's guidelines and API offerings can change, so always refer to Apple's official developer documentation or check the App Store Review Guidelines to get the most recent and accurate information.Could a widget app discover and display app icons ?As of my last update in January 2022, an iOS widget cannot directly discover and display other app icons on the device. Apple's privacy and sandboxing policies prevent apps (and their widgets) from accessing information about other apps installed on the device, unless explicit mechanisms are provided by Apple.

However, there are some workarounds that developers use to give a semblance of this functionality:

1. User Input: An app could ask users to select from a list of popular apps and then display the associated icons, which the developer has bundled within their app. This method doesn't "discover" the apps but relies on user input to display a predefined set of icons.

2. Open URL Schemes: While you can't discover apps directly, some apps support URL schemes that allow other apps to open them. A widget could provide functionality where tapping on an icon opens a specific app via its URL scheme. However, this again requires the user to manually configure which apps they want to open using the widget, and not all apps support URL schemes.

It's important to note that any approach that tries to mimic or recreate Apple's native home screen behavior could face scrutiny during the App Store review process. Always ensure that any app or widget adheres to Apple's App Store Review Guidelines to prevent potential rejections.

For the most recent and accurate information, it's best to refer to Apple's official developer documentation or the App Store Review Guidelines.

New chat created at Tue Jan 20 1970 15:05:58 GMT+0000 (Coordinated Universal Time)