Angelo Pesce on hackability should appeal to many here: http://c0de517e.blogspot.com/2019/12/is-true-hacking-dead-what-we-lost.html

This is a very nice essay. I think it is very clear that the current development stacks are ridiculously complex. Unfortunately the world rejected the work of Prof. Wirth, whose Pascal/Modula-2/Oberon progression was about making it possible for a small team to build and understand an entire operating system. I was one of perhaps a few hundred people working in Modula-2 for 20 years; the vast majority of American developers were wedded to C, because of the MS juggernaut. Even Apple eventually caved and switched out of their Pascal dialect into Objective-C. Simplicity, and understandability are not possible when you have a giant pile of dependencies in almost every project.

<cough>NPM</cough>

We’ve discussed the complexity aspects here many times, however I’m somewhat intrigued by his take on open source:

Whatever the causes, we have software and hardware systems that strive to be entirely open, yet time and again are closed ones that are more accessible in practice, that drive social revolutions. Linux didn't change the desktop, nor the way software is made.

I’ve always felt weird about open source, which is taken for granted as a good thing by many because of its openness. But it feels messy and poorly designed in most cases, because only few open source projects have strong opinions and willingness to leave out things (which I think is a core part of good design / managing complexity). The open source projects that do are either rather insignificant code dumps from single individuals or projects backed by massive companies who’ve imprinted their strategy on them.

And ironically, probably by utter coincidence, but ironically indeed, all the new power brokers of this era, the Facebooks and Amazons, the Googles and Twitters and so on, fully embrace opensource stacks, hundreds of millions lines of codes powering the AIs, the networks of today.

The new IBMs do know very well that lines of code are for the most part worthless, but people and communities aren't, so it's a no brainer to opensource more if in change one gets more people involved in a project, and more engineers hired...

It almost feels like there is a inherent systemic force that makes open source projects absorb complexity and therefore less valuable in the eyes of big corporations who seem to be more interested in their appeal to an audience that attracts talent and free or at least cheap labor. If they really cared (and for those parts of the code they really do), they’d properly hire engineers instead.

Perhaps we didn't truly graduate from our a-social tendencies, perhaps we're true to form in thinking that the machine and technology are more interesting than people, and groups, and culture...

This is also a sentence packed with insight worth a whole discussion on its own. Are we really contributing anything valuable if we all individually dump our code on GitHub? And if we all do just this with our own projects instead of looking how we can contribute to other people’s projects?

I think the things became much complex than earlier days. That’s how it’s more difficult to tinker with entire system. You still can do it with parts, like web-development for example. But to do something completely from hardware to software is not possible because amount of knowledge is too huge

to do something completely from hardware to software is not possible

For a counterexample, look at Arduino programming, where you can program the bare metal and make something useful. Or, look at the community of people who design and build their own CPU hardware at a hobbyist level using FPGA programming.

Oberon OS was by today's standards a very crude graphical interface, but it only took 100Mbytes on the hard drive, which is tiny fraction of current operating systems. OSX 10.15 by comparison is 8GB compressed...(80 x bigger). So no question that massive bloat has occurred in operating systems and application programs. See https://www.progtools.org/article.php?name=oberon&amp;section=compilers&amp;type=tutorial

Arduino programming

in my opinion Arduino is a low level, you can’t make a GUI on it for example

@Stefan Open Source is just a technique for publishing software, used by several types of organizations for different reasons: 1. Individuals or small groups make public backups of their code on GitHub. 2. Larger organizations make their source code public as a form of virtue signalling: Look, we are generous. Look, we are transparent. 3. Loosely organized communities solving shared problems make their source code public for transparency and for attracting new members. Firefox and TensorFlow are good exmples for case 2, Linux or Emacs for case 3. It's the last case that most people associate with the FOSS labels. Such communities rarely do innovative work, because innovation requires small teams in tight collaboration. Usability is rarely a dominant criterion, since the communities develop for their own needs. And dependencies are socially useful: they generate bridges to other communities and thus potentially more mindshare. I hope someone will figure out a way to do more innovative and user-oriented work and still publish it Open Source for transparency. Today's dominant innovation model of "free toys in exchange for letting us do what we want on your devices" isn't great either.

But what is striking to me is how that ideology is completely lost as well, replaced with one that prioritizes theoretical freedoms over actual ones.

That's the core.. like @Stefan indicates, the openness of open source is most useful to corps and advanced programmers, not to average programmers, and certainly not to non-programmers.

@Wouter I agree for the C64, but Smalltalk has kept up with developments, and today's Pharo or Squeak let you do impressive stuff while remaining nearly as hackable as their ancestors from the 1980's (check the videos from ESUG2019 for example, in particular Roassal 3 and Woden: https://www.youtube.com/playlist?list=PLJ5nSnWzQXi8DPNpy1jCkjE4yE0WUtDP2). And yet Smalltalk remains a niche tool. Perhaps it is just not well-known enough, but another explanation is that hackability is just not fashionable.

@Wouter good points.

I'm not a smalltalk user, I just have a collection of prejudices against the language from way back, some or many of which may no longer apply. My perception is: stone age graphics, the graphics core isn't GPU accelerated, poor support for high DPI displays, poor unicode and font support. Unicode includes: using harfbuzz and pango for text shaping and layout, full unicode editing support (bidirectional text, ligatures, etc). No modularity (eg, having to hack default message handlers into class Object to integrate your code into an image), no modern internet based package manager, etc. It's still an image based system, right, rather than consisting of a small clean core plus a hierarchical collection of packages? It's still purely object oriented, where everything is strongly coupled to everything else due to everything being represented as mutable objects, rather than being a functional language with immutable values. Smalltalk is horribly unsafe: someone recently confirmed you can still crash Pharo using 'true becomes: false'. Safe languages are where it's at today. Pure functional languages have a very good story for modularity, safety and sandboxing of untrusted code, because a pure function can't access any state that you don't pass as an argument. I'm not sure if I can easily build and ship a native executable. I seriously doubt I can export to web assembly. These latter issues are because: if I'm going to devote serious effort to building some interesting software, I'd like to have the option to make it available for use by non-smalltalk users, which means native apps and web deployment via WASM or JS. To be clear, I'm trying to enumerate preconceptions that a lot of people have about Smalltalk (including myself), that might inhibit them from looking more closely. I think that saying "hackability is just not fashionable" is really oversimplifying things. I would love to see a modern system that meets all the requirements I enumerated above, which embodies a smalltalk level of hackability.

@Doug Moen Given your criteria, Smalltalk is indeed not for you, but then I’d also argue that hackability is not that high up on your list of priorities. Things have improved, however: Pharo for example supports Unicode and uses images as temporary workspaces rather than for long-term system evolution. Modern Pharo code lives in git repositories. And there is support for immutable objects, which are however still quite rare. ‘true become: false’ still produces a spectacular crash, but that isn’t really an issue in practice. Everything else being equal, I’d also prefer pure functional languages, but everything else is not equal. Smalltalk makes it much easier to understand your system, which is worth a lot as well.