nuclear_eclipse

We have multiple CPython core developers at Facebook, and the Cinder team (among others) are heavily involved in discussions around CPython's direction. There are many pieces of Cinder that would never get accepted upstream, or would take a decade of PEPs and incremental improvements to get there. Cinder is both a proof of concept that these ideas can work in CPython, and something that we can use today, rather than waiting a decade to realize these benefits from a pure open source perspective.

The big benefit of type hints things like Pydantic (and some things I've written myself) is that it can provide useful runtime information. If you know that property `obj.foo` is hinted with `List[Foo]`, then that allows you to do something expecting to have a list of `Foo` objects. This is really extraordinary for deserializing untyped data (like a json blob) into appropriate objects at runtime. You can take something like `{"foo": [...]}` and attempt to deserialize each element of the `foo` list into `Foo` objects, rather than just guessing at what the list contains. If you stop being able to understand type hints at runtime, then the only thing they're good for is documentation and static analysis.

I've been on Dvorak full-time since 2008, and even though I generally don't use vim itself for programming, I do still use vim-mode in my editors and IDE. But I gave up on using hjkl long before switching to Dvorak, and I've always just either used motions like w/b/f/t/n/etc, or moved to the arrow keys for shorter motions. This also lets me share more of the muscle memory for movements when I'm typing into standard text boxes like this.

If someone signs a bad contract because they refuse to read and understand it, and just signs it anyways, they're still generally bound by the terms of the contract. iOS and Android both have pretty clear descriptions in their permissions dialog of what the app is asking for.

Presenting a screen/dialog to the user at first login asking for permission to access contact data does not sound like "forcefully harvested". Users rarely understand the consequences of their decision, which is why I would love to see iOS and Android eliminate the option of wholesale contact access, but use of Facebook apps is not predicated upon receiving your contact data.

Your friends can (and almost certainly will) share their contact info (including your name/phone/email) with Facebook , Messenger, or Whatsapp, even if your account is deleted and doesn't exist.

Assuming that the data is just your phone number and name/email, is it not possible that this is just from friends who have allowed Facebook and/or Messenger to share contact info? Your original account data almost certainly would have been deleted/purged due to various regulatory requirements, but that doesn't necessarily stop your contact info from being shared again and making its way back into the system.

Sanitize, normalize, and distrust. All three cover different use cases.

It's legal negotiation. You sue for the maximum allowable penalty/damages in hopes of settling for something in between the maximum and zero.

I've been a lifelong fan of Calvin & Hobbes, and I have all of the books, but I both don't have the time to revisit them, or when I do, I binge way too much.

Is there any way to get a personal, daily comic via RSS or similar that starts from the very beginning, without having to wait for one of the syndication sites like gocomics to wrap around back to the beginning?

Just wait until you get Python 3.9 and can do:

    >>> a, b = 2, 4
    >>> f"{math.gcd(a, b) = }"
    'math.gcd(a, b) = 2'

I presume they would claim them with fake/fresh username/email info to get legitimate licenses/keys, then resell those after the fact.

I've been extraordinarily happy with iStat Menus for showing a variety of system info in the menu bar.

https://bjango.com/mac/istatmenus/

resell them on various sites for < MSRP

If you can answer the why, then I think physicists around the world would really like to know. We "know" the universe is expanding because we can observe the effects (eg, red shift of further away stars/galaxies), but the "why" has been the big, fundamental question for as long as it was predicted and/or observed. It's almost certainly related to some property of physics that we don't yet understand, but ultimately, we may never know any reason beyond "that's just how it is".

The easy answer is C extensions. PyPy does not support C extensions, and thereby does not support a wide range of native, accelerated libraries. Facebook infra is heavily dependent on wrapping C/C++ libraries (like Thrift) for use in many languages, and not having C extensions (or Cython) would cut off a large portion of our shared codebase.

As someone who operates two Nest cameras (one doorbell, one camera, both record audio) in California with clear line of sight towards public areas (sidewalk and street), I would really like to know what sources make you believe this is illegal. I find that claim very hard to believe.

Most laws around street legality center around certification of the chassis, safety equipment, and emissions. Don't run the jet engine during a smog test, and prove that all the necessary safety equipment function (signals, airbags, seatbelts, etc), and you're going to pass. This is why most kit cars depend on a "donor" chassis that gets stripped down and have the new car built on top of.

If only we had a government mechanism for holding service providers to higher standards for neutral delivery of services to citizens regardless of economic incentives.

This is where I've become a staunch proponent of type hinting Python code. I've caught more subtle bugs by enabling mypy on new sections of code than by running and debugging in production. Of course, this requires adding type hints everywhere, which can a struggle for older codebases, but MonkeyType is a great way to solve that, along with diligence on adding type hints to all new code you write, giving progressively more benefits as more of the codebase is covered by type annotations.

For user interfaces this is huge advantage: you can run all your code on the UI thread; but the UI stays responsive while awaiting tasks.

... assuming any other tasks/coroutines running on the UI thread are being cooperative and not doing bad things like waiting on synchronous functions or otherwise hogging the UI thread too much. Done right, it's a big performance and maintainability win over multithreading, but when done poorly, it can result in large variance in latency/responsiveness of any individual task.

Prop 22 is a state amendment, but not all propositions are. Some are referendums from the legislature that just pass/enact/repeal normal laws, and others are just new laws without being amendments to the state constitution.

These initiatives amend the state constitution, so they can set any requirements they want. Prop 13 famously added a requirement for 2/3 vote to change it, and this was sustained by the US Supreme Court: https://en.wikipedia.org/wiki/1978_California_Proposition_13

California ballot propositions have the possibility of amending the state constitution (see Prop 13 [1] as one of the historic examples), and once you're allowing that, anything is possible.

1: https://en.wikipedia.org/wiki/1978_California_Proposition_13

Actually I am using a Retina display. I’m still noticing the difference very much.

I suspect you are not running at the "correct" 2X Retina resolutions, which for whatever reason are no longer the default on Apple Macbooks. Instead, they end up running at a 1.75x or 1.5x of native resolution, which results in slightly less crisp rendering for everything, not just fonts.

You can do very similar things on macOS. `Option+E, A` generates á, `Option-U, U` yields ü, and so forth. There are tons of alternate characters available like this using the Option keys, generally covering the most used glyphs I've needed. Beyond that, the Rocket app is fantastic for finding and inserting emojis and more complicated emoticons by human-friendly name.

You'll be interested to look up Foveated Rendering.

Because I really like the model/UX of the staging area. I'm not worried about the tool being simple; I use it every day, so it's worth learning inside and out.

It's a much nicer experience IMO to be able to work on various different pieces, then iteratively run `git add -p` or similar to stage individual files or hunks, verify everything I'm adding with `git diff --cached`, then `git commit` when I'm actually ready and happy. It lets me fix multiple parts of my project at the same time, without interruption, while still letting me compose my batch of changes into multiple, self-contained changesets.

`hg record` feels really limited by comparison, and rushes you immediately into committing your selected changes, and then further makes it difficult to selectively amend more (partial) changes to that commit afterwards.

It's a lot better than it was in 2014, but I still miss using git.

Nit: the standard library includes a module to fetch and install pip. It doesn't include pip itself.