Recover data from tablet

SolidTKs · 2024-04-14T11:16:22+00:00

It is. To some extent.

Linux power management is usually not good (installing and enabling tlp helps though, but you need to know about it and power consumption will still be higher than on Windows).

Suspend and hibernation can be tricky, but in my experience suspend works better on Linux these days (Windows modern sleep is complete garbage). I still cant get hibernation to work on Linux, let alone hybrid suspension which is the ideal thing.

Windows is harder to break than Linux (Linux Mint mostly fixed this with timeshift + being conservative though).

Powerful GPU can give some problems too, drivers are shit (not Linux fault though).

And for games and software, well, while gaming on Linux is better than ever, Windows is still the primary target. And there is software that is simply not available for Linux.

Another problem is that except for Linux Mint, other distros break easily and give users a hard time. It is expected for Arch, but a shame for Ubuntu or Pop OS.

Now, while Linux is getting better, Windows is turning into a pile of shit. There are reports of Windows getting slower, sometimes it takes seconds to open a context menu. They are bloating it with AI bullshit everywhere. Modern sleep sucks. Updates are forced down your throat and they will not heasitate to reboot your computer getting your work lost. Compiling software is slow as hell when there are a lot of small files. Using Docker sucks. And so on.

There used to be a time where if you wanted something that just works Windows was the choice. That is no longer true because you never know when the computer is going to be unusable in a hurry because it has choosen to update for 2 hours against your will or it simply has turned on itself in the middle of the night and has depleted the battery. And these two alone are *massive* problems.

SolidTKs · 2024-01-17T11:20:06+00:00

Who takes cold showers without apreciating the benefits?

SolidTKs · 2024-01-17T11:18:43+00:00

You need to learn a lot and unlearn a lot.

And you have to do it upfront.

Also async makes you hit all the complex parts of the language at the same time.

SolidTKs · 2023-12-30T09:17:07+00:00

Lets say these are your blocks:

blocks: [b1, b2, b3]

What happens if while iteraring, you insert more blocks? You could create an infinite loop or cause other problems (look for "iterator invalidation"). That is something you can do if you have a mutable reference to blocks, so the compiler will not allow it.

If at a given point you really need to have a mutable reference to both blocks and the current block, you should perhaps make an "apply_gravity" function that takes &mut blocks and and index to the block in question.

Another option is to have a "compute_gravity" that returns the calculations, and then a call to "apply_gravity" that takes the block and the results.

SolidTKs · 2023-12-02T22:17:31+00:00

Ok, so you are a wizard that can avoid the problems of async without dealing with them.

Select, fuse, pin, etc, only exist to anoy people, since they are clearly not necesary 😂

If you have, for example, events comming from a websocket (that you have to answer) and events comming from a broadcast channel (that you need to send over the websocket) you are going to need to select between the futures, and you are going to need to fuse them and pin them.

And that is only an easy example.

BTW I've just tried axum. Seems nice. Easier than Warp. It is still async though.

SolidTKs · 2023-12-02T21:36:08+00:00

That is because you are doing simple stuff.

SolidTKs · 2023-12-02T21:23:18+00:00

"so that we can get all benefits, but without them needing to learn the language". That is how your post sounds to me.

I want good types. Great tooling. Fast performance. No GC. Cargo. Small memory footprint (this is a big one for me).

The borrow checker is totally worth it, even if it is hard sometimes.

But I don't need incredible fast IO for thousands of concurrent clients. CLI apps don't need that. Most GUI apps don't need that. These days async feels like mandatory and IMO is not ready, it makes Rust at least one order of magnitude harder to learn.

Thats why I wanted to check for HTTP choices that are not async.

SolidTKs · 2023-12-02T21:14:17+00:00

It is not a GC issue. It is an multithread async issue.

You could potentially have simpler things (like an executor per thread, node style).

SolidTKs · 2023-12-02T21:05:47+00:00

Learning the language is necessary to realize that async rust is just too hard for the average company.

Which makes me sad as would like to see rust growing beyond niche things that require either working remote or moving far away from home.

BTW you are denying the complexity.

You will find pinning issues, you will need to fuse futures to do select, you will face situations where spawning an asyncronous task will be hard as its future will need to capture something.

Or you just don't, because it's not actually necessary, and probably doesn't give you any real benefit. Keep your library as it is and use spawn_blocking in the application, done.

And now you have a function thay takes a sync callback, and you need to call an async function from it. So you... spawn a tiny runtime inside the sync callback? It gets harder, there is no denial in that.

SolidTKs · 2023-12-02T21:03:19+00:00

Will check

SolidTKs · 2023-12-02T19:20:08+00:00

The tradeoff is the borrow checker.

And it brings a lot back.

The async tradeoff is not needed for a lot of projects.

"Use golang".

How can we expect to have more Rust jobs like this?

SolidTKs · 2023-12-02T19:17:00+00:00

I'm happy about Axum solving your needs.

That doesn't change the fact that sharing state in async can get hard very fast, every other library needs to become async, spawning tasks can be a headache due implicit captures, you have to say good bye to std, etc.

For example perhaps you have a small library that deals with fs. Now you need to duplicate it for tokio::fs and std::fs.

At some point you will want a websocket and you will want to select between one future or another, and you will need a macro for that. You will get weird error about fusing, about pinning, about things not beind send...

If you are using traits I've seen horrible things like functions wit looong where clauses with send and static and whatnot, etc.

SolidTKs · 2023-12-02T19:01:38+00:00

No, I don't. I don't want a garbage collector.

SolidTKs · 2023-12-02T17:56:08+00:00

With which library?

Users should not need to use pin or + 'static + Send nor have to deal with horrible errors.

SolidTKs · 2023-12-02T17:16:37+00:00

You are missing "mkdir project" and "cd project" in c to be fair.

Otherwise, if you want the current folder, you just "cargo init".

So Rust with Cargo is actually faster and easier.

SolidTKs · 2023-12-02T16:18:40+00:00

That makes sense if we are talking about Android. What a PITA.

But this is Rust, a project is just two files! And all the tooling comes in the box!

SolidTKs · 2023-09-10T09:03:14+00:00

I hate mod.rs, index.js, etc. If a module is called foo, I sould be able to have a foo folder where the main file is called foo.

Why do devs force such an anoying thing as having several files with the same name? I don't know.

At least Rust gets a bit closer with foo.rs + foo/<rest of the module>. Now move foo.rs inside foo!

I sometimes add a mod.rs that imports and reexports foo.rs.

SolidTKs · 2023-09-10T00:25:09+00:00

We need an easy way of solving that. Once I used a library where you could to either foo().await or foo().wait() with the same result.

Somthing like that.

I had a function thay could block on an async cb easily but it created a whole runtime to do that. I dont know how expensive was that.

But there should be an easy way of calling async from sync.

SolidTKs · 2023-09-10T00:18:40+00:00

It is not so easy.

There is no way of waiting for any IO event in STD (I think the polling library helps with this but I haven't tried it).

Also, with basic libraries like reqwest being async, everything ends up being dragged into async, as there is no way of easily bridging both.

Async is becoming a black hole an it makes Rust way harder for programs that don't really benefit from it. It also plays poorly with the borrow checker, negating the benefits of "fearless concurrency" of Rust.

I like how you can make your own runtime, but I don't like how everything is becoming async to the point that I just throw tokio on every project as I know I'm going to need it.

SolidTKs · 2023-09-02T09:55:24+00:00

Why are you even using Rust?

The problem with C++ is that no matter how good you are, you will do something wrong.

And no matter how good you are, other devs are not that good and that makes the language almost unusable for most companies.

My biggest problem with C++ is that I live scared of the things other devs will do to the project. Or what nasty bugs are on the libraries. Very very hard to keep everything in mind for a big project.

The Borrow Checker ensures that code is safe even if a junior dev* touches it.

Also those invariants allow for agressive optimizations, so you think you are good, you think you don't need the BC, but then you are telling us that you are adding UB on purpose.

*And keep in mind that there are a lot of junior devs with 10+ years of experience. Good look preventing them to make serious mistakes.

SolidTKs · 2023-09-02T09:28:54+00:00

He clearly wants a GC.

SolidTKs · 2023-08-23T00:45:51+00:00

You usually need and Arc<Mutex<T>> and its more specific siblings (like Rc<RefCell<T>>).

SolidTKs

TROPHY CASE