The basic problem is that identifiers can be either types or variables, and without a keyword letting you know what kind of statement you’re dealing with, there’s no way of knowing without a complete identifier table. For example, what does this mean:

foo * bar;

If foo is a type, that is a pointer declaration. But if it’s a variable, that’s a multiplication expression. Here’s another simple one:

foo(bar);

Depending on how foo is defined, that could be a function call or a declaration of a variable bar of type foo, with some meaningless parentheses thrown in.

When you mix things together it gets even more crazy. Check this example from this article:

foo(*bar)();

Is bar a pointer to a function returning foo, or is foo a function that takes a bar and returns a function pointer?

let and fn keywords solve a lot of these ambiguity problems because they let the parser know what kind of statement it’s looking at, so it can know whether identifiers in certain positions refer to types or variables. That makes parsing easier to write and helps give nicer error messages.

Technically any Catholic male is eligible to become pope, it doesn’t even have to be a cardinal. But yeah cardinals are the only ones voting so they always elect one of their own (with a few historical exceptions)

As a European, the idea of a bank having a drive-through is just absolutely wild.

What you’re talking about is essentially an EMP. They don’t generally emit continuously. Instead you just set off a single strong pulse which induces such high currents in receiving antennas that they melt or otherwise damage connected circuitry.

At these levels of power, any amount of conductive material tends to start acting as an antenna. If you set up a continuous transmitter you’re going to have trouble not damaging your own delivery and power mechanisms.

The most common way to generate one is to set off a nuclear bomb that has been finetuned to release most of its energy as electromagnetic radiation.

A system I work with gives all keys a string value of “Not_set” when the key is intended to be unset. The team decided to put this in because of a connection with a different, legacy system, whose developers (somehow) could not distinguish between a key being missing or being present but with a null value. So now every team that integrates with this system has to deal with these unset values.

Of course, it’s up to individual developers to never forget to set a key to “Not_Set”. Also, they forgot to standardise capitalisation and such so there are all sorts of variations “NOT_SET”, “Not_set”, “NotSet”, etc. floating around the API responses. Also null is still a possible value you need to handle as well, though what it means is context dependent (usually it means someone fucked up).

I think it’s more so that the kind of people contributing to these projects are on balance not that interested in doing the marketing work.

This is “the gadget,” an implosion type nuclear bomb detonated in the trinity test, the first nuclear bomb test on earth (that we know of, heh).

It’s shown partially assembled inside the 100-foot test tower where it would eventually be detonated.

Can someone explain where the Y comes from? Is this something like, there exists a mother relation between this X and some Y?

Your thought is correct. The basic problem is that higher level languages contain a lot of additional information that is lost in the compilation process.

Fun quote from an interview with Chris Sawyer:

Latterly the machine code came back to haunt us when the decision was made to re-launch the original game on mobile platforms as RollerCoaster Tycoon Classic a few years ago, and it took several years and a small team of programmers to re-write the entire game in C++. It actually took a lot longer to re-write the game in C++ than it took me to write the original machine code version 20 years earlier.

is-number is a project by John Schlinkert. John has a background in sales and marketing before he became an open source programmer and started creating these types of single function packages. So far he has about 1400 projects. Not all of them are this small, though many are.

He builds a lot of very basic functionality packages. Get the first n values from an array. Sort an array. Set a non-enumerable property on an object. Split a string. Get the length of the longest item in an array. Check if a path ends with some string. It goes on and on.

If you browse through it’s not uncommon to find packages that do nothing but call another package of his. For example, is-valid-path provides a function to check if a windows path contains any invalid characters. The only thing it does is import and call another package, is-invalid-path, and inverses its output.

He has a package called alphabet that only exports an array with all the letters of the alphabet. There’s a package that provides a list of phrases that could mean “yes.” He has a package (ansi-wrap) to wrap text in ANSI color escape codes, then he has separate packages to wrap text in every color name (ansi-red, ansi-cyan, etc).

To me, 1400 projects is just an insane number, and it’s only possible because they are all so trivial. To me, it very much looks like the work of someone who cares a lot about pumping up his numbers and looking impressive. However the JavaScript world also extolled the virtues of these types of micro packages at some point so what do I know.

The only one I really would avoid is passing things between or touching chopsticks together. This is reminiscent of Japanese funeral rituals and thus considered rude to do at the table.

The others are more about common sense and trying to help you enjoy the sushi as the chef intended:

• They are bite-sized pieces, designed as a flavour combination, so don’t break them up in any way
• If you don’t want rice, sashimi is a good way to get that
• Putting too much soy sauce on the rice can make it fall apart
• (real) Wasabi is delicate and mixing it with soy sauce will certainly destroy its subtle flavour. In any case in a high-end place the sushi chef will have added everything that’s intended as part of the flavour combination before serving the sushi, so adding stuff is not necessary

But again, these are suggestions. Enjoy the sushi how you like, you’re not hurting anyone.

The confusion arises because there are 5 different ways to do the same thing, the non-experimental methods shouldn’t be used even though they’re recommended in the official docs

I appreciate what you’re trying to say, but you’re kind of illustrating exactly the point I was making about conceptual simplicity and atrocious UX.

Nix has the same mix of conceptual simplicity and atrocious user interface as git, but somehow magnified three times over. I’ve tried it multiple times, but could never get over the unintuitive gaggle of commands.

It would be pretty funny if GPT starts putting licence notices under its answers because that’s what people do in its training data.