How would you rebuild software from the ground up?

The ultimate goal is omniscience and omnipotence. If you had that, you wouldn't need software. Software should serve to eliminate the delta between "I want pizza" and "I have pizza".

Humans have physical limitations. They can't be everywhere at once. There's a limit to amount of information they can learn and process. They can't focus on multiple things at once. They need to offload most of these responsibilities to others (whether humans or machines).

Omniscience is the first thing we should tackle. We must capture, process, organize and store the world's knowledge. We can't continue having each company/service/app store knowledge in their own format on their own servers. We need to distribute knowledge in a standard format, that can be consumed and created by anyone. I believe the semantic web was on the right track, and we should push these ideas forward.

Once there's only one knowledge repository, it's trivial to program IoT devices to broadcast all their sensor data in that format.

Omnipotence starts with the formulation of intent. First, we observe the world for problems. Once we identify a problem, we pick an alternative reality that doesn't have that problem. Ultimately, intent is the communication of a future state of reality (ideality), and is represented and stored exactly like the knowledge mentioned previously.

At this point, we have a knowledge base full of data about the real and the ideal. The last step is to bridge that gap, and make the real become the ideal. For that, we need smart contracts, the union of multiple ideals. These contracts can involve other humans, or be automated by involving robots. Resources, whether humans or machines, are defined by the set of all futures they can make happen. For example, a Uber driver is defined by its ability to take you from a continuous set of location A to a continuous set of location B.

Before we rebuild the entire software stack from the ground up, we need to figure out how knowledge will be represented, how smart contracts will work, and what the interface will be like.

The solution will likely implement ideas from:

- AI

- ML

- AR

- VR

- Semantic web

- Datalog/Prolog/Mercury

- Idris/Agda/Coq

- Eve

- lojban

- GTD

- Akinator

- Tinder

- Google Wave

- Google Lens

- Google Inbox

- Google Freebase

- webOS "Just type"

- Apple Watch Time Travel

- Pebble Timeline OS

- Amazon Firefly

- Mechanical turk

- Smart contracts

- Google/Siri/Alexa/Cortana/Bixby

- Messaging bots

- IPFS

- Ethereum

- Bitcoin

- Blockchain

- Edge computing

- WeChat

- Urbit

- Naked Objects

- Squeak/Smalltalk

- 5th generation computing

- Cycorp Cyc

- Homotopy Type Theory

- Xanadu

- React/Redux/Relay/GraphQL

- OpenID

1) To me, security goes hand in hand with your point on mental models. It's hard enough to imagine how a bad actor might abuse a simple system you know well. Scale that up to a complicated system that no one understands and you've got a real problem.

2) Absolutely. For one, I'd want UI separated from data and logic such that you can easily tie programs together Unix-style.

Today, programs have a hard time interfacing with each other. And portability is nasty too. Maybe we could make the _ideas_ behind a program portable?

People quote “Programs must be written for people to read, and only incidentally for machines to execute.” But has this ever really been true? Take any function in your codebase and imagine you were asked to explain it to a friend. Does what's written out in code resemble even remotely what you'd say to them, draw out, or demonstrate? If the representation were good enough, you could just lift out the key idea and add it to your program.

3) I've used LabView a little, and it does kind of suck. Probably because they focused on making the logic itself be visual. When I think about merge sort, I "see" the recursion and merges, with chunks of the list flying around as the stages unfold. I don't see a flow chart or a circuit diagram. I'd bet most people do something similar.

Really, code is a pretty reasonable way to write out program logic. What we're missing is that visual intuition behind it, that mental model we force people to build up imperfectly.

But the web becoming a dominant, near universal platform gives us the ability to experiment with all of these. Just not in the way you'd imagine.

We have the ability to create unique, experimental personal computing models now that will be immediately useful if they fulfill one requirement: they have a functioning, standards compliant web browser (with TCP/IP and all that's needed). If you only have this requirement, then there's a lot of freedom.

Imagine a computer designed specifically for the "operating system" that hosts it (kind of like we used to have back in the days of diversity). I put that in quotes because it could be something LISP or Smalltalk-like, where the language is itself the "operating system." So long as such a thing came with a web browser (and I know it's a big task), it would be immediately useful and usable for most people. That means potential for wide adoption.

A platform like this could then give rise to the "after-web". If the system was an object/actor one, people who had these platforms would inevitably decompose the objects/actors that comprise the built in web browser, pulling them out and giving them additional functionality within the confines of their own systems. Eventually, people would network only these objects with each other. Some standard might emerge from this, and we could have a true network of interacting objects.

Of course, these computers don't have to have text-based languages or anything else. They just have to have a web browser somewhere inside of them. That's what I see as the real promise of the web: it's now universal presence and adoption is the gateway towards the thing that can replace it. But in order to do so we need to re-think personal computing in total.