A big data notebook comes to mind, still not much different UX-wise, just happens to have a supercomputer under the hood But I'd love to see a visualization of how the machine performs the operations I've sent it, so that I can see bottlenecks and really build up an effective processing pipeline through the notebook

A different idea: I'd love an environment where I could share pieces and say to friends "this could be your server", whether for discourse, for solid, as a file share, etc - just a fun way to say "let's share this big machine in ways that people have typically needed a server in the past"

also 1 PB disk, 1 PB SSD?

I like the idea of a message passing erlang style environment, also maybe more of a GPU style programming environment that's SPMD, maybe they communicate by writing to a shared L2 cache that is functionally similar to group shared memory

with explicit barriers

If I had a very different new architecture, I'd model objects (lists and key-value stores) (and single values) directly in the hardware. The links between object references would be literal (conceptually, if not actually). Garbage collection would automatic, as each "object" cell would constantly propagate an "alive" signal (bit) to whatever it references. The moment an object is not connected to another "alive" object, it frees itself to be reallocated. There is no way to reference an object by "address"; only by following a link from an object you already have a reference to. In theory, if the instruction set was very small (e.g. all the operations for manipulating these objects and primitive values), then each "memory cell" would have it's own little processor, and correspond to one object (conceptually, if not actually). With this model, a computer can be more like fabric, and objects and processes can just "walk" it, like entities in the game of life. They could transfer from one environment to another so long add there was a connection, just like you'd transfer around objects in the physical world.

Or perhaps a similar but different idea: If you model code as a DAG, and it's pure-functional, and the dependencies from one expression to the next were all represented physically, then changing a value upstream would cause everything downstream of it to recompute itself automatically. The only processing effort is that each is constantly outputting some function of its inputs. I guess it's like digital circuitry, but at a higher level, and dynamically allocatable at runtime

If that's all outside the limitations of the question, then I'd use that computer to simulate / POC systems like the ones I've just described

@Kartik Agaram as much as the society at that point in time

I guess the intent of the question was what to design if the resources availability is not a problem. Either it is not a problem to have any amount of resources (RAM, disk, number of cores but other kinds too, more about it below) and the environment and societal impact is low. On the resource side, first I would add other kind of resources. Mainly interface resources. I.e. the computer has advanced HCI system. Not only mouse and keyboard but as much cameras and sensors needed to have better interactivity and help make it more tangible. As, for example, one where it is fast and easy to capture hand gestures. Then, I would consider that people that have to collaborate with the language/environment, and that are not in front of the same computer, all have powerful computers that are all efficiently connected. So I will answer on that basis!

The environment will use CRDT like technology that construct the state of the system from its history. So the entire multiuser history is stored. Of course the programming/editing history, but also the executing history. Or some part of it, leaving aside what is still too resource intensive (like complex video playing/processing maybe) and less "useful". In fact, in that kind of system the boundary between programming/editing and executing is blurred. In that environment, there is a focus on making things as tangible as possible. I.e. your programming artifacts are alive, you can see them and manipulate them interactively. Some might not be possible to be really alive and tangible, but in that case everything is done to simulate them as realistically as possible. For example, if you are designing a complex infrastructure architecture, it is not always possible to make it tangible, in that case there is some simulation of it, so, as much as possible, things can be "tangibly" designed before making them concrete. So I guess, part of the environment, there must be a serious and flexible "simulator" facility. With the system being aware between what is really tangible/moldable and what is just simulated and needs to be brought to life at some other time.