TheMode

I would rather call it a workaround. They are doing the exact same thing everyone do, but for longer.

Which I guess is better, but they are not tackling the root of the problem.

That's not solving anything at all, what we need is hardware that doesn't need to have its software updated constantly. If you cannot have that, I wouldn't consider it ""sustainable"". There is nothing sustainable about depending on some company on the other side on the world to do the right thing continuously.

Now sure, you could answer that they are doing it better than others and you may be perfectly right, but is it really the way we want to solve it? Gossiping on every company on how often they update their software?

Is the hardware really the bottleneck to sustainable device? The software seems more much important but nobody is tackling it.

Having a phone with a new battery doesn't matter if I can't run the same apps as others.

The fact that I do not understand at all what these services are for by looking at their landing page is kinda funny.

My main point is that you shouldn't depend on code to be able to run the program, but on the spec. Hence the emphasize on the spec being simple to implement.

There is no way to ensure that a vm/compiler will last forever, especially given the infinite amount of potential platforms. Binary search as a concept will last longer than ScummVM.

Raw assembly is theoretically portable as well, why do you want the source?

My problem with these is that they are cross-platform only as long as the maintainers decide they are, you aren't gonna write a vulkan software impl from scratch if the platform doesn't come with one.

Now you can argue that this is all very unlikely, but you have to agree that this is no archival. At some point the project will become unusable because of all the automation code it depends on. Binary search will outlive it.

What we need are programs compiled down to some minimal instruction sets, simplifying the implementation of custom vm able to run such software.

The source does not mean anything if there is no working compiler, or if the compiler doesn't support your new shiny platform.

It is the same for servers. Having the source for a whole hosting service depending on some specific hardware doesn't matter.

If we decide to truly care about software legacy, we need to re-think the stack.

Kinda doubt they will achieve parity. Even if they do, for how long? The problem is that the spec is a moving target, you cannot justify maintaining a platform indefinitely while a complete version exist on the side.

The stakes are different. Back in the day they lived more independent life, these crazy things they believed in didn't really matter as only the people from your close geographic area would be affected.

Giving conflicting informations to people all around the world expected to interact with each other is a bigger issue.

Isn't lambda calculus heavily parallelizable? Perhaps not as much with our current CPUs, but couldn't we have dedicated hardware?

[0] and [1] seem pretty promising to me, although I believe that the problem come from the fact that these languages do not expose a way to describe a sequence of bits, which may make them not lambda calculus anymore, but probably much more usable (you could then implement a soft version of integer/float operations and a compiler that convert this code into a single instruction, easier as there is no side effect guarantee)

> but I haven't yet come up with a good system of combinators that can represent I/O and foreign functions properly

I do not believe that you should support either.

I/O could simply be the program arguments & the final reduction of the expression. The input being your mouse position and the output being a window shouldn't be the responsibility of your program.

Foreign functions are IMO a bad idea, especially if the goal is for the program to outlive you, you lose the guarantee if these functions depend on the environment. Why couldn't you copy/paste the code into your own project?

[0] - https://esolangs.org/wiki/Binary_lambda_calculus

[1] - https://esolangs.org/wiki/Dependently_Typed_Binary_Lambda_Ca...

Have you ever thought of using a version of binary lambda calculus as your spec? I see you mentioned it as a joke ISA, but not as the possibly simplest backend

Dying because no code is written in it, or dying because nobody is able to run it isn't the same.

We shouldn't prevent language from dying, but they shouldn't either due to lack of maintenance.

We do not need to future-proof languages, we need to make them replaceable and able to interact with each other.

I believe the biggest problem to be environment/io access. It will be the bottleneck of most new language implementations and encourage people to update the old instead of creating the new. A simple fix would be to separate both, like in this blog post having input/output instructions and leave the actual environment interaction to something else.

It is definitely lazy and superficial, but it does not necessarily make for a terrible indicator. We are much more receptive to color than small shape variation, by removing the former you are preventing (or at the very least mitigating) comparison and the creation of stereotypes.

Now I am not from the US so I won't comment about history, and I can fully believe that there is some link between being a white nationalist and believing one "race" to be superior to the others, but I do not believe that this is a reason enough to disqualify the idea.

"my own people" in this case means "people that look like me, and have a somewhat similar culture/lifestyle". So obviously it is a bit unclear and you won't be able to get a perfect list of allowed/not allowed group, but it does not imply inferiority at all.

And if they didn't do anything you'd have said that these mods are too proud to move away from power for a few days and absolutely cannot listen to their community.

All software have many dependencies (IMO for very wrong reason), if you can find a way to build a static system where nothing need to be updated good for you, but I doubt that this is the majority of use-case.

Will this device be able to load any web page in one or two decades? It would likely be slow, but the impossibility would be a pure software limitation.

I may agree with the idea, but it is pure fiction. Instead of begging companies to be nice, we should figure out how to change our entire software paradigm so it becomes impossible.

I do not use a washing machine, but that's not the point. Do I need to have some sort of primitive lifestyle to dare say a lot of what we have shouldn't be a guarantee? Don't understand why you need to get aggressive.

I didn't even mention these which are likely far from the priority or realistic, what about one day shipping?

Perhaps that we do not need the same standard of living

Hope you are digging your own fuel

Not arguing about that specific project as I do not know anything about it, but not figuring out how to run software seems like a pretty big design issue. You can't always blame the user

What we need is understandable laptop/hardware, not open-source. Open-source is a step toward this goal but it shouldn't be the target.

Framework laptops could be considered as open-source, but I am not convinced that I could understand the system much quicker than any other random laptop manufacturer

With collisions and perhaps a few other things, couldn't it be used in a game to design machines? Seems fun.

Wouldn't you just be pushed into dressing the same way? Is it really problematic?

What new job will arise? The ones requiring more education? The barrier to enter the economy cannot indefinitely grow, do we want every single human to become an AI developer or a researcher?

The problem is that humans aren't getting specially smarter as generations go, but technology continue to grow

Ignoring study, that would be a more graphic example: https://www.youtube.com/watch?v=meiU6TxysCg

Or historically, if this wasn't true we would be the happiest humans to ever live on earth. Doesn't seem to be true on any possible metric.

I do not believe that standard of living should be compared in a vacuum. Since I assume that this is what you are referring to, I am firmly convinced that happiness is relative.

What this means is that improving the standard of living of the average person by 5% while improving it by 50% for a smaller population will hurt more than it helps.

The dog would say that it has more value, same for a tree, or an ant. If we had to fully protect everything categorized as intelligent/living, we wouldn't do much.

Dogs may be a hard no for someone, and yes for someone else. It's kinda arbitrary.