Oh, I can't NOT be involved in this! I just hope it fits around or my with schedule!

I just recorded a 3 hour ramble yesterday about the connections between living structure in the physical world, natural world (micro and macro), human world (e.g. businesses), and software; what that means and why it matters; how the failure to achieve it hurts society, the planet, and ends users; how it can be accomplished in software, and how doing so is central to the computer revolution that hasn't happened yet; etc.

... I'll need to trim it down or summarize it, but might not be able to do that during the work week.

(I'm technically still on leave from this community, but just happened to actually peek at the latest weekly email, and I saw this thread and just had to jump on, and this is a very specific opportunity I'm working to make a singular exception for ... Side note, making progress managing ADHD ... despite that one 3 hour recording 😅😬)

it'd be amazing to even just get access to the course materials or notes -- if there's any way to provide the community a data exhaust that would be truly grand

i feel like a lot of us participate asynchronously so any way to learn that's friendly to that would be 👌

dont let me oblige you to take a bunch of notes for us though 🙂

Stefan Lesser are you familiar with Sep Kamvar’s work? If you’re into Alexander, you might enjoy Sep’s Syntax and Sage (this https://farmerandfarmer.org/succession/syntax.html gives a flavor of it). He’s brought Alexander’s ideas to both software and to the design of his companies + learning communities (Celo, Wildflower, his research at MIT).

I’m interested 🙂

i’m interested!

Best (simple and meaningful) adaptation of Christopher Alexander to software I've come across yet! I'm now referring to that "production by the masses" page to sum up my FOC project

Anyone else doing anything similar to what any of these articles describe?

This sounds very tempting but days are still at 24 hours a piece... But I will watch this space for insights from thos who participate actively.

I just quickly wrote and published a draft inspired by a discussion in class yesterday. It's my own views and doesn't represent what we discussed. I thought I share it with you here as well. Sorry, it's rough and rushed, but I really wanted to get a first draft out quickly for comments and feedback — including yours. https://stefan-lesser.com/2020/10/27/how-to-adopt-christopher-alexanders-ideas-in-the-software-industry/

Thank you for starting this thread Stefan!

I only explicitly came across Alexander’s work relatively recently, through this community, but immediately resonated with much of the process he described of what it is to build something, and why we might do it. In my own work, I’ve naturally found myself drawn to an ‘unfolding’ approach, guided more by a sense of ‘wholeness’ than of any particular specifications. This has been in the context of working for a charitable community aiming to create ‘social spaces for social change’, with my role being to guide the creation of online spaces to complement physical spaces and activities.

I’ve just now enjoyed watching the introductory video from the publicly available webinar (https://www.buildingbeauty.org/nature-of-order-lecture-series) and was happy to see how much of the conversation centred on the interaction of ‘wholeness’ in what we build and ‘wholeness’ in ourselves and our social relations, given that this seems to me the deepest meaning his theory has, which can then be applied to specific fields such as architecture or software.

In my own work, trying to enable people to have as much agency in the creation of online spaces as they would with physical spaces, this led me on a long journey, culminating over the past couple of years in (rather accidentally) creating a programming language (https://maraca-lang.org/). Having now spent some time with this language, I would loosely describe it as a language for defining living/dynamic structure (the motivating example being a dynamic web page/app), in a way that feels at some level a little like sculpting clay, or other similar ‘unfolding’ acts of creation.

Similar it seems to Alexander and architecture, I haven’t found it easy to align with the general world of IT/tech, meaning much of this has been rather solo work, and can be challenging to articulate, so I’m looking forward to discussing these themes with others 🙂

I'm a big fan of Alexander's work to the point of collecting at one point every image i could find of buildings he designed. He wrote a forward for Richard Gabriel's book Patterns of Software. People interested in this thread may want to check it out. https://www.amazon.com/Patterns-Software-Tales-Community/dp/0195121236

Your post remind me of one of my favorites quotes from How buildings learn:

What makes a building learn is physical involvement by the people inside.

@larry Here's his address to the software community, in which he declares that he's got something more to offer/ask than what he did in the forward to RPG's book: https://youtu.be/98LdFA-_zfA

Stefan Lesser

1. Your last paragraph really resonated with me as being what software really is / can be, as a medium.

2. Design Patterns in software are actually a horrific failure of an attempt to capture what Pattern Languages in architecture were fundamentally about. I'll explain:

Design Patterns (if software was a building) are more like solving very particular (and invented) problems with the electrical wiring or plumbing, or building a wall with a limited supply of wood beams, etc. Nevermind why the building is being created in the first place (e.g. as a place to live, and therefore as a good place to live).

Pattern Languages are about shaping (and solving problems for) the human space within it. For example, an http://naturalhomes.org/pattern-112.htm transition because "the experience you get leaving and entering your home influences the way you feel inside it". Nevermind how it's otherwise literally constructed.

I think Christopher Alexander's work is about about understanding a thing not in terms of the thing itself, but of the environment that it creates for those using or inhabiting it.

A building (as a place) is not the building, it's the human space in between. A software application is not a framework of code or services, but the experience it creates for, say, booking a trip.

Even words used to describe software take on new meaning if thought of this way: robust, elegant, connected, intelligent, clean, efficient, flexible, adaptable, innovative, disruptive, functional, dynamic, correct, agile, powerful, "best practices", etc.

Some things are for looking at and some are for using.

@Dan Cook I always thought it was odd that design patterns caught on for software 'internals' but not for software user interfaces. One of Alexander's quotes - might be from "The Timeless Way of Building" - was something like "the character of a place is given to it by the things that happen there over and over again." It's something I've thought about a lot when working on interfaces.

@Jon Whitehead amazing to see the progress you’ve made on maraca’s documentation since you first shared it! great work!

@larry I'd say that software didn't even get the internals part right. If the human model is only reflected on the outside, then it's just an https://youtu.be/NAjz0INs3Lc?t=12m14s -- and not just in some idealistic sense: the software will behave in ways that are inconsistent with what it presents itself as, because it is NOT what it presents itself as. Try dragging or copy-pasting various things around in many document editors, and you'll see what I mean.

Conversely, software that does match (or is shaped by) the human model, can be broken down into (and understood in terms of) the same pieces that the human model can be broken down into and understood in terms of. (Every function, variable, expression, etc. forms either a direct part of that model, or a basis upon which to construct it). Think about it: The behavior of software is what happens when you use it and the code that makes it do that!

You see a similar contrast if you compare Bob Martin's "Screaming Architecture" to "Execution in the kingdom of nouns"

@Dan Cook i’m just getting a mobile game company when i google “screaming software”—do you happen to have a link or author name?

I edited my previous response to include it (among other things)

oh i do know that concept—thank you!

This is isn't directly related to architecture, but the laws of pattern discussed by this physicist do provide incredible insight to the similarities between nature and woman-made constructs.

https://www.amazon.ca/Scale-Universal-Growth-Organisms-Companies/dp/014311090X/ref=asc_df_014311090X/?tag=googleshopc0c-20&linkCode=df0&hvadid=296035595995&hvpos=&hvnetw=g&hvrand=18027496144629556268&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9001314&hvtargid=pla-453988306758&psc=1

might be enough for npm

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"

Christopher Galtenberg check out the Tilde movement if you haven't already: https://medium.com/message/tilde-club-i-had-a-couple-drinks-and-woke-up-with-1-000-nerds-a8904f0a2ebf

I'm on http://tilde.club and a couple of others. It's particularly nice for trying out new and strange OSs. For example, https://tilde.institute has several Plan 9 tools installed (though more can be done here to give people a portal into an alternate universe).

Hest

Mariano Guerra first thought that comes to mind: you'd need a lot more attention to sandboxing, just because you'd be likely to be running a lot more heterogeneous software on such a machine.

Sandboxing in particular is something the current stack is abysmal at.

Kartik Agaram makes a good point as that one rouge process breaks the window server. With silly resources, I would try to adopt designs that perform extensive speculative execution. For example, the web browser fetches and renders all the links so that when I finally click on one, it's already ready. Sandbox becomes more important so as to model destructive possibile futures. Assuming this fantasy setup doesn't have a magically fast clock, we only get a benefit from parallel execution. The programmers are never going to have time to write stuff to run well in parallel, so instead of twiddling its thumbs, I'd have the system proactively test rewrites. Amounts to a machine that perpetually asks itself, "why am I so slow?"

actor systems with message passing and lightweight processes like the erlang vm take advantage of the extra cores for free

Erlang would indeed be suited to 1024 cores. I don't know enough about it to comment on the RAM/disk specs..

each process has its own heap and garbage collection, so it should scale there too

Whatever I do, would probably use Rust for that

how much cache on that computer? and what do the cores look like? Small out of order cores with lots of SIMD units? cell style spus? something weirder? I'm assuming they probably look like "regular" CPU cores in a modern x86 or ARM CPU

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

Guys invent something new with your mind, that's the invitation on this thread

i think the first question for me is "what would you do with that machine that you can't do with the one in front of you?" Analyzing DNA would be a nice fit. Since this is a fantasy, i would attach one machine directly to each sequencer rather than sending data over the net. Now i could start to think about what that language might look like.

If processors were as "free", then they could be allocated like memory. Each object gets its own brain, and can spawn others.

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

Follow-up question for Mariano Guerra after reading @Dan Cook's response: do we care about carbon footprint? Social assumptions make a big difference to the answers here.

@Dan Cook Have you heard of the Rekursiv project? I recommend trying to track down a used copy of the book.

Will do!

"The last known copy of a Rekursiv computer ended up at the bottom of the Forth and Clyde canal in Glasgow." - Things sometimes do not go as planned. I have heard of this project before and was very interested in it but then life took on. Thanks @Eric Gade will look at it again

@Dan Cook sounds a little bit like the propagator from sussman: https://www.youtube.com/watch?v=Rk76BurH384

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

@Dan Cook I share your views here. It is good to have you back! ☺ Or you are not really back, but you can't help but answer this very interesting question!? 😅

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.

@Dan Cook and Nicolas Decoster these both sound very similar to what I’m working on. A visual/notebook based purely functional programming development environment with live data and time traveling for both previous inputs and each step of a run that uses CRDTs for collaboration.

Seeing it on this thread has me worried that this may be pushing the limits too much for what’s currently feasible?

I’m using Rust targeting wasm in browser. Is this possible now? Do I need this beast machine to make that happen?

From my understanding, one pain point with CRDT is rebuilding state from a very huge history logs. With a beast machine the problem will arise later.

But depending on your real use case, I guess it can work right know. And there are some strategy to mitigate this.

Maybe you already know his work, but here is a video by Martin Kleppman talking about the "hard parts": https://www.youtube.com/watch?v=PMVBuMK_pJY

Yeah, Nicolas Decoster scaling over time/a large history is definitely a challenge in CRDTs from what I’ve gathered, both on playing catchup if you’re say a year behind and for just loading all of that into working memory even if have an up to date local copy.

I really appreciate you pointing me towards Martin Kleppman! I’ve been looking into his work, and I’m on the Automerge slack channel and I may get involved in their Rust port implementation.

I’ll have to check this video of his out 😄