miguelrochefort

I have thousands of online accounts, hundreds of thousands of saved items (likes, bookmarks, papers, books, movies, videos, photos, files, open tabs, tasks), hundreds of inbox and feeds, and they just can't seem to stop growing.

Inbox zero is now a rare occurrence, only made possible by abusing Gmail's snooze function. My phone, laptop, and clouds are full.

Using personal finance analogies, should I:

- Reduce my spending (unsubscribe, stop consuming feeds)?

- Pay back my debt (consume the saved items)? Perhaps using the debt-snowball method?

- Get more credit (file storage) so that I can spend (save items) more?

- Declare bankruptcy (delete everything)?

Apps are skeuomorphic. They typically represent real-world objects or concepts.

For example, these are all the apps pre-installed on iOS:

- App Store: Software retailer

- Books: Book

- Calculator: Calculator

- Calendar: Calendar

- Camera: Camera

- Clock: Clock

- Compass: Compass

- Contacts: Rolodex

- FaceTime: Face-to-face interaction

- Files: Filing cabinet

- Find My: ?

- Fitness: Workout log

- Flashlight: Flashlight

- Health: Health record

- Home: Home

- iTunes Store: Music retailer

- Mail: Mail

- Maps: Maps

- Measure: Tape measure

- Messages: SMS

- Music: Music player

- News: Newspaper

- Notes: Notebook

- Phone: Telephone

- Photos: Picture

- Podcasts: Radio

- Reminders: To-do list

- Safari: ?

- Settings: Buttons, switches, sliders, knobs

- Shortcuts: ?

- Stocks: Newspaper

- Tips: User guide

- Translate: Bilingual dictionary

- TV: Television

- Voice Memos: Tape recorder

- Wallet: Wallet

Although the one-to-one equivalence between real-world concepts and apps may seem intuitive to those who have experienced the former (older generations), they appear completely arbitrary to those who haven't (newer generations). Keep in mind that most kids have no idea that the save symbol represents a floppy disk.

Unfortunately, such short-sighted design decisions often remain unchallenged. For instance, most people never asked themselves why we ended up with the arguably inferior QWERTY keyboard layout. Likewise, most of us have accepted the arbitrary boundaries we set between apps.

What if this skeuomorphic way of thinking had wider implications than simply facilitating the transition from the analog to the digital world? What if the very idea of apps was the single biggest mistake in the field of software design? How powerful would software be if we directly interacted with data in a general purpose way, rather than being constrained by the limitations of real-world objects in a domain specific way?

Let's imagine you're building a company that intends to compete with FAANG.

Your company will be expected to have most of these:

* AI Research Lab (FAIR, Brain, MLR, Research)

* ML Framework (PyTorch, TensorFlow, CNTK, Core ML)

* Web Framework (React, Angular, Blazor)

* Browser (Chrome, Safari, Edge)

* Smart Speaker (Nest, HomePod, Echo)

* Smartphone (iPhone, Pixel, Galaxy, Fire Phone, Lumia)

* VC Fund (GV, M12, Apple, Alexa Fund)

* Virtual Assistant (Siri, Alexa, Assistant, Bixsby, Cortana)

* Personal Cloud Storage (iCloud, Drive, OneDrive)

* Typeface (Roboto, San Francisco, Segoe)

* Personal Video Chat (FaceTime, Duo, Skype, Messenger)

* Work Video Chat (Meet, Teams, Chime)

* Personal Chat (iMessage, Hangouts, Skype, Messenger, WhatsApp)

* Chip (Silicon, Tensor, Pluton, Graviton)

* App Store (App Store, Play Store, Microsoft Store)

* IDE (Visual Studio, Android Studio, Xcode, Cloud9, Nuclide)

* Search (Google, Bing)

* True Wireless Earbuds (AirPods, Pixel Buds, Galaxy Buds, Echo Buds, Surface Buds)

* Email (Gmail, Outlook)

* Programming Language (C#, Swift, Go, Hack)

* In-Car Entertainment (CarPlay, Android Auto)

* Design (Human Interface Guidelines, Material, Fluent)

* Maps (Google Maps, Bing Maps, Apple Maps)

* Notebook Hardware (MacBook, Surface, Pixel Book, Galaxy Book)

* Desktop OS (Windows, macOS, Chrome OS, DeX)

* Wearable (Apple Watch, Pixel Watch, Samsung Watch, Halo, Band)

* Health (Apple Health, Google Fit, Samsung Health, HealthVault, Halo)

* Smart TV (Apple TV, Chromecast, Fire TV)

* Office Productivity (Office, Docs, iWork)

* and much more...

Some of these are easy to reproduce, through licensing, partnerships, acquisitions, reverse-engineering, or open source forking. For example, it is possible for small companies to design their own typeface, white-label their brand of true wireless earbuds, or develop a basic chat application.

On the other hand, some are incredibly difficult to reproduce, due to network effect, lack of data, or R&D costs. For example, designing your own chip, developing your own office productivity suite, obtaining movie streaming rights from all major film producers, or building a digital map of all the streets in the world, might only be achievable by a handful of tech giants. As such, these would be considered to be some of tech's largest moats.

What are some of the largest moats in tech? Are there technologies out there that a company with 5 billion dollar and 5 years would struggle to replicate?

There exists a lot of high-quality UI component libraries such as MUI, Bootstrap, ANT, Grommet, Chakra, Semantic UI, etc. These components typically map to primitive types:

    boolean -> checkbox / toggle button / visibility
    integer -> numeric input / slider
    enum -> drop down menu / radio buttons
    string -> text field
    date -> date picker
    array -> list view
    matrix -> table view
    bitmap -> image
    async promise -> loading indicator
    side effect -> button

But what about higher-level types, classes, and schemas? Where can I find UI components that map to a person, a place, an event, a product, a transaction, a movie, an album, a book, an article, or a comment? Shouldn't higher-level UI components exist for popular ontologies such as Schema.org? It seems absurd to manually reimplement these templates in every project, yet I can't seem to find any comprehensive library of such components.

Have I been searching in the wrong place or do such higher-level UI component libraries actually don't exist?