With teams like MS and Apple also working on it, I expect this to be figured out on a faster timeline. Months/ few years.

That assumes they will share a meaningful amount of work. I do not see what Apple have done to help much at all - completely closed ecosystem with their own custom chips that they are not going to want to share.

MS have done a really bad job as well at getting ARM to kick off and have not been putting a huge effort into it that I have seen. And especially since valve is doing this in part to get away from MS systems why would MS help valve with this goal?

So yeah, if they did put in and share the effort it would take less time. But I don’t see them doing that. Plus, it takes years to develop a product like this. And all evidence ATM suggests they have barely if at all started on the next version. Which does suggest that the next deck is likely more than a year away, likely two. Which does increase the chances that it could be arm based.

And the basket will be upside down.

I wouldn’t sound so sure. There are a lot of blockers to getting a working ARM based steam deck. First Arch Linux (which steam os is based on) does not offer official ARM binaries. This would mean they would need a new base os or work on getting Arch Linux to support ARM. With their recent donations to Arch Linux were focused on unblocking some issues with supporting Arch on ARM (notibally stuff needed for better automated builds) would suggest they want to stick with Arch.

Next you need good emulation layers for x64 and x86 as that is what all games are written in. Which there are leaks that say they are working on this as well.

But that is two big blockers that could take years to solve. So all comes down to when they want to release the next deck. Within a couple of years and I don’t think it will be arm based. After that the chances go up quite a bit.

And given some recent news about Valve working on an ARM emulator and funding Arch Linux to help them start supporting ARM as well they might be working towards that. Though if that is for the deck 2 or something else further in the future is yet to be seen.

The only other major thing for repairability/upgradability would be less glue on the battery and threaded inserts, which doesn’t add size.

The glue was reduced on later versions and especially on the OLED version which also got threaded inserts. So those are already done and I doubt the next version would regress in that regard.

I suspect that concurrency was used back when there were only single threaded cpus, when process scheduling became a thing, to talk about the difference between running one process after another vs interleaving the processes so they appear to be concurrent. Then once true multithreaded programs became a thing they needed a new word to describe things happening at the exact same time instead of only appearing to.

And then relabel all the old standards when they create a new one so every generation you need to figure-out what al the new names mean.

I would argue that rust has a very strong OO feature set (it just lacks inheritance which is the worst OO feature IMO). It is not seen as an OOP language as it also has a very strong functional and procedural feature set as well and does not favor one over the other letting you code in any style that best fits the problem you have.

So I would not say OO and a borrow checker are impossible or even hard. What makes less sense is a GC and the borrow checker. Though there are some use cases for having a GC for a subset of a program.

And if you only have one layer then why not just use interfaces/traits? Which are a vastly better design than inheritance.

How do C and C++ try to restrict mutability?

IMO rust does use OOP styles all over the place. OOP does not mean dynamic dispatch or inheritance - that is just what older popular languages used. Note that static dispatch and monomorphization (where the compiler generates a method for each type at compile time rather than using a runtime lookup) give you a lot of the benefits of dynamic dispatch at the cost of binary size in favor of runtime checks and performance.

And other aspects of OOP, like encapsulation, data abstractions and polymorphism are easily achievable in rust and often are. Just look at any object from the std library - they are all essentially written in an OOP style. Such as Vec or File - hidden internal state with traits that you can swap them around with other parts that make sense. The only thing it really likes - like Go lang (which claims to be an OOP style language) is inheritance.

And the only reason rust is not seen as or describes itself as an OOP language is because it does not force the OOP style on you. But instead lets you program in more of a functional or procedural style if you want to. You can pick the best methodology to solve the problem you have at hand rather than trying to fir everything into a single style.

But that does not make it bad at OOP style.

Inheritance is isn’t always a terrible choice. But it is a terrible choice often enough that we need to warn the next generation.

But also, when it is not a terrible choice for a problem it is often not the best choice or at the very least equally good as other options that work in vastly more cases.

Note that I am explicitly calling out inheritance here rather than OOP as a whole. There are many things about OOP that are not that bad or quite ok, like composition for instance. It is generally badly designed inheritance that leads to

require tons of internal knowledge about how the classes work

And it is very hard to create a good inheritance structure that does not devolve over time as new requirements get added. While there are other patterns that OOP languages have started to adopt in more recent years (like composition and interfaces) that solve a lot of the same problems but in a vastly more maintainable way.

I think a lot of people conflate OOP and inheritance to mean the same thing. And inheritance is what should get the bad rap. It does not solve any problem I have seen any better than other language features (in particular interfaces/traits can solve a lot of the same problems) but inheritance causes far more problems overall.

But building the code out of logical units with fenced responisbilities is in my opinion a good way to structure code.

This is encapsulation, which is one of the better ideas from OOP languages. Though also not unique to them.

And I have a hard time to wrap my mind around some design choices in the language that would have been very easily solved with a more OOP like structure.

What design choices would those be? And how would they better fit into an OOP like structure? Note that rust is not anti OOP - it uses OOP techniques a lot throughout the code base. It just lack inheritance and replaces that with other IMO better features.

It requires you model your problem perfectly from the start, then it can work alright. But in reality you cannot know the future and when new requirements come in that don’t fit the model you created you are left in a crappy spot of needing to refactor everything or just cram it in however you can.

So the easy way is to inherit and extend to a custom type while keeping the original functionality intact.

You can do this with traits and interfaces in rust/go. You can add any methods you want onto existing types. Which IMO is better. No need to subclass, in just just create a new trait, implement it on the type you want and you have new behavior attached to that type without needing to convert the existing thing you got from something into a new type.

And I think the trait system (in Rust for example) creates so much duplicate or boilerplate code.

It really does not. You can have implementation on traits that don’t need to be re-implemented on every type - like the Iterator - it provides 76 methods of which you need to implement only 1 for new types. You can implement others for custom behavior which is great for specialization (aka using a more efficient implementation for types that have more info, like calling skip on an array which knows all its elements vs the default which needs to call next n times).

But it creates a vastly more flexible system. Take a very basic example - read/writing to something. How do you model that with inheritance? Basically you cannot. Not without painting yourself into a corner eventually. For instance, you can read/write to a file, to a network socket, to stdin/stdout but each of these is very different. Stdin for instance cannot be written to and Stdout cannot be read from. You might want to have a buffered reader/writer as well that wraps these types making read operation cheaper.

You cannot put these into a inheritance tree. Everything either needs to inherit from the same generic base that can both read/write and probably also close. But then for some types you need to implement these methods that don’t make sense that do what? Nothing when called? or throw an exception? It is a poor way to model this behavior.

Read and Write are orthogonal ideas - they have nothing to do with each other except they might be useful on some of the same types. With interfaces/traits you are free to separate these and implement them on whichever types make sense for them.

I have not yet seen a problem that is solvable with inheritance that cannot be better solved with some other language feature in a better way. It sort of works for some things, but other solutions also work at least equally well. Which leave it in a state where what is the point of it? If it is not solving things better then other solutions we have these days?

Inheritance, which allows classes to reuse state and methods of other classes.

This is the absolute worst feature of typical OOP languages. I don’t know of any case where it is the best way to solve a problem and very often becomes a nightmare if you don’t get the exact hierarchy of types right. It becomes a nightmare once you have something that does not quite fit into the assumptions you original made when you started out. Which happens all the time.

The examples given with the logger can be solved just as well if not better with interfaces/traits with solutions that don’t have that problem.

Oh they care. They care a lot. Particularly that you don’t have any so they can sell all your details to any bidder.

I don’t think data races are generally considered a memory safety issue. And a lot of languages do not do much to prevent them but are still widely considered memory safe.

How are they not memory safe in a multi-threadded context?