mirashii

> Polars biggest downfall is that pandas/matplotlib are so ubiquitous in data science and polars just plays so differently than pandas including using hvplot as its default plotting package, etc.

huh? Polars doesn't have a default plotting package, it's always something you add. matplotlib supports polars out of the box through the dataframe exchange protocol, which is ubiquitous enough due to the proliferation of other dataframe libraries (dask, vaex, modin/ray) that you really get about every other tool in the ecosystem with polars for free.

Polars is a Python library as well as a Rust library, and most of its use comes through the Python library.

One example is reimplementing coverage.py with this, as its made to reduce overhead for the types of tools enumerated in the docs.

https://nedbatchelder.com/blog/202312/coveragepy_with_sysmon...

Sure, but that's not really the point of my comment. The author suggested this helps reproducibility in some way, and I'm trying to understand how this is supposed to help, when on its face, it can only hurt.

> The goal in a way is better reproducibility. The memo hashes the contents of the inputs, so if your cell is deterministic (and you cover all the inputs), the memo should give you the right answers.

That's an enormously large if, and without any way to detect or manage when that's not the case, it's hard to see how this could aid reproducibility. This adds a new failure mode for reproducibility where an important side-effect is not rerun, altering the results.

This isn’t about cloning an image, it’s the full running VM state, including memory.

Devil's advocate, using WASI assume there are no bugs in the new specifications or anything that implements those specifications. We already have a variety of tools to sandbox processes, by implementing and adopting WASI, you're needlessly adding a huge attack surface.

More likely things like https://heroicgameslauncher.com/

And by implicitly trusting authority, you mean trusting the device manufacturer with billions of sales and intense scrutiny from security researchers and state actors spanning decades, right? You mean trusting the entire of the security industry to have managed not to miss this glaring and easy to detect invasion or privacy? This isn’t “it’s not happening because Apple promises it’s not”. This is one of the most scrutinized platforms in the world. Making wild claims and disavowing them immediately is lazy rhetoric, just as oversimplifying this as an appeal to authority is lazy rhetoric.

There's actually still plenty of insane things about None in Python. https://peps.python.org/pep-0661/ is a great example of that.

> Sibling comments mentioned Option types, which are assumed the currently best approach

Option types are actually just the tip of the iceberg though. The real power is in languages that support algebraic data types. Option is just one common example, used to distinguish between just Some and None, but it's reasonable to have an enum with other states, each optionally with its own associated data.

Waiting til 20 works only if you're willing to wait to accept the benefits of US Citizenship until you are 20. My mother was in this category, and shortly after she registered to vote in the US, she received a letter stating that her Japanese citizenship was therefore revoked.

Agreed, doing sd 'search' 'replace' **.py is common in my history. I only mention fd + xargs as a backup for when you need to do something that a simple shell expansion won't cover.

Also, for a "confirm your changes" type workflow, I like git add -p after running the sd command just to review all of the changes.

I'll throw in sd as a nice sed/find-and-replace tool. Using fd + xargs + sd is a pretty good workflow if a shell glob isn't good enough to target the files you want. https://github.com/chmln/sd

Not with DNS blocking, which is what the pihole is

Just wanted to note Go does only a partial monomorphization, only monomorhpizes for gcshapes and not for all types. This severely limits the optimization potential and adds a runtime cost to dispatch, at least in its initial implementation.

https://github.com/golang/proposal/blob/master/design/generi...

Profiling the compilation process suggests that this isn't the case. Rust's higher level passes are rarely the dominant part of execution time.

Check out https://github.com/lqd/rustc-benchmarking-data/tree/main/res... and the other benchmarks in that repository for some data on how real world crates compilation times are spent. You'll find that backend code generation and optimization dominate most crates compile times. There are a few exceptions: particularly macro heavy crates, a couple crates with deeply nested types that hit some quadratic behavior in the compiler. But overall, the backend is still the largest piece.

It’s not go as a literal replacement for bash, as in you write golang when interacting with your own machine. It’s go binaries instead of bash scripts. You’re still distributing one file, but now with all the GP’s stated benefits

Although not out of the box right now, it requires running some external scripts to grab guest accounts and running a build off a branch or fork. See https://github.com/zedeus/nitter/issues/983

The notion that one should always pin their dependency version falls apart when considering that package managers like cargo when considering libraries. Libraries hard pinning dependencies causes a world of trouble.

This is exactly why cargo uses a lock file that does pin your dependencies as described for binary crates, but does not use the same mechanism for libraries. https://doc.rust-lang.org/cargo/faq.html#why-do-binaries-hav...

https://github.com/gorhill/uBlock/wiki/uBlock-Origin-works-b... explains a variety of techniques uBlock Origin implements in Firefox that are not supported in Chrome, with some statistics about what percentage of ads those are.

No, it signals that that manufacturer didn’t follow the established process for certification.

What evidence is there that anyone is picking and choosing?

From the article you linked:

> João Goulão — head of Portugal’s national institute on drug use and the architect of decriminalization — admitted to the local press in December that “what we have today no longer serves as an example to anyone.” Rather than fault the policy, however, he blames a lack of funding.

> Twenty years ago, “we were quite successful in dealing with the big problem, the epidemic of heroin use and all the related effects,” Goulão said in an interview with The Washington Post. “But we have had a kind of disinvestment, a freezing in our response … and we lost some efficacy.”

The story turns out to be much the same as a common trope for those who wish to undo successful policies here in the US: under-fund them as sabotage, and then call them failed when the lack of funding causes lower efficacy. Additionally, prohibitionist policies and the policing drug use has been rising (see 24,25,26 at https://substanceabusepolicy.biomedcentral.com/articles/10.1...) over the second half of the time drugs have been decriminalized, so the rollbacks in societal gains need to be taken with a grain of salt.

Paperless-ngx supports a folder on disk that you can drop files into and have them ingested. Throw in a samba container pointed at the same directory in your docker-compose and you’ve replicated the same setup.

The update emails through this kickstarter have been fantastic. Tons of fascinating details on the process, little previews of content, and interesting insights. Would highly recommend.

Most of this post is verifiably not true with a quick search.

> rejected from steam with no explanation beyond "it appears your game contains AI generated content." They say nothing beyond that.

Their actual message, which has more details, can be found at https://www.reddit.com/r/aigamedev/comments/142j3yt/valve_is.... One important quote:

> In particular, [Game Name Here] contains art assets generated by artificial intelligence that appears to be relying on copyrighted material owned by third parties. As the legal ownership of such AI-generated art is unclear, we cannot ship your game while it contains these AI-generated assets

Additionally, Valve has put out a number of clarifying responses to journalists.

https://www.polygon.com/ai-artificial-intelligence/23783520/... https://www.theverge.com/2023/7/1/23781339/valve-steam-ai-ar...

This is a... very consumer-centric view of the landscape of routers, not really all that applicable to businesses and enterprises.

> Unity would now prefer you give them the information yourself.

I’m sure they’d prefer to capture the data themselves, but they’re now allowing you to self report in order to placate the outrage from the recent announcements.

It’s about a 10 line nix file, a 10 line dockerfile, a one line rust-toolchain.toml.

> it works with rust 1.72.0; tomorrow I slightly change function by splitting a statement into two, and now suddently the evaluation becomes too long and my dependents don't compile anymore.

Just to be clear, this was the case before the new changes in 1.72. They already had that limit, and code could break in exactly that way. There were two problems with that beyond the simple backwards compatibility break. One is that there was no opt out, so if you broke you were kinda hosed at the library level. The second is that the limit was relatively low and so it was very possible to hit it.

Now if you end up running too long and the compiler fails, you’ve at least got an opt out, and the limit before failure is much higher.