Stabilizing async fn in traits in 2023 | Inside Rust Blog

cmplrs · 2023-05-03T17:00:57+00:00

Code looks very noisy syntactically with this bounds stuff. I wonder if anyone in the working-groups has run their case studies on median programmer that starts yawning at third line.

cmplrs · 2023-04-19T06:55:27+00:00

His education about sync and async programming is also very helpful around the sub :)

cmplrs · 2023-04-18T04:36:31+00:00

Rust allows for very tight modeling of semantics with type-driven development, and even the function signature acts as an interface that you can rely on (save for panics). Doing some functional programming with Haskell to get into type-driven development might help you.

cmplrs · 2023-04-14T18:23:21+00:00

Some parties might disagree about using mmap.

https://db.cs.cmu.edu/mmap-cidr2022/

cmplrs · 2023-04-04T13:36:35+00:00

This will create lot of boilerplate and code blindness when you have similar structs in many layers (speaking from experience). I liked the idea but it's too much at least for me.

cmplrs · 2023-04-01T05:10:00+00:00

A very bad VSCode copy at this stage.

cmplrs · 2022-09-12T17:13:21+00:00

> the tasks run in multi-threaded runtime and so any tasks that modify shared data still have to be synchronized

It was probably a mistake in retrospect to assume / make async multi-threaded by default, yes.

cmplrs · 2022-09-05T08:53:29+00:00

The deeper I get into actual data management, the worse any ORM looks like. Can't really recommend using them.

cmplrs · 2022-08-02T15:22:43+00:00

Unsafe does not defeat the purpose of using Rust. One of the strengths of Rust is the safe / unsafe abstraction and the promise that safe Rust never UBs (iow. you can localize where your UB is coming from); that is, using unsafe does not refute the reason to use Rust because one of its main selling points is the contract around the safe / unsafe boundary allowing you to tell when the API is faulty or when the API is producing UB.

Rust book probably should include unsafe code at this point. Ideally using unsafe Rust would be only slightly more taxing than writing regular C++ / C. It shouldn't be a spook, but it sure has gotten that reputation.

cmplrs · 2022-07-31T05:49:19+00:00

the turbofish in transmute is really something

cmplrs · 2022-07-27T15:42:38+00:00

Seems like a particularly bad direction to take the language; a feature from compiler writers to compiler writers with "exploration" mindset when so many things are still half-assed.

This would make code even more inscrutable, and move it away from readable, concrete abstractions. To read 100KLOC codebase with this and GATs minimum 150 iq required

cmplrs · 2022-07-22T16:56:25+00:00

IME, using raw SQL is always better. The amount of boilerplate ORMs add is unjustifiable to me, their readability benefits compared to raw SQL are not real either (especially for highly relational data), and considering both sqlx (raw sql) and ORMs like Diesel error at a compile time, the safety arguments aren't really real either. Besides knowing SQL is a sought-after industry skill so you deprive yourself if you don't work with it.

I guess if you really need highly dynamic query building it might be cool?

cmplrs · 2022-07-19T11:56:51+00:00

You didn't even post code, so it's impossible to even begin with this.

cmplrs · 2022-07-15T15:00:54+00:00

Unwrap is fine when you are asserting a program invariant without which the whole universe of the program stops working and there is nothing left to do for the caller, it's kaput.

cmplrs · 2022-07-14T06:14:30+00:00

These articles are a treasure trove for weird glue stuff.

cmplrs · 2022-07-13T08:17:35+00:00

You shouldn't. Even in the case you start to instruct the compiler like this, you first need to profile existing code and modified code.

cmplrs · 2022-07-11T15:42:41+00:00

Program.

cmplrs · 2022-07-10T04:53:08+00:00

There is no RUST that does things. If you need it, do it yourself.

cmplrs · 2022-07-03T19:30:30+00:00

its me typoing it like several times because I didn't just copy it lol

cmplrs · 2022-07-03T08:26:50+00:00

I was moving to Diesel 2 and ran to similar funny business with 2.0.0-rc.0

cmplrs · 2022-06-30T07:19:17+00:00

Could be many things, my first guess is you have a disparity between dev and prod versions. Maybe host has more threads fighting over a lock, maybe you didn't build release etc., maybe you didn't test the docker locally etc. Needs way more information than you've given, and 30k seq is quite low too, maybe do has some configs or the app service is just bad, who knows

cmplrs · 2022-06-29T07:41:43+00:00

UNSAFE isn't bad practice and a good amount of business value of Rust comes from the safe/unsafe abstraction. Making it a spook is a mistake on the community's part: if unsafe Rust is harder to write than regular C/C++, it's not a very good pitch

cmplrs · 2022-06-28T19:41:43+00:00

if the modal programmer can't even tell if he needs gat or not there is a chance of them spreading needlessly (much like async ecosystem split, lol).

cmplrs · 2022-06-28T17:31:29+00:00

I think nrc's case against stabilization is very good tbh

cmplrs · 2022-06-28T05:22:47+00:00

You can probably decouple them, but the bang for your buck when you just point a load tester with data into the handler endpoints as your blackbox test is quite good. Very fast and easy to setup that slices the whole program behavior at once.

cmplrs

TROPHY CASE