This video (from 2019) has some very interesting “what if’s” https://youtu.be/9CSjlZeqKOc?t=819
That was AMAZING. I can’t believe I haven’t run into this video in 6 years.
2 Likes
The Web That Wasn’t: Forgotten Forebears of the Internet
For most of us who work on the Internet, the Web is all we have ever really known. It’s almost impossible to imagine a world without browsers, URLs and HTTP. But in the years leading up to Tim Berners-Lee’s world-changing invention, a few visionary information scientists were exploring alternative systems that often bore little resemblance to the Web as we know it today. In this presentation, author and information architect Alex Wright will explore the heritage of these almost-forgotten systems in search of promising ideas left by the historical wayside.
The presentation will focus on the pioneering work of Paul Otlet, Vannevar Bush, and Doug Engelbart, forebears of the 1960s and 1970s like Ted Nelson, Andries van Dam, and the Xerox PARC team, and more recent forays like Brown’s Intermedia system. We’ll trace the heritage of these systems and the solutions they suggest to present day Web quandaries, in hopes of finding clues to the future in the recent technological past.
Speaker: Alex Wright is an information architect at the New York Times and the author of Glut: Mastering Information Through the Ages. Previously, Alex has led projects for The Long Now Foundation, California Digital Library, Harvard University, IBM, Microsoft, Rollyo and Sun Microsystems, among others.
1 Like
Karl Marx famously wrote that
“The philosophers have only interpreted the world, in various ways. The point, however, is to change it.”
In the same way, the meaning of information and what is important depends on the context and the governing that needs to be performed In order to have a change.
Thus we cannot have a single interface to information and to modes of control. It is important to start by defining the context first, and then adapting the tools to that context.
Example : Dynamicland decided to build local tools around a community and consciously avoided their distribution across the internet. Thus they had control over the context that their tools would be used and that the feedback they would get would be only from this context.
A civilization to be governed will require multiple contexts and different types of governances, from the local level to the community to the city , the country and the globe.
I do not have the details very clear, but we need to link different contexts/communities/social organizations and not information/text/html
This is a continuation of my previous thinking on this:
1 Like
The motivation behind the first of today’s Web technologies was the dissemination of scientific information. That’s a very specific context, which today represents just a tiny fraction of the Web.
Technology has always been transferred to different contexts. Maybe the problem with the Web is that new contexts have not only adopted technology from earlier contexts, but taken over their development. I am thinking in particular of the shift to commercial use of the Web. The idea of having one universal Web, which was present from the beginning, was probably a cause for this as well.
The idea of universal solutions is far too present in tech for my taste. There’s always the tacit assumption that context doesn’t matter.
2 Likes
Funnily, I happened to stumble upon Allan Kay’s html burn.
He simply says that data formats and the procedures that can understand them should be in the same place, thus no one else needs to learn of those formats. He talks about abstraction, about having multiple objects interacting with each other while internally having specialized organization.
Alan Kay makes the compelling argument that the object / actor / system itself should be the only one to know how to draw itself on the screen.
That is why we only need the X window system, and not a browser. Instead of the browser , we would have a multitude of drawing mechanisms.
The DOM is a single shared state that is changed by a multitude of asynchronous functions, thus it is the worst possible thing to do.
Reflection / inspection is a good property of the dom but smalltalk does have reflection as well.
I am not promoting smalltalk, by the way. I promote composable asynchronous systems , composable protocols.
1 Like
Let’s look at Kay’s 1997 vision with the benefit of hindsight. Did his approach ever have a chance of realization? Was there ever a configuration of market forces in which most major players would have agreed on a single protocol and runtime support library, which moreover would have been designed and implemented with good security built-in from the start?
2 Likes
I personally believe that we need to enable commons based peer production that would lead to attaining an income to sustain software development and fund citizen and open science.
Yochai benkler believed in such a possibility. I believe it too because there are many P2P processes that could increase in effectiveness with software.
Platform cooperativism tried to put money into the problem but venture capitalists will always have more money.
The point is to build decentralized structures that are more effective than centralized ones , by nature of the problem itself. Thus we need to take advantage of the fact that decentralized organization is more effective under certain complex problems.
For this to happen, we need to think like a biologist and not a physicist.
1 Like
Here’s the transcript from 23:53~, the “HTML burn”.
Think about it. HTML on the Internet has gone back to the Dark Ages. Because it presupposes that there should be a browser that should understand its formats. This has to be one of the worst ideas since MS-DOS. [Applause]
You don’t need a browser. You just read it in. It should travel with all the things that it needs and you don’t need anything more complex than something like X Windows, hopefully better.
Wouldn’t it be even worse to have the state distributed among a multitude of objects? Having a single source of truth for the application state seems, if not inevitable then desirable for practical reasons.
I’m not convinced it’s better for data formats to carry with them the “procedures that can understand them”. That seems to mix concerns, where what I wanted was to transport data safely and instead get a Turing-complete system along with it - like HTML and JSON versus Flash or a bundle of JavaScript drawing on a canvas.
But of course it depends on the implementation. I’ve dreamt before of a Web of Lisp Objects (WoLO), where we could share applications and their states as easily as sharing documents and text files.
I feel that thinking like a mathematician is better because mathematics is closer to the bottom of everything than physics or biology. (xkcd #435)
But I get what you mean, we need more Biomimetics, learning from patterns in nature.
Alan Kay in a personal correspondence (2003) said this about “object-oriented programming”.
The original conception of it had the following parts.
I thought of objects being like biological cells and/or individual computers on a network, only able to communicate with messages (so messaging came at the very beginning – it took a while to see how to do messaging in a programming language efficiently enough to be useful).
I wanted to get rid of data..
My original experiments with this architecture were done using a model I adapted from van Wijngaarten’s and Wirth’s “Generalization of Algol” and Wirth’s Euler. Both of these were rather LISP-like but with a more conventional readable syntax. I didn’t understand the monster LISP idea of tangible metalanguage then, but got kind of close with ideas about extensible languages draw from various sources, including Irons’ IMP.
The original Smalltalk at Xerox PARC came out of the above.
This part resonates for me, how objects are like abstract machines.
objects being like biological cells and/or individual computers on a network
Taken further, an object has its own interface language (methods), memory (state and properties), inputs/outputs, operations to perform state transitions. Such objects can communicate among each other within an application, between applications, or across the network.
Also an object could be persisted to disk and resurrected/reanimated at a later time, like software cryogenics - or computer hibernation where it saves the entire system state before shutdown and restores it on next start.
Mentioned by Kay:
- Euler (programming language) - “EULER: A generalization of ALGOL and its formal definition” by Niklaus Wirth
- IMP (programming language) - Edinburgh IMP by Edgar T. Irons
Related thread:
2 Likes
Apart from the problem of the shared state that makes programming difficult, each " knowledge" field needs to have its own data structures and its own rendering mechanisms.
Instead of a single specification that becomes monstrously big that is controlled by some companies that have the capital to engage in its création, the same companies being the only ones to develop the browsers, we would have a multitude of specifications , all working together.
In essence we are again talking about extensibility and lithification. Abstraction plays a vital role in having variation.
https://forum.malleable.systems/t/lithification
That is the way is see Alan Kay’s argument. From a theoretical point , I agree with him. Maybe there are some intricacies that I have overlooked though.
1 Like
You already did when you downloaded the browser. There are many ways to distribute the procedures and many implementation details that I will not specify, because they are not relevant at the moment.
There did seem to be a brief window in the 1990s through mid-2000s in which CORBA could’ve, might’ve, tried to be that protocol. That’s what the Object Management Group thought it was being, I think? Trying to define the One True interoperable object standard for the whole world? And they had a lot of corporate power behind them, or seemed to have.
But it died hard in the war with Microsoft’s COM, and then GNOME resurrected it and it died hard a second time even there.
I imagine CORBA’s security was probably terrible like everything else from the 90s, so it probably wouldn’t have been a win even if had succeded.
Then there was IBM’s SOM, which they were pushing with OS/2. Was that part of CORBA or competing with it? Could IBM have made that a thing if Warp hadn’t failed so spectacularly?
1 Like
I agree on not wanting a large Turing-complete environment when I just wanted a small piece of data. I think Alan Kay’s repeated recent calls to replace “data” with Turing-complete black boxes is a terrible idea on multiple levels, in today’s computers which are cybersecurity warzones attacking the user from both ends (by both crime gangs and centralised corporations.) It reminds me of game cartridges in the 80s: game companies loved them because they were hard to pirate, and they were easy to use, but they weren’t intended to let the user have much control. Mobile “apps” aspired to the same kind of “user buys a large opaque machine, plugs it into a slot and lets it run” model, and have pretty much managed to reinvent it. That’s nothing to be proud of, though it’s made Apple insanely rich.
where we could share applications and their states as easily as sharing documents and text files.
I want that too. But I think before we can get to the point of “sharing application states”, we have to somehow push past the very deeply rooted sense of shame that today’s programmers have when it comes to even thinking about the idea.
Somehow along the line, and I’m not sure how - possibly from the OOP world but possiblty earlier - programmers have been taught and internalised the idea that “computational state is dirty and icky, one should never share it beyond the bounds of a single process, and even then only the compiler or VM should know about it, and destroy that knowledge as soon as possible”.
And some parts of that shame are probably sensible. There are secrets inside calculations that often should be protected. But… ultimately, everything is a computation, all data everywhere is (from one perspective) just a piece of a single giant ongoing computation, the Internet, which never stops. We obviously don’t want all of that state to be visible to everyone, and encryption is one way of hiding state, but a lot of it is visible to a lot more parties than we think it is. And we have to be able to think sensibly about how to safely share computational state, in a world where perhaps there might be no such things as even “processes”.
If we did have a worldwide live computation fabric made out of things like Alan Kay objects, the very first thing we’d need to do with those objects would be to share them! And that means having to expose their state. That’s job one in a messaging system: communicating state. But communicating violates Kay’s rules about objects being sealed boxes. There’s a deep contradiction there. Somehow we managed to invent a computing paradigm based on message passing without inventing how to convert an object itself into a message that can be passed. That contradiction, I think, is why the Web got there first and did “distributed objects” terribly poorly, in a very centralised way, and only after years of extremely hard work to layer them in over top of the non-objecty (but very clearly defined in its transmission semantics) “SGML document” concept.
Sometimes I wonder: if only Smalltalk had had a built-in mandatory non-overrideable “import/export object as data” method on its base Object class, would that have saved it? Or would it ruin everything? If you hold a reference to an object, is there a good reason why you should not be entitled to read all of its internal data fields? Because if you receive a transmitted data packet, or a file, you’re for sure going to be able to read all of its internal data fields.
The OOP contradiction exists even in Lisp/Scheme: if I receive a cons, yes I can read its car and car (although the actual “address” of a pointer remains hidden, which is very important for cheap VM implementions; if Lisp pointers were exposed to Lisp code as integers, they would have to be cryptographically secure random integers). But if I receive a closure, I probably can’t read its source, all I can do is blindly execute it, hoping for the best. A closure’s secrecy even to its receiver is a two-edged sword but often a useful security property when it is offering itself as a call point to untrusted code (and in a system exchanging code with the Internet, a lot of code will and should be untrusted). However that secrecy property is destroyed by serialising and transmitting that closure - which in a system exchanging code with the internet, will also happen.
I don’t know how to fully resolve this tension, but it probably comes down to being clear on the distinction between transmitting an actual closure/object vs transmitting a reference to a closure/object - which is much the same as the distinction between transmitting a document vs transmitting a link (if the link is something that doesn’t quite retrieve a document, but asks a remote system to run a computation, vs retrieving the code and database of the server process). And the choice of which of the two to use would depend very much on the “trust level” of the system sending and the system receiving. It feels like it shouldn’t be a major issue, yet somehow it doesn’t seem to have ever quite been formalised in a useful way - and formalising something like trust levels would be required just to implement something as simple as “file copy, but of objects”.
3 Likes
I think that there is a big misconception about what an abstraction is.
It is not opacity from the point of the user but from the point of the program.
Only this way, can the user inspect the interior of an abstraction, change the implementation, without
altering the functionality that the exterior sees.
It allows the users to play without too much fear. It increases variation / malleability.
The other direction of an abstraction is that it allows its reuse in different contexts.
Files with open documented format can be used by any program.
Documented functions can be used by any program.
Programs with documented protocols can be used by other programs.
An abstraction is a contract between the environment and the interior, it provides guarantees to both.
And at the same time, it allows the interior partial autonomy.
2 Likes
Yes, I think that’s probably right. A language / runtime / OS kernel should provide some kind of basic abstraction (like “object” or “closure” or “data type”), which everything can be built out of. This abstraction should allow most other objects to not see inside it, but allow some designated objects which are proxies for the user/operator of the machine (ie: compilers, debuggers, IDEs, object browsers, the VM/runtime/kernel itself) to access the inside.
Most software objects probably shouldn’t send raw data packets between themselves, but rather typed objects or abstractions, so that they’re known to be valid and correct because they’re parsed in and written out by a software object which knows what it’s doing.
There seem to be a lot of agreement on this basic principle of abstractions but two schools of thought in programming design as to how it should be implemented: either through “types” or “objects”. And those two fight forever. And then there’s a third school of thought which is practical OS design following the Unix model, which ignores everything just agreed on by the programming people, and allows all software objects to write all data out to completely untyped files on disk or packets on the Net, and implement parsers by hand themselves.
It turns out that no programmer has ever been able to write a parser correctly (despite this being the only thing taught in computer science degrees) so this architecture of course breaks constantly and hilariously causing massive security vulnerabilities each time. It’s always image parsing libraries in particular that do this, maybe because everyone thinks “I know parsing is hard for everyone else, but, I’m smart and this thing has to run fast so I’ll just use raw C++ memory access and it’ll be fine cos I’m smart” And five minutes later it’s another node in the World Wide Botnet.
(Yes, I did just read about the Android “Landfall vulnerability”, and yes, I’m annoyed. WHY IS IT ALWAYS IMAGE PARSERS? Whatever it is you keep doing when you write image parsers, programmers, stop doing it! LANDFALL: New Commercial-Grade Android Spyware in Exploit Chain Targeting Samsung Devices )
2 Likes