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?
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?
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.
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.
@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.
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.
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?
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?
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?
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?
@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.
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?
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).
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.
@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.
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.
@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.
@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.
@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.
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.