NewEntryHN

Any business model where ads can be paid off has no incentive to make good ads. Ads are meant to be annoying enough so that people prefer paying. Hence the war on ad-blockers.

The advantage of Cursor is the reduced feedback loop where you watch it live and can intervene at any moment to steer it in the right direction. Is Codex such a superior model that it makes sense to take the direction of a mostly background agent, on which you seemingly have a longer feedback loop?

Most servers will natively use caching policies for serving static content as well.

Some SQL engines support accepting parameters separately so that values get bound to the query once the abstract syntax tree is already built, which is way safer than string escapes shenanigans.

Fair enough. It would be nice if Python allowed to customize the formatting options after `:`

This way you could encode such identifier directly in the t-string variable rather than with some "out-of-band" logic.

Assuming you also need to format non-values in the SQL (e.g. column names), how does the `execute` function is supposed to make the difference between stuff that should be formatted in the string vs a parametrized value?

Is this

wget --mirror

?

Yes but with concepts instead of tokens spelling out the written representation of those concepts.

Most of homeopathy usages target little aches and whatnots that require no treatment (beyond patience), so I guess it could also act as a buffer against overmedication.

It has not escaped close scrutiny. It's just that people don't go around accusing a specific person without evidence.

Give it a week until it is exactly that that did actually happen (not saying it has been orchestrated, just talking net result).

OP needs to change companies.

Most widespread obfuscation methods are solvable with a bunch of regexes. They have never been more than a first line of defense against trivial bots.

Doesn't matter. If God wants to hide he can spot you're measuring prayers and stay under the radar anyway.

Not drinking coke.

The author did not understood the idea.

His description of his understanding does not include any reference to the "wrong"-ness of abstractions that shouldn't exist. If I read him as-is, I should conclude that the idea is to never make any abstraction at all. It obviously cannot be it since that would be stupid.

"Wrong" abstractions are already bastardized, from their first iteration. Developers decide to code them nonetheless because they estimate that their "awkwardness" is worth it in comparison to code duplication. What they fail to realize is that, to the contrary that code duplication which just "is there", the awkwardness of the abstraction will compound.

Duplication is the last resort, when one has established that he couldn't find any non-wrong abstraction.

Above a certain threshold of talent, there is no need to negotiate at all.

The example really doesn't sell it to me. The search "what is the most common element on the periodic table" currently returns a big display with "Hydrogen" as the answer, followed by a brief explanation.

That's all I need for such a query. In comparison any text written by a "generative AI" is mostly noise.

Good article, but it's a bit binary on the notion of incident. For the same company, it can be very serious to have a global 1h outage, but not so serious to have the internal admin interface down for 1h. This allows for more fine-grained assessment of the validation required to push to prod: the "checks" only have to test the critical part of the application. Dev exp start deteriorating when the non-critical parts are over-tested.

Any serious application beyond the example given in this article will include conditional SQL constructs which go beyond SQL query parameters and will therefore require string formatting to build the SQL.

Think a simple UI switch to sort some result either ascending or descending, which will require you format either an `ASC` or a `DESC` in your SQL string.

The moment you build SQL with string formatting is the moment you're rewriting the SQL formatter from an ORM, meeting plenty of opportunities to shoot yourself in the foot.

While I agree with the sentiment, I can see 2 counter-points:

- "Nothing bad happens" might be the accumulation of risk until something _very_ bad happens.

- Something bad might actually be already happening, only silently. For example, teams suffering unnecessary difficulty whenever they need to work on some part of the codebase, but it's considered "normal" because that's life now.

52ms for me. Pretty standard for an HTML page.

In all cases you're going to store and manage your state some place. What you describe is managing the state using the DOM itself, which would indeed be easier if the DOM wasn't directly tied to the screen, but which would still be very cumbersome because of the lack of appropriate APIs for managing the DOM as an application state.

If you were to go in this direction, you would eventually make the DOM less DOM-ish, and the painting mechanism more DOM-ish, effectively shifting everything one place and going full circle back to the frameworks.

People making comments on the code editor you use before using the mouse to select text like monkeys.

Seems very weird (and fixable) that text found on the web would be interpreted by the chatbot as an instruction.

The actual answers to OP's question is that management needs to know:

- how much resource to allocate to the task

- variations of the estimates in function of variations of the scope

In my experience, "ballparks" estimates are sufficient for this exercise, and precise estimates are just resource-tracking leading to the issues described by OP.

I guess they fired him because he was an idiot.

"Classical" chess engine (those based on alpha-beta search) are indeed better because they calculate faster, although so insanely faster that there is probably not enough time in a _lifetime_ for a human to win a single game against it.

The more recent chess engines (LeelaChess, and the latest versions of Stockfish) use neural nets to allow for more shallow calculations without decreasing game quality. In this case the engine is better because it's just "more intelligent" (and nobody understands how).

Social consequences is a cute term for savage justice.

And yet, this part is inconsistent with the part the headline comes from: they argue for causation because they asked individual random students to quit social media for 4 weeks, and saw an improvement of their mental health.