legobmw99

I’m not familiar with Fire, but I assume it uses argparse under the hood? Do you put the Gooey annotation on the function that calls fire.fire?

I think most ball players got J&J, which has a decently lower prevention number. The encouraging news was that they all ended up asymptomatic, which is the next best thing

I think it’s too soon to say, but there seems to be substantial evidence against what you’re claiming. In fact, it may be the opposite entirely:

https://www.biorxiv.org/content/10.1101/2021.04.15.440089v2....

https://www.nejm.org/doi/full/10.1056/NEJMc2032195

To be clear: I’m not arguing your later point. The questions of oversight and liability are very important and under-discussed.

I’ll add an alternative answer to the variety you’ve gotten: functional programming is often given a bad name for not really corresponding to the way computers actually work. When you’re writing C, it can feel like the code you’re writing corresponds directly to the actual physical processes and components of the machine. The more higher level you get, the less you feel that (no Malloc in Java, for example), and functional languages are fully based on a model of computation that isn’t the one we physically have in the real world. This can also lead to speed and memory problems, though I think at this point the compilers for these languages are good enough that this is less of a concern than it may have been.

It’s an interesting example of the Blub paradox [0] as well (Paul Graham’s answer to a similar question, “why doesn’t everyone use Lisp”)

[0] https://wiki.c2.com/?BlubParadox

The history of programming languages is one of my personal interest fields, and I find it fascinating how, 25 years on, many of the most popular languages are still slowly encorporating core features of functional languages like OCaml: records, enumerated (sum or variant) types, pattern matching and destructuring, true tail calls, type inference.

To be clear, I’m in favor of these changes, and I don’t denigrate any existing language for not having them, I just still marvel seeing HN headlines like “Python to get match statement”, “Record Types in Java”, “Tail Call support in Rust” and appreciate all the more the things OCaml (and before it, ML) have gotten right for so long.

> There are no bad programmers, only insufficiently advanced compilers

I know this is meant in jest, but it seems like a pretty good perspective to have on the interplay between learners and the tools they're using

This book is very good. Reading it online is fine, but I highly recommend the curious download it actually run it from your favorite editor

I second Story Graph. Much cleaner, “just works”, and can import all your existing data from goodreads

Students are in the loop in the software - it doesn’t just silently report to teachers. It would be a huge distraction to be accused by the computer of truancy or cheating for no reason

Sadly it’s internal.

I’ve found the xarray docs to be fairly comprehensive, and GitHub issues/stackoverflow fill the gaps.

(Not the OP) I’ve been using xarray for the better part of a year now on some serious scientific projects. It certainly has some pain points and places to grow (it’s still a 0.x release after all), but when it works it’s truly excellent to use. So many things “just work”

From the PEP [1]

> This rule is included to simplify the choice for the user between an assignment statement and an assignment expression -- there is no syntactic position where both are valid.

1: https://www.python.org/dev/peps/pep-0572/