> Armed conflicts have indirect health implications beyond the direct harm from violence. Even if the conflict ends immediately, there will continue to be many indirect deaths in the coming months and years [...] In recent conflicts, such indirect deaths range from three to 15 times the number of direct deaths . Applying a conservative estimate of four indirect deaths per one direct death to the 37 396 deaths reported, it is not implausible to estimate that up to 186 000 or even more deaths could be attributable to the current conflict in Gaza.

The text is not claiming that 200,000 people at the point of publishing have died, it is estimating the number of deaths attributed to the conflict in the coming years.

It offers a more involved approach to managing the dotfiles, but (imo) addresses the need to have differences between dotfiles on different machines.

[1]: https://github.com/SuperCuber/dotter

but for example a language like C has many different syntaxes for different operations, like function declaration or variable or array syntax, or if/switch-case etc etc.

so to know C syntax you need to learn all these different ways to do different things, but in lisp you just need to know how to match parenthesis.

But of course you still want to declare variables, or have if/else and switch case. So you instead need to learn the builtin macros (what GP means by semantics) and their "syntax" that is technically not part of the language's syntax but actually is since you still need all those operations enough that they are included in the standard library and defining your own is frowned upon.

And yet, many interviewers' experience shows that there are people that would pass a discussion-only interview and fail at basic coding tasks. There's plenty such people holding down jobs for a while, so even that may not be a sure indicator of skill.

> The intentional ambiguity is deceitful. The expected dependence and expected deference is so patronizing and manipulative.

I'm ~1.5years into my first job as a Backend Dev so I can't speak much about the industry, but based on my experience and what I hear from others, asking questions and clarifying unclear requirements is part of the job description. I almost never get my tasks in a precisely defined way and a lot of my job is gathering information and asking the right questions to build the right thing, often making my own choices and judgement calls. I assume that these skills are what GP comment is trying to test.

> They don't really care, nor should they, about your product, or your customers.

You can hardly blame a company for preferring someone who does. Or at least, pretends to.

> For security reasons, it is advisable for users to log out from a web application once they have completed their tasks

No, the application should be resistant to XSS instead. Online banking and such are automatically logging out to prevent someone stepping away from the device and another person abusing the logged in session.

> Frequently, when a Logout function is present in the application and is implemented with JSON Web Tokens, the application stores the JWT in an insecure location, such as the JavaScript code itself or the local storage in the user’s browser

This claim is as valid as "Frequently, when a Logout function is present in the application and is implemented without JSON Web Tokens, the application stores the plaintext password in an insecure location". The storage location is completely independent of whether it's a JWT or not.

    curl 'https://...googlevideo.com...' --output video.mp4

on the other hand,

    yt-dlp videoIdHere

Does that curl command run much faster for you? Or do you do something else?

    echo -n '{"videoId":"aqz-KE-bpKQ","context":{"client":{"clientName":"WEB","clientVersion":"2.20230810.05.00"}}}' | 
      http post 'https://www.youtube.com/youtubei/v1/player' |
      jq -r '.streamingData.adaptiveFormats[0].url'

I'll give you an example from a ongoing side project of mine: https://github.com/SuperCuber/facto_rs/blob/master/src/model...

Hopefully the Rust syntax is not too much of a distraction here, but enough to focus on the `struct` and `enum` parts (an enum in rust can be "one of" the variants, like tagged union or sum type in other languages, or | operator in typescript). The project is a live wallpaper/screensaver that is a simulation of something like a combination of the games Factorio and Mini Metro.

I had in mind what I wanted to happen - a grid containing a rail network with trains running between different nodes.

What I call the model is the representation of the things in the code: I could store the train's position in terms of [float,float] and a facing Direction, but instead I choose to store it in terms of List<[int, int]> of grid tiles that it plans to go through, then an int for its current position in the list, and then a single float between 0 and 1 representing how far into the tile it's moving.

The two possible solutions have pros and cons, and there are other solutions as well that are equally valid I'm sure. In my mind, the process of "modeling your domain/problem space" is about deliberately thinking about these things and choosing what you think is the best.