Gavin Zhao @[email protected]

Fabulous 😭

“When drivers fail to yield for pedestrians, it’s not because they can’t see them, it’s because they don’t care.” Kudos to @VisionZeroYVR for this brilliant intervention. https://momentummag.com/vision-zero-campaign-bricks-vancouver/ #TheWarOnCars

Do you want to stop "supply chain compromises" as a company? Here's a very simple way to do so: pay a stipend to a maintainer of something you depend on.

You don't really need dependency tracking tools. You don't need to exactly parcel out the 'right' proportionate amount of money to every maintainer. All of that operational complexity is unnecessary.

It doesn't even matter *which* maintainer you pick, as long as it's one who isn't receiving a stipend yet, and you pay them enough to constitute a salary.

It will cost you exactly one developer salary. If every able company does this, the problem of supply chain compromises is solved tomorrow.

All you need to do is simply *do it*, and talk about it so that other companies will too.

If you had code on GitHub at any point it looks like it might be included in a large dataset called “The Stack” — If you want your code removed from this massive “ai” training data go here:

https://huggingface.co/spaces/bigcode/in-the-stack

I found two of my old Github repos in there. Both were deleted last year and both were private. This is a serious breach of trust by Github and @huggingface.

Remove all your code from Github.

CONSENT IS NOT OPT-OUT.

Edit — thanks for all the replies. More context here: https://hachyderm.io/@joeyh/112105744123363587

Also the repos i found of mine i’m sure were private, but even if they were public at some point, for a brief time, in the past that isn’t my consent to use them for purposes beyond their intent.

---
Edit 2 -- I see this made it to HN, which is a level of attention I do not want nor appreciate....

For all those wondering about the private repo issue -- No, I am not 100% sure that these ancient repos weren't at some point public for a split second before I changed it. I do know that they were never meant for this and that one of them didn't even contain any code.

If my accidentally making a repo public for a moment just so happened to overlap with this scraping, then I guess that's possible. But it in no way invalidates the issues, and the anger that i feel about it.

大象岩，古城欧拉，沙特阿拉伯 (© Lubo Ivanko/Shutterstock)

Some of you know today as π-day.

But the real insiders know that today is the 30th anniversary of the 1.0 release of Linux.

Hey look at that, world's first baremetal instalation of Serpent OS

Sandy Gottesman是伯克希尔早期投资者，2022年96岁去世。

去世前，留了一笔钱告诉他的妻子——现年93岁的爱因斯坦医学院前教授Dr. Ruth Gottesman——你觉得这钱怎么花合适就怎么花。

几个小时前，她宣布把这10亿美元捐给医学院。从今年8月开始，所有学生都不需要再支付学费了。

美国私立医学院的四年学费，一般在20万到30万美元之间。 加上四年大学，差不多要40-60万美元左右。

@[email protected] Similarly, Siamese cats are heat maps of themselves ​​

大半夜的，被那个 spam 图片搞的想吃午餐肉了

OpenAI: (chews on dataset)
World: what’s that in your mouth?
OpenAI: (chews faster)
World: WE SAID WHAT’S THAT IN YOUR MOUTH SPIT IT OUT

AMDGPU LLVM Adding GFX 9/10/11 "Generic Targets" To Build Once & Run On Multiple GPUs

Code merged today to mainline LLVM is preparing for the notion of generic targets across the GFX9, GFX10, and GFX11 GPU families. With follow-on work these generic targets are aiming to allow compiling code once and then running across multiple GPUs in the given hardware family...
https://www.phoronix.com/news/LLVM-AMDGPU-Generic-GFX

the trouble with writing is that it's literally always easier to lie on the floor making seal noises

Heya, folks! We want to start the new year off right, and what better way to do that than a new Solus release? That's right, Solus 4.5 Resilience is now available to everyone! A ton of work has gone into this release, including a new installer with #Calamares, and a new #XFCE Edition!

Blog post: https://getsol.us/2024/01/08/solus-4-5-released/
Downloads page: https://getsol.us/download/

#Solus #Linux #OpenSource #foss #Resilience

- Evan

Like when I can’t get Rust to work it’s usually because it’s stopping me from doing something dumb, whereas when I can’t get C to work it’s always because it has allowed me to do something extremely dumb.

圣诞节快乐

Announcing the official release of Fedora Asahi Remix 39!

Props to the Asahi Linux project and the Fedora Asahi SIG for all their work in providing a stable Linux experience on Apple Silicon.

* All MacBook Air, MacBook Pro, Mac Mini, Mac Studio and iMac systems with M1 and M2 chips are supported
* KDE Plasma is the default desktop environment
* Wayland enabled by default
* The speakers work, baby!

Announcement: https://fedoramagazine.org/introducing-fedora-asahi-remix-39/
Download: https://asahilinux.org/fedora/

#Fedora #Asahi #Linux

join the petition to tax higher order functions from programming! don't let devs get away without paying maintenance tax when they casually add a continuation parameter and pass a function defined 100k lines away in the codebase

The #Lean4 project to formalize the proof of the Polynomial Freiman-Ruzsa conjecture has succeeded after three weeks, with the dependency graph completely covered in a lovely shade of green: https://teorth.github.io/pfr/blueprint/dep_graph_document.html , and the Lean compiler reporting that the conjecture follows from standard axioms.

More discussion on the project can be found at https://leanprover.zulipchat.com/#narrow/stream/412902-Polynomial-Freiman-Ruzsa-conjecture/topic/Project.20completed!.20.20Thoughts.20and.20reflections.3F

ghc wasm backend jsffi has finally been implemented! the rest is source notes as well as user-facing documentation. not sending a #haskell discourse thread yet, but for the curious eyes, here's what's supported so far (and also an ama thread):

1. calling sync js function

foreign import javascript unsafe "console.log($1)" js_log :: JSVal -> IO ()

js src text can be any valid js expr or statements, using $1 etc to refer to the haskell arguments. JSVals are first class haskell values and garbage collected.

2. calling async js function

foreign import javascript "fetch($1)" js_fetch :: JSString -> IO JSVal

await is supported in js src text. calling it initiates the side effect immediately, and returns a thunk that only blocks on promise resolution when forced, allowing concurrency without even needing to fork haskell threads. promise rejections are captured as haskell exceptions.

3. js callback -> haskell function

foreign import javascript "dynamic" js2hs :: JSVal -> Arg1 -> Arg2 -> Result

pretty much same thing like "dynamic" ccalls, though we use JSVal to represent a js callback instead of FunPtr.

4. hs function -> js callback

foreign import javascript "wrapper" hs2hs :: (Arg1 -> Arg2 -> Result) -> IO JSVal

yup, this converts any haskell function closure to a js callback that you can pass to 3rd party frameworks. it's garbage collected on the js side as well, the haskell closure will be dropped if the callback is unreachable in js later.

5. foreign exports

foreign export javascript "js_func_name" hs_func_name :: Arg1 -> Arg2 -> Result

this will end up as a wasm export named "js_func_name" directly callable in js, and it returns a promise of the final result that can be awaited.

the hardest part of all the above work is concurrency & re-entrancy: calling async js should be cheap, should not block the runtime, should play well with existing threading model in haskell. and hs can call into js that calls back into hs, indefinitely. i'll write up more detailed explanation on how this is delivered