I'm quite sceptical of apps/software as the best way of structuring computing. I don’t pretend to know which alternatives would be better (and like to think there doesn’t need to be a single answer) but the explanations for the success of software and the failure of alternatives always seemed pretty underwhelming, often leaning on the fact that software did succeed as proof of its own_._ However_,_ finding an argument to be weak isn’t really an explanation, even if it suggests the need for one. Recently I was wondering if there is explanatory power in “Conways Law” if applied to large socio-technical systems. Conway was thinking about the internal structure of software as produced within an organisation in How Committees Invent. The paper has much more nuance, but the adage roughly states:

Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization's communication structure

If we apply this line of thinking to computation at large, we might ask questions on the impact of communication mechanisms inherent to capitalism and their structuring effect on the computing landscape. This maps quite well to software, as there is often a correspondence between software production and individual firms. We might imagine a different economy (e.g. some highly federated, anarchist society) and think of what the organisation of computing might look like. This is something I think is interesting to explore on its own, but it lead to a different idea I find quite compelling: That the success of software is a result of a drive to make computing economically “legible” to capitalism. (I’m appropriating legibility here from James C. Scott’s Seeing Like a State) This makes some sense as an explanation for software, but it might also offer a new explanation for things like app stores among others. • Platforms could be seen as (among other things) exertion of control of legibility, where legibility is much higher for those who control the system (e.g. Amazons view of their own services vs a users view). • The apparent success of software over alternatives such as open document systems, or composable (non-software) GUI systems, or "computational media" efforts, might be explained as not a technical or conceptual success, but as providing legibility that alternatives lack. • More interestingly to me, is wether legibility is even something desirable in the first place. [This is a slightly rehashed line of thinking I passed around at work that I thought might be interesting to this crowd. This isn’t thought through, so just read it as casual speculation. But I do think we need an explanation, if we are ever to move beyond this current way of interacting with digital systems]

I have been thinking about this as well, and I also happen to be a big fan of Conways law as an explanation for design architectures, software or other. However, what I see as the social foundation of the package-based structure of today's computing environments is not capitalism, at least not directly, but the concepts of intellectual property and legal responsibility. A software package is a unit that is owned by someone (person, company, OS community, ...) and may create liabilities for their owner. For a different architecture, consider (human) language. There are ownable units as well (books, articles, etc.), but nobody owns English or Chinese. The evolutionary processes are thus very different than for owned units.

If I understand you correctly, it's not "software" in general that you're asking about, but separate, siloed applications each living in its own isolated world. I suspect part of the cause is historical, since personal computers couldn't handle more than one focused task at a time for over a decade, which was long enough for a way of thinking to become deeply entrenched. I also suspect that part of the issue is security. Sandboxing each app by itself, like on iOS or Android, is much easier than allowing untrusted code from multiple sources to all coexist in the same object space, in the Smalltalk or Open doc or NewtonScript sense. I think we could learn something from multiuser games here, since they've been dealing with the issue of letting untrusted bits of code from multiple sources interact with each other for a long time. Second Life, LambdaMOO, LP Mud, and object capability systems all seem like potential sources of inspiration here.

BTW, I am trying to encourage a different model for my digital scientific notation (https://github.com/khinsen/leibniz-pharo). No idea if it will work of course. I plan to describe a recommend a "no reuse" policy. If you want to work with someone else's code, you copy it into your own project and adapt it as necessary. This is how people have worked with scientific models and theories for centuries, with good results, so I see no reason to change just because the knowledge becomes digital.

@Konrad Hinsen yeah I totally agree there, it’s part of what I meant by legibility, as software provides a structure that is amenable to ownership, IP, markets, etc. I think your framing might be a more effective one. As for the language example, that’s actually exactly the counter-example I used at work! I’ll definitely fold ownership or “ownability” into future discussions. The reason I like “legibility” is because it doesn't point to a specific economic concept like private property, and so might translate more easily to analysis of other economic systems (or variations of our current one). Hence the federated/anarchist example.

@Orion Reed You might want to frame it as "apps" rather than "software", as the latter word has a different (and well established) meaning that will trip up some readers, like PDM and myself. But yes, the silo'd apps in an app store model is... not great.

On a similar note, I'd say "widely adopted/used" (or something similarly concrete, whatever you actually have in mind) rather than "successful".

Trying to compare to an economic model different from the US, but one that already exists, I was wondering how much of a role the Chinese government has in enforcing software interoperability, since about half of their economy is state-owned. Looks like they have an initiative called ‘China Standards 2035’ that’s partially about coordinating technological standards. But as you can read here it’s also just about economic modernization and isn’t that heavy-handed. For context, their government is also pretty decentralized (which should be distinguished from how authoritarian it is).

Extremely interesting conversation. To understand tech in China, I cannot recommend The Great Firechat enough https://www.greatfirechat.com/. It just so happens that Kevin and Adeh started the podcast shortly before the Chinese Communist Party introduced major changes to how it regulates tech. See also Kevin's brand new book about WeChat https://www.amazon.com/First-Superapp-Inside-digital-revolution-ebook/dp/B0B1Q7NYN1. To sum up the China tech antitrust situation... With consolidation, like one dominant rideshare company (DiDi) and two dominant digital payment systems (Alipay, WeChat Pay) especially with Jack Ma touting how payment data was enabling Ant Financial to outcompete any bank at assessing credit worthiness, the Party felt it was high time to intervene. No one institution should have too much influence on the Chinese public — except the Party itself. So IPOs have been blocked, Ant Financial was nationalized, apps can no longer collect more data than they need from people. What else has happened recently? Online tutoring is no longer a thing. A huge industry dissolved in about a day. See also Hong Kong's legislative council being reorganized after it became clear that the existing electoral system would have produced a majority critical of the Party.

The antitrust angle is interesting. Or in general looking at what effect consolidation has on software. I wonder if there’s anything out there about what happened to the old AT&T’s code after they got broken up. I’m sure they had to maintain standards, but did they just fork the internals?

Legibility is indeed an important perspective. It is ultimately about different scales of implication/engagement with something. There are "locals" and "outsiders" (for software: developers and users), with legibility being the ease of access for outsiders, even if that incurs a cost for the locals. Human language is defined by locals (speakers) and makes no concessions for outsiders (everyone who doesn't know the language). They have to deal with whatever is there, or use services (translators/interpreters). Legibility is low. Scientific theories have locals (scientists) and outsiders (everyone else). Like language, they are defined by and for locals. Outsiders have to learn the science, or use services (science journalists, ...). Legibility is low. In a complex society, there is room and need for both approaches, and probably an intermediate one that remains to be discovered. What I think matters is awareness of the trade-offs, and that's not yet very well developed. Open Source is a nice illustration. There are OS projects that deliver industrial products just like software vendors do, only with a different commercial model. Firefox is a nice example. Legibility is high, but locals (developers) don't profit from their work other than through income. There are also OS community projects, with communities seeing themselves as working together on a shared asset, i.e. by and for locals. But many of them (the well-known ones: Linux, Python, ...) are much more about a legible product for outsiders, in return for mindshare/idealism/fame/whatever. That doesn't work out well for those locals who believe in the community story, and we get maintainer burnout as a result.

I'm not at all convinced legibility is entirely a matter of scale of interaction. It seems perfectly possible to have a system that's illegible to all involved. International intelligence comes to mind, mainly because I've been reading John le Carré lately, but various kinds of computing systems also tend toward total opacity if not carefully managed.

There are certainly cases of designed systems that nobody understands, but I see them as fundamentally dysfunctional, and thus a different issue. A more interesting case is evolved systems that aren't legible for anyone.