You might even find that there are billions of people still living in societies with some form of traditional gender roles, and it turns out they're not all superstitious rubes!
913 karma · joined May 2, 2013
[ my public key: https://keybase.io/angasp; my proof: https://keybase.io/angasp/sigs/JGo37h7yq1cqScBqR8GSHg9KLsd1lUbJA5Zskx87l-E ]
You might even find that there are billions of people still living in societies with some form of traditional gender roles, and it turns out they're not all superstitious rubes!
F# is probably what you're looking for if you want functional-lite programming with a strong type system, but don't want to deal with the pains caused by static resource management.
> The need to request formal permission also applies to employees offered pay cuts in return for staying at home in cases where the local cost of living is lower than around the office where they are usually based.
To start, this claim is unsourced.
I'm having a hard time interpreting this claim, but it seems like _maybe_ it's saying that FB is requesting individuals who were already approved for remote work to RTO. But it also seems like they're just describing the existing process, which is that if you want to remain remote beyond January 2022, you must be explicitly approved for remote work. Anyway, I can't speak for everyone, but as a remote approved FB employee, I've received no such request to RTO.
[0] https://www.dailymail.co.uk/news/article-10064865/Facebook-g...
https://www.cnbc.com/2021/08/12/facebook-delays-return-to-of...
Even the subhead betrays how weird this journalistic formulation is: "The company beat out Jeff Bezos’ Blue Origin and Dynetics, a defense contractor". Like, ok, who is the CEO of Dynetics? Is it just some "public person" standard - because readers will say "Oh, that guy!"? Or is it because they're the majority shareholders in their respective companies and they do this for any company with a singular majority stake?
Just seems like a weird tic to me.
Hopefully an expansion of remote work can improve this situation.
[1] https://en.wikipedia.org/wiki/Age_and_female_fertility#Quant...
If you're working in some sort of Information technology, you're one of the least expendable employees in the labor market, at least as of March 2020. Only government and finance have lower layoff rates: https://www.bls.gov/news.release/jolts.t05.htm
Forcing dioceses to close and restart from square one doesn't really even hurt any of the people responsible as much as it hurts all the parishioners who now have to bootstrap a brand new diocese. At least when a company files for bankruptcy, the owners' equity is severely damaged. What does a bishop lose? After bankruptcy he probably even retains his position.
- EU Youth Unemployment Rate: August 2019 https://www.statista.com/statistics/266228/youth-unemploymen...
- US Youth Unemployment Rate: November 2018 - December 2019: https://www.statista.com/statistics/217448/seasonally-adjust...
This is why I didn't mention it, but I agree that shared memory and typical uses present a particularly challenging problem for Rust.
In HPC, we're very much interested in GPU compute programming, rather than shader programming. In CUDA codes, you're typically doing transformation from input buffers directly into output buffers from your CUDA kernels. This should immediately raise red flags for a Rust developer - you've got shared, mutable state across threads!
Consider this simple CUDA-ish Rust code with threads independently executing over 0..cuda.len() (ignore the bounds bugs at i = 0 and i = in.len()):
fn stencil(i: usize, in: &[f32], out: &mut [f32]) {
out[i] = (in[i - 1] + in[i] + in[i + 1]) / 3.0;
}
(The `i` is a conceit around computing indexing from thread/block IDs, but the input and output arrays are pretty similar to the style CUDA promotes).It's obvious to me, the programmer, that I don't have any aliasing issue - each thread is only mutating at a single index in the output array. However, Rust is not smart enough to see this. If they allowed the definition of the kernel as is, you could easily write multi-threaded code that has shared mutable access to individual memory locations, violating Rust's memory model. OK, you force the kernel to look more like this, then:
// `in` is the slice of [i-1,i+1]
fn stencil(in: &[f32], out: &mut f32) {
*out = (in[0] + in[1] + in[2]) / 3.0;
}
And you'd enforce Rust's invariants at the kernel launch site, computing the valid slices at some higher level in the library in some "unsafe" code. But this only solves the simple case where you have some array mapping to another array where the index relationship is obvious, and it's easily provable that there are no aliasing issues. Start layering in things like unique indirect indexing, or perhaps non-unique indexing but with atomic reductions, and it becomes difficult to phrase your correct program in a way to safe(!) Rust that is compatible with the borrow checker, at least without having to build a bunch of abstractions to express each of your parallel patterns. Having to build a bunch of bespoke abstractions may not be scalable to the types of developers building big scientific codes.Anyway, I'm curious if the folks at "Embark" have spent any time thinking about the issue of shared, mutable state in GPU programming with Rust. It seems like a deal breaker from where I stand.