I do currently use a Pixel, but I hate how big it is.
I do currently use a Pixel, but I hate how big it is.
We all know who you are talking about, just like everyone know what "guy" I'm talking about.
That being said, I believe there has been an increase in genuinely dumb people in American politics in the past ~15 years.
My assumption is that people have used orms that automatically add the index for you when you create a relationship so they just conflate them all. Often they’ll say that a foreign key is needed to improve the performance and when you dig into it, their mental model is all wrong. The sense they have is that the other table gets some sort of relationship array structure to make lookups fast.
It’s an interesting phenomenon of the abstraction.
Don’t get me wrong, I love sqlalchemy and alembic but probably because I understand what’s happening underneath so I know the right way to hold it so things are efficient and migrations are safe.
FWIW, I've also asked everyone I've interviewed in the past decade about indexes and FKs. Most folks I've talked to seem to understand FKs. They're often fuzzier on the details of indexes, but I don't recall anyone conflating the two.
1. Reducing costs by hiring fewer people.
2. Increasing profits by decreasing care.
Did I nail it or what?
> 1. The change is not really a refactor
Is anything ever really just a refactor, though?
> 3. Another refactor is already in progress
Ah, but - in large and poorly-maintained codebase, it is always the case that some refactoring is already in progress, likely stalled for weeks, months or years as priorities have shifted without it having been completed.
> 4. The code is unlikely to change
If the code is unlikely to change, there's a good chance you might want to refactor it out of your repository anyway, into some low-frequency-of-changing library.
> There’s no benefit to improving code that never changes
Oh, there are lots of benefits to improving code that never changes! And that's because other code _uses_ the code which never changes. And if originally the use is clunky, but you manage to improve it by your refactor, youve' done well indeed.
> 5. There are no tests
A repository which lacks test coverage is extremely likely to be in dire need of all kinds of refactoring. Waiting until someone (maybe even yourtself) writes tests for most code, before doing anything in the mean time - well, it basically means giving up on yourself.
> we can start by writing some tests!
Well, that's nice, but - if we do that, then no refactoring would get done, and we'll have to write code based on ugly and unweildy older code, which only adds stuff to refactor later. Plus, who's to say the tests don't fail _already_? :-(
This is true, and something I also thought of when reading that point. I don't think it's necessarily a counterargument, though. It's probably a better idea to spend your time helping to complete the previous refactor instead of starting your new one. Codebases in which many refactorings are started but not completed can be worse than ones that aren't refactored at all.
There could be exceptions if your new changes is very small, localized, and unlikely to interfere with the other changes going on.
I still have a small amount of hope that someone will make a modern, well supported ~5" Android phone. But that's also feeling less likely.