daan

Making sure you are still able to control everything when the network is down seems like a good idea.

In our house, the smart plugs have a physical button that can be used to toggle them on or off. The lights are still connected to a physical power switch, so they can be reset by flipping the switch a few times, in which case they will probably just act as a normal light. Air conditioning units have an IR remote.

In Belgium we have a similar system, also fully open source. It's pretty cool that different countries are going to be using the same system soon.

The only thing that worries me is that the EU has this habit of creating open source libraries and releasing it under a permissive license, which is then incorporated in proprietary apps. This also happened with the corona contact tracing. Germany made their app open source, Belgium didn't, but I could just use the German app instead.

Another example is the Belgian eID stuff. Anything government related uses the open source tech, but ISPs and banks made their own proprietary app that does the same thing, and then everyone started using this crap. Now, the government started paying a third party to make yet another proprietary app that does the same thing, but no one cares about it or uses it.

I doubt Phosh will merge with GNOME, since GNOME Mobile already exists and might even be overtaking Phosh.

I'm currently using GrapheneOS on a Google Pixel 6a (a legitimate way to degoogle, ironic as it may sound). I used to run LineageOS on my previous phone.

I have tried porting pmOS to one of my old phones for fun, but never succeeded unfortunately. Maybe it will be a feasible option in the future?

There's a difference between consuming power to do stuff, and consuming power to charge. More power to charge = faster charging.

Out of curiosity, what kind of phone are you using at the moment, if not an Android phone?

After lots of distro-hopping, using arch for many years, I switched to Fedora and never looked back. I just want things to work, and fixing little issues gets boring really quickly, so I stopped using arch.

No, I phrased that poorly. What I meant is that if you have a struct that has some field (it owns that data), your operations on that data will be methods of that struct, and not some other struct that happens to have a reference to that struct. The latter is something people tend to do in OO languages like Java. In Rust, if a function accesses data, you usually "freshly" borrow from the owner of that data and pass it as argument to that function instead of relying on some "hidden" references somewhere in hidden in an object. Borrows will almost always be short-lived.

I don't know if any of this makes sense, I'm sorry for the bad explanation. It might make more sense if you play with Rust yourself.

When you create an instance of a struct and assign it to a variable or field of another struct, that variable becomes the owner of that value. When you assign it to some other variable or pass it to a function that takes ownership, ownership will move. Otherwise, you will borrow. But there will always only be one owner for each value. That way you know exactly when to free up memory: whenever the owner is dropped.

You can store references in another structure, but you probably don't want to do this most of the time, since it's a major headache to get ownership and lifetimes right. You shouldn't think of references as pointers, but you should think of them as "borrows": you are temporarily borrowing something from the owner, but you can only do so if the owner exists. So you need to statically guarantee that for as long as you borrow it, the owner must be alive, which gets tricky when you store that borrow somewhere in some data structure. In practice, references or borrows will be short-lived, and most operations on data will be done by the owner of that data.

Underneath, references are represented by pointers, but you shouldn't think of them as pointers, but rather as something you have borrowed, so in that sense it's different from C.

Also, Python does use references everywhere, it's just implicit, and depends on the type. Try storing a list in a class: you've just stored a reference to another structure. Most things (e.g. lists, objects) are passed and stored by reference, some types like integers are copied. In Rust, you can choose whether you want to pass by reference, copy or move ownership. At this point we're still at a high level of abstraction, we don't think so much about whether this will be pointers at the low level.

But my main point is that whether you use pointers, references, or whether it's implicit or explicit doesn't make a language slow or fast, it just defines how programs are written. Rust is very fast because it's compiled to machine code and doesn't do garbage collection or have any other overhead from a "runtime". Python is relatively slow because it's interpreted. You could argue that more manual control over references/pointers can make a language faster, but it's not the main contributing factor.

I would argue that on the one hand you could say that the references to objects in garbage collected languages are also pointers.

On the other hand, you could argue that such references are not pointers, but then you might as well argue that references in rust are not pointers.

I just feel like "a language with pointers" is a weird way to describe a language and it isn't really something that causes the language to become fast. Pointers are low level constructs that are used all the time, and whether or not they are abstracted away in the high level language doesn't automatically make it slow or fast.

I'd say that it's fast because it's compiled to machine code and doesn't use garbage collection. But I see what you mean with "pointer-based".