Follow

So I feel like everyone is reallll fed up with the status quo of digital electronics regarding efficiency, simplicity, learnability, (list probably goes on).

I have two questions on my mind:

1.) Does it just seem like that? Is it the programmers in my bubble becoming old and grump, or is there really something brewing? Do we have enough powder for the computing revolution of the 2020s?

Show thread

2.) Who is already out there tackling this problem, and at which level? I fear we may have to go very deep and compromise intermittently to improve. What projects are out there, with vision and roadmaps?

Show thread

@s_ol aral may have some suggestions of projects... @aral - and something to say on the subject.

@Truck @aral
oh nice, i hadn't found their Mastodon account yet!

@aral

yup, I remembered this, but couldn't find it. Thanks @Truck for pointing me back towards it:

The small technology foundation
small-tech.org/

@s_ol
@aral @Truck the #smalltech vision and principles are very inspiring and can be readily adopted by anyone disillusioned by big tech.

In these times we come to see again that #smallishuge

@s_ol Chuck Moore has been building his own parallel universe of computing-without-the-suck for several decades

the problem is it just doesn't interoperate; like ... I don't want to switch to a platform that doesn't let me participate in stuff like the fediverse or make SSH connections to other machines.
@s_ol there's different levels of what a "paradigm reboot" could entail, right?

there are people making incremental improvements that are very practical like the MNT Reform or the Novena from a few years back (heck; I'm building my own modest contributions putting a Pine64 in the Atreus Deck) that just strip away the worst bits of capitalism but leave the Unix intact, and there are people starting over from the silicon gates, and then a bunch of stuff in between.

I really want to throw away Unix and the shackles of decades of C-induced 1970s thinking to trade it for a system that invites end users to shape everything to their will, but I also want whatever I build to be a thing I can use every day at my job, and those seem mutually exclusive.

@technomancy
Yup, I think you nailed it here, especially with the last part. I think somehow whatever comes next *has* to break compatibility if it wants to be better, but maybe there needs to be a mid-term plan for coexisting. One of the biggest pain-points for sure is supporting the web; without a browser you can't convince a single end-user.

@technomancy
Since reimplementing an OS and a Browser from scratch and better is essentially impossible, I have only two ideas:

- Build a whole alternate device formfactor that just doesn't web. Back to the personal-personal computer or something, a machine for hacking.

- Build something lightweight that has the ability to run bare-metal, but also virtualized, and have it integrate A+ with existing operating systems, so users can use both until the current web is obsolete.

@s_ol @technomancy the web should be abandoned and relinquished to the capitalists. fundamentally this technology is inadequate to achieve its goals and must also be re-architected. we could have such an amazing hypermedia web but unfortunately projects by Tim Berners-Lee, Semantic Web and Solid, won't succeed because they rely on backwards compatibility in a hostile and chaotic space.

@theruran
imho at #solid TBL and Inrupt also got their focus wrong. Having a commercial approach and overly technical mindset just doesn't cut it. Plus they seem inwards focused (not all in the community of course, but most of core team are).

@s_ol @technomancy

@s_ol @technomancy I think in these situations we have to consider how tech revolutions happen in an entrenched system landscape: the market changes and the big players are not coming along. So personally I think there is no point in working on something that coexists with the existing ecosystem. We will always lose. We had a new opportunity with mobile, and embedded, but it’s slipping through our fingers.

@kensanata
yes i agree, see my comment right underneath the one you responded too :)
@technomancy

@s_ol @kensanata @technomancy This is an interesting discussion, but the issue is not quite clear to me. From your perspectives, could you explain what you think is wrong with the OS? Is it the kernel that needs changing, or the layers above or below it, and why?

@wim_v12e
I won't claim it's fully clear to me either, and I can only speak for myself. I think that we have been doing too much layering and wheel-re-inventing, and it has made a confusing mess out of everything. Every layer has some amount of historical "could've-should've" baggage that we can't fix without breaking everything on top of it.

@wim_v12e
There is so much stuff in computers you can learn about it for many decades, but in the industry you start working after at most five years of training (usually way less). It just doesn't seem sustainable.

(note: don't mean to imply some elitist bullshit about everyone needing to study more - programming needs to become simpler)

@s_ol I image you are more concerned with the layers closer to the top of the stack? I mean, the OS is layered to allow hardware abstraction and to present a standardised API, which seem like good things to me. Therefore I assume the layers you have in mind are above that?

@wim_v12e
mostly yes, but I do think that if our OS' would reach further into GUI-space (the way browsers do, but as principled as kernels have), that might be key to building more stable (over time) and consistent software.

@s_ol I'm sorry, I don't quite understand: do you mean that GUI functionality should be under more direct control from the kernel, rather than being handled in user space?

@wim_v12e
yes. I think if the "standard interface" that you get to work with as a userspace programmer wasn't int main and fopen but a different abstraction that maps into (a purposefully-designed version of) modern user experience. I'm not sure what that would have to look like, but it's probably something like the Pharo Smalltalk environment (but performant...)

@s_ol But could you not implement this in terms of say existing POSIX calls? Would there be a need to change the OS for this purpose?

@wim_v12e
its not a technical issue - of course you can build literally everything on top of any OS that exists today. It is a social/cultural issue about how hard or easy it is to create software of a certain quality and coherence.

@s_ol So is your point then that the APIs currently exposed by the OS (e.g. POSIX) are too hard to use, and that this could be solved by having an API that supports GUI functionality directly?

I must say that I don't understand what "GUI functionality" means, is this event support, rendering, or something else entirely?

@s_ol @wim_v12e Look also at the Commodore 64/128 version of GEOS, which has exactly *one* event loop, and it's in the kernel.

I hope to build my own OS/Forth-inspired environment for my #rc2014 some day using a similar architecture.

@vertigo
It is very interesting, thanks for the pointer. I think I understand now what s-ol means with GUI functionality closer to the kernel. What would the advantages be compared to the current approach?
@s_ol

@wim_v12e @s_ol Extremely lean, small software. The GEOS kernel fits inside of 20KB, including *both* the graphics primitives it offers (which isn't a lot but is enough) *and* the replacement DOS for the stock Commodore DOS, which both adds support for VLIR file types as well as a speed-loader/-writer, while still leaving 28 to 32KB of memory left over for user applications. GEOS is the closest thing the 6502 processor platform has to an OS comparable to CP/M for the Z80 platform.

@wim_v12e @s_ol This has lead to a number of surprisingly powerful (considering the limitations of a computer with an 8-bit CPU and only 64KB of RAM) productivity applications for the OS that all fit easily on the 176KB floppies of the era, with room on-disk for user-generated content.

Because of its compulsory efficiency, using GEOS on an accelerated system (e.g., C64 with SuperCPU set to 20MHz mode) feels very much like a 66MHz 486DX2 system running Windows.

@vertigo
I see. That is certainly true for this particular platform. My question was more about general-purpose OSs though.
One of the posters mentioned "I really want to throw away Unix [...] to trade it for a system that invites end users to shape everything to their will, but I also want whatever I build to be a thing I can use every day at my job", and my question was about this: what is wrong with e.g. Unix?
@s_ol

@wim_v12e @vertigo @s_ol *nix exposes the wrong interfaces to users :flan_shrug:​ wrong because they are insufficient. wrong because they were designed for a particular system in the 70s. wrong because they were designed for software and computer engineers, not ordinary users.

@wim_v12e @s_ol Apologies; my intent wasn't to suggest that GEOS was a viable alternative, but rather to show an example of what an alternative approach could be like.

Because GEOS is so heavily "evented" (as contemporary vernacular calls it), it's a great case-study for contrasts against "threaded" OSes like Unix and, yes, CP/M (even though it's single-threaded).

Show more

@wim_v12e
I think old Lisp Machines and Smalltalk Machines from the 70s/80s have a lot of better ideas. These machines are of course much worse than our modern systems in many ways since ours have been continuously improved for decades since, but these other systems had a much more ambitious vision and would be way better than our current Unix.
@vertigo @s_ol

Show more

@wim_v12e @vertigo @s_ol One of the main advantages is not having to rely on partially-documented, ever-changing interfaces. GUI support should be fundamentally supported as with other essential services we still don't have in the year 2020.

I just want to add that we could have nice things. They have already been invented. But there were very real barriers created by capitalism that prevented those inventions from ever leaving their labs. Just one example that comes to mind is OpenDoc.

en.wikipedia.org/wiki/OpenDoc

@theruran Would extending POSIX to include GUI support be an option?

@vertigo @s_ol

@wim_v12e @vertigo @s_ol POSIX is designed for Abstract C Machines... we have to really get past the idea of sequential processing if we are going to transcend this paradigm.

Show more

@wim_v12e @theruran @s_ol I speak only for myself, but my opinion is that POSIX is way too big as it currently is. Adding a GUI standard to it would not (I think) create the desired outcome.

Considering also how many different POSIX-compliant systems existed which nonetheless remained mutually incompatible even at the source-code level (thus necessitating hacks like GNU Autotools), I'd argue that X11 served its role as a GUI standard more adeptly than POSIX ever could.

Show more

@s_ol @wim_v12e Configuration and orchestration need to be simpler, too. This whole "you need to re-up your $5kus certification every year because that's when they teach you about the breaking changes" thing is bullshit.

@drwho Maybe I misunderstand this, aren't configuration and orchestration done at layers above the OS? This is what tools like Ansible do, isn't it? Or do you mean something else?

@s_ol

@wim_v12e @s_ol They are, yes. The ones that tend to be used in corporate environments, however, are incredibly complex and the documentation sucks. Possibly deliberately so to get people to cough up lots of money every year to re-up their certs.

@wim_v12e @s_ol @kensanata any software that doesn't have a "view source" function at every level of the stack is fundamentally flawed and should be replaced. any software that doesn't make it trivial to edit that source and apply changes easily better have a damn good reason for omitting such critical functionality.

@technomancy I'm sorry, I should have clarified this in my question, I am more interested in hearing your technical arguments.
@kensanata @s_ol

@wim_v12e @technomancy @kensanata @s_ol I'm not sure where I readed it, but there was a good blog post about how the UNIX model limits composition.
The basic example was:
why must we rewrite sort(1) for C programs?

This is why I am more and more inclined towards the LISP model.

I want to be able to run a query in Scheme that modifies the current playlist in VLC. And I want type safe rewrite rules for me shell scripts.

@grainloom

What do you mean by "why must we rewrite sort(1) for C programs"? I can't parse that at all.

@technomancy @kensanata @s_ol

@wim_v12e @technomancy @kensanata @s_ol Well, you can't really use the sort command on C data structures.

@grainloom OK, understood, a language with a proper type system would make that possible. But that is to my mind independent of the OS.

@technomancy @kensanata @s_ol

@wim_v12e @technomancy @kensanata
the point is that Unix encourages you to make reusable pieces at the program level, which is in conflict with creating reusable pieces at the language level. what @grainloom is advocating is the language *being* the operating system (and the user interface), so that the two sides of the conflict are made congruent.

@s_ol I suppose this would mean that the language runtime is the OS.
For a general-purpose OS this might not be desirable, if only because programmers are very attached to their preferred languages.

@technomancy @kensanata @grainloom

@wim_v12e @s_ol @technomancy @kensanata There are approaches like ALLVM or the new WASM thingies.
Transpilation is already rather widespread as well.
It's the only path I see that doesn't involve a significant slowdown and can run on existing widely available hardware.

@grainloom But these don't provide a runtime with the same capabilities as a general purpose OS. The are meant to run on top of an OS.
Also, fundamentally, if you have different languages, interoperability will never be perfect, esp. if one has dynamic typing and the other static.

@s_ol @technomancy @kensanata

@wim_v12e @s_ol @technomancy @kensanata I'm ok with not being able to run all the more complex programs. If some patching is necessary, that's fine.
It's not like interoperability is all that good right now.

Show more
Sign in to participate in the conversation
Merveilles

Merveilles is a community project aimed at the establishment of new ways of speaking, seeing and organizing information — A culture that seeks augmentation through the arts of engineering and design. A warm welcome to any like-minded people who feel these ideals resonate with them.