Dunno why you're being downvoted. It's very obviously deliberately chosen to make 12 year olds giggle.
I wish we had something like McMaster Carr in the UK. I don't even care if it's fast! You guys had better appreciate how good you've got it.
Oh cool how do I run VSCode in Termux?
One of the things I hate about merge-based Git workflows is git makes a default Merge 123234234 from user/dave/fsdf
message which:
a) Is shit - it contains zero useful information (what's in the change??) and contains information you explicitly don't care about (the temporary branch name the author happened to use). a) Makes people think they are supposed to use that message.
It would probably be better if the default message was blank. But also squash & rebase is generally better anyway and it avoids this problem entirely.
You seem to have the idea that there are "people who want RT" and they'll overcome any inconvenience to get it, therefore making RT more convenient to use won't increase use of it.
Clearly nonsense, and I think the GPS analogy is a good one. My mum isn't "a person who wants GPS" and she would never have bought a GPS device in the 00s, but she uses one now because it's conveniently already available in her phone.
He never said it was an Internet Draft. Try actually reading. It might help you in the future when you are discussing things.
I've heard they also removed good reviews if you don't pay them, so... yeah I don't think you can really learn anything from TrustPilot.
Yes. For the project I work on pip install
takes about 60 seconds and replacing it with uv
reduces that to about 7 seconds. That's a very significant improvement. Much less annoying interactively and in CI we do this multiple times so it saves a significant chunk of time.
I disagree. It's a sign your code isn't structured in a way that the borrow checker understands, but that is a subset of well-structured code.
In other words, if your code nicely fits with the borrow checker then it's likely well structured, but the inverse is not necessarily true.
One thing I always run into is using lambdas to reduce code duplication within a function. For example writing a RLE encoder:
fn encode(data: &[u8]) -> Vec<u8> {
let mut out = Vec::new();
let mut repeat_count = 0;
let mut output_repeat = || {
out.push(... repeat_count ...);
};
for d in data {
output_repeat();
...
}
output_repeat();
out
}
This is a pretty common pattern where you have a "pending" thing and need to resolve it in the loop and after the loop. In C++ you can easily use lambdas like this to avoid duplication.
Doesn't work in Rust though even though it's totally fine, because the borrow checker isn't smart enough. Instead I always end up defining inline functions and explicitly passing the parameters (&mut out
) in. It's much less ergonomic.
(If anyone has any better ideas how to solve this problem btw I'm all ears - I've never heard anyone even mention this issue in Rust.)
only access secrets from environment variables
I kind of think this is a bad idea because environment variables can be read from anywhere and aren't designed to be secret.
But I'm not sure what a better solution is tbh.
I never did a CS degree but recently I've been doing some things that make me wish I had. But it isn't any of this stuff which seems mostly programming things that you can easily learn outside academia.
The stuff I would like to understand which I haven't yet been able to learn on my own is the hard computer sciency stuff: lambda calculus, type inference (how do you read that weird judgement syntax?), how SAT/SMT solvers work, dependent typing systems... Does anyone have any good resources for those sorts of things?
Nope. Specs can have bugs. Here are the bugs in the C++ spec for example:
https://www.open-std.org/jtc1/sc22/wg21/docs/cwg_toc.html
As I said, specifications are useful and desirable, but the SIL's dogmatic "no spec = unsafe" is clearly not based in reality.