dylukes

I've done research involving sampling from all extant notebooks on GitHub and manually analyzing them, and have been a heavy user of them in non-CS research contexts for a long time (and Mathematica notebooks for years before iPython Notebooks grew in popularity).

Having manually sifted through hundreds of randomly sampled notebooks, I feel I can confidently speak on the distribution of characteristics in them, at least up through a couple years ago.

1. Notebooks on GitHub are not necessarily an entirely representative sample of notebooks at large. If the author is putting it on GitHub, there's already a significant selection bias towards certain topics, despite notebooks being used in practically any discipline you can think of at least to some extent.

2. Notebooks in repositories that contain requirements.txt files are a minority and tend to be intended/cleaned up for sharing (itself not the norm).

3. What's more common is just a handful of !pip install at the top.

4. Even more common is just some details on dependencies in an adjoining README.

A very non-trivial chunk of notebooks on GitHub are just copies of the "Hands On ML 3" textbook/exercise set. If my memory serves there are tens of thousands of copies of that one repository. The fork count shown by GitHub doesn't account for the plethora of copies that weren't made using it.

Small quibble: converting a measure to a z-score requires an assumption of normality and that you're considering a population.

For a sample the equivalent is the t-statistic, which indeed IS very often used for p-values (with the ever popular t-test) and has a decently strict list of assumptions (which, like those of [O|W|G]LS are very frequently ignored).

If I'm in the mood for being a little glib... where do you think that Linux distribution that SteamOS is based on got its user-space (or more seriously, its drivers?)

Also: the SteamDeck is by any reasonable standard a console. It just happens to run a windowed environment out of the box. Don't be that guy. If you want to pump Valve, focus instead on their contributions to the Wine project.

What do you think is running on your favorite game consoles (that aren't Xbox)? I'll give you a hint, it isn't Linux.

Nintendo is using a custom OS but with a huge chunk of user space borrowed from FreeBSD. Sony on the other hand just went and forked FreeBSD outright.

You might also want to look into what OS are being used for server environments. A lot more BSD there than you might have initially guessed.

Happy new year to all! Cheers!

I am reminded of Magnetix, though they were ball and stick based, and I don't believe included "solid" polygons.

Maybe some kits beyond the ones I saw did.

Addendum: the positions of the atoms shown in that video and other figures are NOT smoothed or snapped to a grid in any way. They are directly drawn from the experimental results! They really are just that clean.

This also extends to the gorgeous rotational symmetry in the "imperfections" of the outer incomplete shell, which is perpendicular to the reflective symmetry of the inner "perfect" J-27 shells.

It's very neat to zoom so far in on reality and see such a well-ordered structure.

Two dozen programming languages shipped in or not, almost no languages support this.

It is something that you start appreciating a lot more once you have used it significantly. It helps a lot with writing more self-documenting interfaces that are legible at a glance.

Another detail I did not mention is that _public names are part of the interface_. This means that two functions that differ only in the public names are distinct overloads.

To give an extremely simple example (taken from Apple's docs):

class Counter {

    var count = 0

    func increment() {
        count += 1
    }
    
    func increment(by amount: Int) {
        count += amount
    }
    ...

}

This starts becoming even more valuable when you have more complex objects, and allows you to move (e.g. on some kind of repository class) mangling of overload names into more readable named argument overloads.

It separates "names as public-facing API design decisions" from "names as developer conveniences for expressing intent and clarifying their code".

These are often very at odds. And if you don't want to repeat yourself twice with two identical names... you don't have to.

And unlike Smalltalk, in Swift at least, externally unnamed but internally named is easy (just make the external name _).

American coffee shops have never been cafes. They're glorified caffeine dispensaries. Buy your drink, get out, drink it somewhere else.

In Europe no one bats an eye at you spending your entire day in cafe seating using the WiFi.

Sheer random chance.

I had this same question while working on structural resolution of a certain RNA polymerase.

I asked "okay so if this ratcheting mechanism allows the protein to zipper along the nucleotide strand... what's pushing it along?"

The answer is that nothing is pushing it along. It's just random movement and enough time (milliseconds) plus a ratcheting mechanism to ensure it doesn't go backwards.

Our low level processes are not so different from viruses in this respect!