From the makers of “fusion energy in 20 years”, “full self driving next year” and “AI will take your job in 3 months” cones “all code will be AI in 6 months”.
Trust me, it’s for real this time. The new healthcare system is 2 weeks away.
EDIT: how could I forget “graphene is going to come out of the lab soon and we’ll have transparent flexible screens that consume 0 electricity” and “researches find new battery technology that has twice the capacity as lithium”
Well, the closure has a type. Just you cannot declare it. That’s why you do “impl Fn” instead. Because you know that whatever type the close is, it implements the “Fn” trait.
The “drop the array and slice syntax” is just nuts. With 0 justification.
I haven’t done the experiment, I’m curious to know if you can take a random binary compiled for Linux 10 years ago run on the latest version of popular distros. See in which ones it runs.
Non profits do have corporate leeches too. The executives at Mozilla have executive salaries. That is, hundreds of thousands, or millions.
They don’t work out of the goodness of their hearts. And Mozilla has to find a way to earn the income to pay their bloated salaries.
Your Airbnb was someone’s home.
I’m not talking about the technical possibility. Of course you can have multiple video stream, one per participant.
I’m saying that without multicast, it can be more resource intensive than having intermediate servers that can multicast on the application layer.
Is a connection between 3+ people still p2p? Or is there another term for it?
I don’t know how this would work over the internet though.
On a LAN you could use multicast, but I don’t think ISPs support multicast, it seems like it would be an easy way to DoS. But I honestly don’t know.
So, if you can’t multicast, the way to have serverless multi-user video calls would be to have a separate video feed for each receiver, which I can see using more resources than through a server that would replicate the stream to all the receivers. Of course this is dependant on distance, even without multicast it consumes more resources if everyone is in the same LAN.
Slice as chunks is huge. I would prefer an unsafe &[T] as &[T;N], but this can be used for that too.
I’m surprised they at least know they have a problem. I would think these companies would just say “look how the sales numbers haven’t changed, that means that we were correct in doing the AI thing. Without it, sales would be sinking into the ocean!”
And how are women pushed out of “man jobs”?
And how are we fixing that?
Is it bosses that aim to have male coworkers turning down women? How is that different than bosses wanting artificially 50/50 turning down men?
Is it not being represented in advertising? How is that different than what happens now. Where most advertising displays just women? Or if there is both a man and a woman, the woman is usually centered in the picture or doing a more important/powerful role.
By “encouraging” women in the workplace, what you see is things being done to men that you complain was done to women.
In the meantime. This is a valid business model.
Firefox is not chromium based. You can install unlock origin and have no ads.
There’s a reason just in time manufacturing took over the world. Storage is expensive.
The problem might be the arc mutex. mpsc are already clone, send and sync. When you clone an arc mutex T, you are cloning the arc. But mpsc probably needs to be cloned itself to work properly.
Technically, this may sound pedantic. You are not passing neither arrays nor tuples as generic parameter types.
What you are doing is passing an array to a function.
The type of the array is [i32;5]. Every value has a type.
By passing the array to a function, you are allowing the compiler to infer what function you are calling, since that function is generic. Using the type of the parameter you passed to it.
You can only pass values to function parameters. And you can only pass types as generic type parameters.
Well in this case it’s a little different, since it looks like you are passing a value (5) to a generic type parameter (LENGTH), but the const part of const LENGTH means that it’s a value generic for a type, not a type generic for a type, which is the usual thing.
EDIT: additionally, the : usize part tells you what type exactly the const parameter for the type has to be.
Note that you can’t have non-const values as type parameters. Since types are defined at compile time.
EDIT 2: since type inference just fills some boilerplate for you. If we do that boilerplate manually it’s easier to see what parameters go where.
When you do Buffer::from([0,1,2,3,4,5]) what you are really doing is: Buffer<i32, 5>::from([0,1,2,3,4,5)]. In fact, if you put that, the code will compile exactly the same. Now if you put a 6 instead, it won’t compile since the type of the buffer and the type of the array you are passing are not the same.
You don’t need to know at all what optimizations will happen. I said that as an example of a thing that you know in compile time but not in run time.
To tell or not whether a type will be inferred is determined by you. If you tell the compiler the type, it will never be inferred. If you don’t tell the compiler the type, it will try to infer it. If it tries to infer the type but it fails, it will throw a compiler error and it won’t finish building the binary.
The compiler will only successfully infer a type if it has enough information at compile time to know with certainty what type it is. Of course, the compiler is not perfect, so it is possible in complex situations for it to fail even though it theoretically could.
Examples where inferring will succeed:
fn copy<T>(in: T) -> T {
return in;
}
fn main() {
let a = 47; //here a is of type i32, this was not inferred, it's just the default type of integer literals
let b = copy(a); // here the compiler knows that a is i32, therefore it should call copy<i32>. Due to the type signature of copy<i32>, the type of b is inferred to be i32
let c: u16 = 25; // here instead of the default, we manually specify that the type of c is u16
let d = copy(c); // this is the same as b, but instead of calling copy<i32>, copy<u16> is called. Therefore d is inferred to be u16
let e = 60; // at first, this looks like a, and it should be the default of i32
let f: i64 = copy(e); // here, since f is specified to be i64, copy<i64> is called. Therefore e instead of being the default of i32, it is overridden since inference has preference over the default. e is inferred to be i64.
}
Examples where inference will fail
trait Default {
fn default() -> Self
}
impl Default for i32 {
fn default() -> i32 { return 0 }
}
impl Default for i8 {
fn default() -> i8 { return 0}
}
fn main() {
let a: i32 = 8;
let b = copy(a);
let c: u8 = copy(b);
// What type should be inferred to? If it calls copy<i32> because a is i32, then it can't call copy<u8> later to initialize c. And if it calls copy<u8> instead, it can't receive a as an argument since a is i32. Results in compiler error
let d = Default::default();
// What type is d? both i32 and i8 implement the Default trait, each with its own return type.
// let d: i32 = Default::default(); would compile correctly.
}
These situations might be obvious, but inference works as a chain, sometimes hundreds of types are inferred in a single function call. So you should know the basics to diagnose these kinds of problems.
Since deadcream already told you the reason. I’m gonna explain a more generic way.
There are 2 important times: compilation time and run time.
At compilation time, everything that is constant, is known to the compiler, or can be calculated by it.
At run time, everything* is known.
Types have to be generated at compilation time**. This means that generics have to be also known at compilation time.
In this case. Both the “T” type of the buffer and its size “LENGTH” are generic, so they must be known at compile time. Compile time usually doesn’t know about vales of variables, except if those variables are “const”. Then it is known. A value literal is the same as a const variable.
So here, you provide a value literal ([0,1,2,3,4]) which is a fixed array, that is, both its “T” type (i32 by default) and length (5) are known at compile time. Buffer has all the information it needs to become a real type instead of a generic one. In this case, the type will be Buffer<i32, 5>
* Things that are optimized out at compile time are not known at runtime, but yes at compile time. For example:
const A: i32 = 5;
const B: i32 = 5+1;
fn main() {
dbg!(B)
}
Since A is never used (except to calculate B, which is const), A is probably optimized out. However, since B is used, there probably is a 6 somewhere in memory. Notice how I say probably since optimizations are optional. Or more optimizations may even remove the 6, and convert it to an ASCII “6” to be printed out.
**While this is always true trait objects (like Box<dyn ToString>) can act like some kind of runtime type, if you need that functionality.
Because then you can’t change your password. Since you would have to decrypt all the hard drives that use windows with that account, and then encrypt them again with the new one.
This also means that if you forget your password you are fucked.
“in 20 years” doesn’t get as much hype as “in 3 months”
Maybe if they said “in 3 months” instead we would’ve actually have had it in 20 years. Seeing how much ai attracts money with these obviously unbelievable promises.