To be clear the lack of “shared” dependencies does not necessitate code duplication. By shared dependencies I’m talking about languages (Haskell for example) where only one version of a library can be used, which results in the diamond dependency problem (predictably so!).

Let’s say file A references file B and C, and files B and C both reference D. D doesn’t need to be duplicated.

If all includes are qualified/namespaced there is no diamond dependency problem, and the compiler/runtime can reuse the same code for multiple references to the same file.

I guess you wouldn't be able to use it to build a machine that is supposed to display Pi or Fibinocci?

No modules / namespaced includes means that to include other code, you would write something like `include as Foo './other-source-code.file'` or `include as Bar 'github.com/foo/bar/some/source.file@commit`. All the names in the included file (functions, names of data, etc.) would be referenced by prefixing the namespace, like `Foo.baz` or `Bar.baz`. Combine that with the ability to include code via URL, and there would be need for a package manager or separate package manifest. Wherever you want to use the new version/code you simply update the include statement at the top of the file.

This can be completely transparent to the user. There's no need to have a separate program do dependency resolution when dependencies are referenced in source code. Instead we have the complete waste of life that is package manifests and shared libraries.

- No linters. Code is auto-formatted.

- No modules. Includes can be namespaced/aliased.

- No package manager. Include by Git URL with tags.

- No type annotations. Automatic type-checking.

- No user-defined types. A few good types is better.

- No null. Set membership with maps is better.

- No exceptions.

- No loops. List and map comprehensions.

- No general recusion. Only tractable transitive closures (ala Datalog).

- No higher-order functions.

- Terminating. All programs terminate. Turing completeness is not desirable for most domains, but predictable semantics is.

- Safe. No undefined behavior. No crashes.

- Persistent, the runtime is also the database. The language is the database.

I'm working on a language with exactly this set of features. Email me if you're interested.

https://support.apple.com/en-gb/guide/security/sec0a319b35f/...

Outside of using Tor and your own VPN, it looks like Safari w/ iCloud+ protects browsing history from everyone (Apple and ISPs) while delivering a seamless experience.

https://support.apple.com/en-us/HT202303

And Apple provides iCloud+ members with a VPN which does not tie browsing history to users by separating ingress and egress traffic and using encrypted forwarding (similar to onion routing): https://www.apple.com/privacy/docs/iCloud_Private_Relay_Over...