Could the interpreter have a "restricted" mode and a "dynamic" mode, where restricted mode can be faster because it skips certain lookups? And then if your code _engages_ in a "dynamic" behavior, it then drops out of "restricted" mode? (this could also be in a class by class basis too).
Django and friends might always have to be in "dynamic" mode, but possibly you could allow for some complex logic to run quickly if you use subset of the language. (e.g., like RPython but with less overhead to set up)
if you do a `git clean -f`, untracked files get deleted. Ignoring files that should stick around helps ensure that command can be used nicely. I've never used `git clean -fdx`, not sure why you would use the `-x` flag at all.
I conceptually like the idea of dropping coding screens, etc - but how do you objectively identify what you're looking for in a candidate without adding bias to the process?
I.e., at least with a coding question, you can set up objective criteria. If you ask someone about their work, it might be a good experience but you're also setting yourself up to bias towards people who talk/think like you.
> On the other hand x86 has a lot of old "stuff" still needing support and use cases are much less clear cut (wrt. thinks like how many PCI lanes need to be supported, how much RAM, etc.).
Good point overall - the performance of Rosetta 2 helped facilitate much of this and - at least from what I've read - does seem to be surprising to folks in the space. So that also helped them out.
Totally get what you mean. I'll pitch for either terraform or AWS CDK as good ways to make some of this plumbing less painful (they both have you describe the end state you want and then generate resources to get there).
I live in SF, it's normal to see someone run out of a Walgreens while an employee tells another employee not to chase the person down (because they don't want to get injured). There's no accountability for theft.
Don't need to send someone to jail, but there's gotta be something better than shrugging shoulders.
a year from now, are you actually going to want to test each individual change in a pull request, or are you going to want to test it as an entire unit?
I agree that code review you want smaller units but my experience has been that 1-2 years later, you no longer care about the individual units and instead you want the entire patch/PR all together.
Understand where author is coming from - but doesn't squash-n-merge (newish github feature) solve the issue of needing to rebase and the issue of having too many merge commits?
Squash-n-merge has nice property of removing unnecessary local information that probably doesn't matter at a meta level (commits are nice when reviewing PR, doesn't matter much later)
Have you taken a look at [PEP 517](https://www.python.org/dev/peps/pep-0517/) ? It enables other tools to replace setup.py (e.g., poetry is pretty nice for making easy-to-package-and-publish pure python libraries).
lib2to3 exists and is used by tools to do this kind of automatic refactoring for python. The idea of having a migration path to the "blessed" way to do things is pretty neat!
at least on Github, if your branch only has one commit, it will use the commit to automatically populate title and summary. And recently pushed commits show up on top of the repo page with a one-click button to open a PR :) (or you can go to the "branches" page to do this as well)
My impression is that backend changes more slowly (and is easier to control) than frontend. At least when you're doing backend you can choose your whole stack (vs. frontend where you have to deal with a huge array of different types of computers and such).
Plus IMO you set up your framework for building once or twice and just reuse it everywhere, so doesn't end up as difficult as the faster changing front end work.
Django and friends might always have to be in "dynamic" mode, but possibly you could allow for some complex logic to run quickly if you use subset of the language. (e.g., like RPython but with less overhead to set up)