News for hackers. Stuff that matters.
Re:Async Rust doesn't have to be hard by hinkley on Friday June 03, 2022 @09:44PM (#31616028)
There’s a common problem of software design where people believe they need to put their logic and their IO together, and not only is that not true, but it screws up testing, scalability, and feature evolution when you do.

A language that punishes you for not keeping your IO separate? Well, that isn’t necessarily a bad thing. Often when I find people complaining about how hard something is, I find out they’re trying to ice skate uphill, and if they backed up a second and took some advice they wouldn’t be struggling so much.

Re:Async Rust doesn't have to be hard by pjmlp on Saturday June 04, 2022 @05:19AM (#31618466)
Microsoft tried to educate developers with best practices by making WinRT async only and it backfired, despite the tooling available in .NET Native and C++/CX for it.

Similarly the way AsyncTask or GCD worked on mobile platforms before other alternatives came into place. Android even went as far as starting to kill processes that were doing network accesses on the UI thread.

All because most will take the easy path if there is an opportunity to do so.

Re:Async Rust doesn't have to be hard by aaaaaaaaaaab on Saturday June 04, 2022 @06:51AM (#31618915)
If you don’t mix logic with I/O then why do you even need async-await as a language feature? I’m not disagreeing with you, but the whole point of async-await was to be able to mix asynchronous operations into your code without having to turn your logic inside out.

But if you isolate your I/O from your logic, then what benefit do you get from async-await?

I guess it can still make the “I/O logic” code more readable…

Re:Async Rust doesn't have to be hard by hinkley on Saturday June 04, 2022 @01:43PM (#31623155)
IO callbacks don’t compose. That’s why everyone is switching to async await (that, and faddishness). This problem is amplified by mixing business logic and IO, so the motivation is in the wrong place and continues through the refactor because we’re solving only half the problem.

Most of the interesting business logic is collating data from three or four places, and fetching that data sequentially is high latency. So you can do that part asynchronously and then present the input to sequential (pure) code that derives the answer. That pure code is very easy to unit test.

The “problem” is now I have three kinds of code - IO, logic, and orchestration - and people intuit that this is more complicated than the bookkeeping they do and externalization onto others by mashing all three concerns together in one file, and then duplicate it with elaborate fakes in their tests. Which they are hesitant to write or others are hesitant to maintain, leading to low value, high effort tests.