tomtomtom777

It helps, but only temporary. I wouldn't be surprised if all 6 digit PINs will be leaked within a few decades.

This assumes every resident is born and registered in said country which is a silly assumption. Surely, any service only catered only to "naturally born citizen" is discriminatory and illegal?

Apart from the reasons you mentioned, the advantage of byo-yomi or Fisher time over the "add time after move 40" as often used in Chess, is that it doesn't create an artificial barrier.

What's so special about move 40? If you analyze chess games, you'll probably find that moves 40-45 are on average more accurate than moves 35-39 even it feels this number shouldn't be part of the game.

Isn't the fact that a certain number is a Mersenne prime interesting in itself? Surely it's a great addition to our knowledge of numbers?

A wallet address (where money is sent to) is the public key hashed. This money can than be spent with a transaction containing both the signature and the public key.

This is one of the reasons it is advised never to reuse an address. After using it once, your private key may still be private but your public key is exposed, reducing security.

Nice except that it is an absolute no go to generate these on the server.

Why not port to JS and generate it on the client? Should be trivial.

Yould should not encourage people to trust you.

It is also a completely different scale. A 11M wind turbine has a 200m (!) rotor diameter. This thing is 12m.

One could argue it's a half-baked quine.

Exactly. The exact amount of sleep needed on average is almost certainly an irrational number. (Because almost every number is irrational)

I don't think much is wasted on encryption. Most is wasted on backwards compatibility in the form of negotiating protocols, algorithm, extenstions, etc.

If there would forever be only one encryption algorithm in use we we wouldn't need most of the stuff.

Because methods to reduce our wasteful consumption, reliance on continuous growth and on the evidently harmful burning of fossil fuel aren't "hard sacrifices".

They are progress. Necessary progress.

It is only the unimaginative who ever invents. The true artist is known by the use he makes of what he annexes.

- Oscar Wilde

> this means that when new members are invited to a group, the existing members can automatically re-encrypt and securely send the recent message history — which is important for threaded chat, so that conversations aren’t broken.

This may be important for "threaded chat" but it's also a privacy killer. Everything you write might than be read by someone who later joins and wasn't the intended audience.

For me the point of this demo is that even a good commit message is often redundant information.

As programmers we learn that adding a comment like:

   // The limit is 16

to

    const SOME_LIMIT = 16

is bad because is redundant information that serves no purpose to the reader and can easily misalign in the future.

So what's a good commit message for changing this limit? Ideally we want to describe why we've changed it but this information isn't always available so even when we're avoiding redundant comments we often use redundant commit messages like "increased SOME_LIMIT" to make browsing through history easier for others.

As we do not need to provide this information (it is already in the code), it seems like a reasonable idea for an AI to help us provide it.

It seems correct to me.

The map shows the country "United Kingdom of Great Britain and Northern Ireland" (UK) without separating its constituent countries. This is what most political world maps do.

Ireland does border by land to the UK, at the border of Northern Ireland. This is shown with the black line.

Also it borders to the UK and all of the world's ocean bordering countries which is shown through the surrounding blue.

It is explained, but than why is it fuzzy? Isn't the fuzziness part exactly what's missing?

Such a tree mostly describes word similarity. But translating words is not what an AI (or more generally a computer) has problems with.

It's word ordering and idioms where AIs stand or fall. Things that show very little correlation in the evolution of language.

Although I am currently tip-toeing on NeoVim, I still feel this is a horrible break-up.

Yes, Open Source simply allows you to branch whenever you're unhappy with the original but this comes at a cost for the community. The cost of having two diverging programs to deal with.

In this case, the motivation was simply insufficient. Some people wanted vimscript+lua instead of vimscript. They felt the code was too difficult. They wanted to develop on their own.

Not bad reasons in itself, but does it weigh against the tremendous cost for the community of the split? Isn't a split only justified in situation like OpenOffice/LibreOffice when there is no other choice? Couldn't they not convince Bram Moolenaar of proposed changes, and if not, doesn't this have a good reason.

I hate NeoVim for the reason they've split, even though I understand it might become even better than Vim in the long run. You need better reasons to fork and divide an ecosystem.

Same here. And when I got suspicious I stupidly searched for "is DuckDuckGo down".

No results.

So you would like a website to implement a checkbox to toggle dark mode, in case it doesn't implement dark mode correctly?

That doesn't make any sense.

It didn't survive because HTML5 came along with very well defined and strict parsing rules.

You don't need closing tags for a specification to be strict. As long as you define the parsing rules rigorously as HTML5 does, there is little benefit in XML compliance and there is in a well defined non-XML standard as it is mostly backwards compatible.

> That's... not an especially worthwhile goal for a competitor.

But it is. Because otherwise we're just embracing monopolies. We can't switch to X because it doesn't accept our input as well as the "main" implementation does.

You can only beat BIND, or Postfix or Excel if you at least understand what they understand.

The problem arises when other people try to implement a compatible tool. Sure your JSON rules might not be ambiguous, but they are not standard either so every competitor aiming for compatibility will have to adhere to these specific rules.

This means that they need to use samatman-JSON and cannot really on JSON libraries for parsing. Or worse, if these tools become popular, we will see "samatman-rules" flags arising in JSON parsing libraries thereby harming the simplicity that made JSON what it is to today.

I think that your example illustrates exactly what makes Postel's law harmful. If you accept JSON, stick to the rules.

True. It is possible though for a language to avoid these iteration constructs as if they are needless plumbing as well. Consider the elegant type system of the XQuery language:

In XQuery, the root type is a flattened sequence. Flattened means not just that [1, [2, 3]] is flattened to [1, 2, 3], but also the a single object 42 is equivalent to a sequence of one object [42].

This means that if I write:

  declare function local:prefixName($name)
  {
     fn:concat("prefix-", $name)
  }

I can invoke it with a single name or a sequence of names without any explicit iteration.

It has drawbacks but using XQuery certainly highlights how much code we normally waste dealing with "things" and "sequences of things" separately.

(Than again working with XQuery also highlights how much code one can waste dealing with XML namespaces :)

I disagree. If you need to know an estimate or guess of certain details that aren't visible in lo-res, this is very useful because the AI is likely much better at inferring these details than a human.

Sure, it is still a guess but a better one than humans can make.

To sum up: The free market is only useful for things in where maximization is the optimum.

I think it's a bit odd to call this "net zero".

If there are more trees, there's more oxygen.

Sure, if a tree dies this is eventually reverted but it also makes room for a new tree (unless humanity claims the land).

That is not expected behavior. If you click a link and get a page, one expects back to return to the previous page.

A standard HTTP redirect does this right as well as location.replace()

The site incorrectly sets a new location by other means.

Nitpick: Please don't break the back button.

It's a good idea but it seems to me the name will hurt adoption.

Phoning home with telemetry data does not by definition imply tracking.

Yet a project implementing DO_NOT_TRACK is essentially saying that without it, it is tracking users. This isn't particularly attractive for a project that already has some OPT_OUT_TELEMETRY option.