It's just too easy to keep adding new feature flags and never removing them. Until one day the FF backend goes down and you have 300 FFs all evaluate to false.
8,250 karma · joined November 11, 2012
It's just too easy to keep adding new feature flags and never removing them. Until one day the FF backend goes down and you have 300 FFs all evaluate to false.
Just FYI how this generally works: it's not developers who add it, but non-technical people.
Developers only add a single `<script>` in the page, which loads Google Tag Manager, or similar monstrosity, at the request of someone high up in the company. Initially it loads ~nothing, so it's fine.
Over time, non-technical people slap as many advertising "partner" scripts they can in the config of GTM, straight to prod without telling developers, and without thinking twice about impact on loading times etc. All they track is $ earned on ads.
(It's sneaky because those scripts load async in background so it doesn't immediately feel like the website gets slower / more bloated. And of course, on a high end laptop the website feels "fine" compared to a cheap Android. Also, there's nothing developers can do about those requests, they're under full the control of all those 3rd-parties.)
Fun fact: "performance" in the parlance of adtech people means "ad campaign performance", not "website loading speed". ("What do you mean, performance decreased when we added more tracking?")
"$Something-is-happening as $Something-else-is-happening"
It's usually written in a way that might be suggesting a direct link between the two things to a layman, but often there's none, other than the fact those two things are happening around the same time.This can be disorienting when the reader is not familiar with the subject discussed, and lead them to wrong conclusions.
In a good interview, the interviewee would ask clarifying questions; perhaps get told to build something simple that works; and then follow-up questions would expand towards bigger scale to test the breadth of knowledge and experience of the candidate.
The thing being evaluated is not blindly repeating random "best practices", but understanding and adapting to requirements.
And not a (botched) fake white/gray grid background that is commonly used to visualize transparency?
Native apps make it much smoother (or just possible at all / with much lower friction) than webapps to do things like taking photos, scanning NFC, doing payments etc. (which the visa apps are doing)
Apps are also natural "storage point" for data, and a "bookmark on the phone" (the latter is partly due to vendors not making it easy to add non-apps to your home page on the phone).
As much as I hate the push to apps for things like Reddit for monetisation purposes (and I don't install such apps), in many cases for specialized apps the experience is actually much better in the app.
And as you can read in op's article, there's a web fallback possible.
The main drawback for me is that apps take 100s of MBs those days.
Just the (small) probability of this being true might be enough for the big players to not consider creating that var. (Although, if it's easy enough to unset it, then maybe not an issue).
> After the luggage is unloaded and collected in the cargo handling area upon arrival at the airport, ground support personnel manually align the handles of the bags and place them on the conveyor belt.
That's a level of attention to detail that we should be striving for in everything we build.
- in root of the repo, it prints empty string
- if you're 1 level deep it prints `../`
- if you're 2 levels deep it prints `../../`
One minor drawback: inside `.git` subfolder, it always prints empty string too.
Useful when you want to create a temporary file to help you e.g. with a bug investigation, and make sure it stays untouched while you switch branches, and to avoid accidentally committing it.
I have a shell alias like this:
git-ignore-local () {
echo "$1" >> .git/info/exclude
}
and use it like `git-ignore-local myfile.ext`https://eu.usatoday.com/story/travel/news/2026/02/22/tsa-pre...
https://www.reuters.com/world/us/us-homeland-security-tsa-pr...
What tools are the best to do the equivalent but for squash-merged branches detections?
Note: this problem is harder than it seems to do safely, because e.g. I can have a branch `foo` locally that was squash-merged on remote, but before it happened, I might have added a few more commits locally and forgot to push. So naively deleting `foo` locally may make me lose data.
This gave me a chuckle, because a colleague who talked with HRs just told me exactly this last week.
I chose my usual size, but Amazon told me "nope we think you want one size smaller, based on your history and our data for this product".
I go to a clothing shop at the start of a new collection, and look at men's shirts for a given type:
- there's 10 XS, 10 M, 10 XXL versions
I go towards end of the season:
- there's like 1 M remaining, but 8 XS, 8 XXL.
Like if they were surprised and had no data that most population is M.
Preventing it it's extremely hard, because the typical way of developing code is to write a ton of code, add a ton of dependencies, and let the bundler figure it out.
Visualizing the entire codebase in terms of "what imports what" is impossible with tens of thousands of files.
Even when you do splitting via async `import()`, all you need is one PR that imports something in a bad way and it bloats the bundle by hundreds of kilobytes or megabytes, because something that was magically outsourced to an async bundle via the bundler suddenly becomes mandatory in the main bundle via a static import crossing the boundary.
The OP mentions it here:
> It’s often much easier to add things on a top-level component’s context and reuse them throughout the app, than it is to add them only where needed. But doing this means you’re paying the cost before (and whether) you need it.
> It’s much simpler to add something as a synchronous top-level import and force it to be present on every code path, than it is to load it conditionally and deal with the resulting asynchronicity.
> Setting up a bundler to produce one monolithic bundle is trivial, whereas splitting things up per route with shared bundles for the common bits often involves understanding and writing some complex configuration.
You can prevent that by having strong mandatory budgets on every PR, which checks that the bundle size did not grow by more than X kB.
But even then, the accumulation of 100s/1000s of PRs each adding 1KB, bloats the bundle enough to become noticeable eventually.
Perf work is thankless work, and having one perf team trying to keep things at bay while there are dozens of teams shipping features at a fast pace is not gonna cut it.
Workaround I found: you can configure the monitors to be a pattern like this instead:
1
2
touching only in the corner. Then it works, the Dock is on monitor 1.Finally I realized the issue: if a window spans across two displays, it won't resize. Insane!
(I have an external monitor up, laptop down, and it's easy to move a window such that it stretches a few pixels from monitor to the laptop. No resize for you!)
https://docs.npmjs.com/trusted-publishers#automatic-provenan...
Bonus point: that Windows 95 style "error" beep when pasting too large image. Always sends the shiver down the spine and confuses the coworkers around (we're an all-Mac shop).
The difference of "value for money" in terms of build quality, battery life, screen, touchpad, OS stability, OS upgrades experience, and overall polish and level of user (non-)hostility is immense.
A Windows guy for two decades, got an MBP for work, and while I miss some Windows software and I don't like some Mac things (e.g. no real write-to-disk hibernation; pricey upgrades from base models etc.), but there's no way I'm going back.