phicoh

Browsers happily killed EV certificates. With EV such a hack would take quite a bit more effort.

A linked list of each authoritative name in the zone. Not a list of zones.

That's for offline signing. For online signing you can do different things.

But the point is, and that's what this discussion is about is that DNSSEC can evolve. It can get extra features to make online signing more efficient.

The problem is that getting all validating recursive resolvers and other validators to update takes a very long time, on the order of decades.

So we got this problem because people started using this feature without verifying that validator support had spread wide enough.

The problem here is that computing three 3 NSEC3 records as you might need to return an NXDOMAIN was considered too expensive. It's just a choice to reduce their costs while increasing complexity for everyone else.

At the time it was well known that messing around with NXDOMAIN would cause problems. But some companies wanted to do it anyhow.

The solution is simple, if you want to use this DMARC feature then don't host with companies that do weird stuff with NXDOMAIN.

I think it is a marketing failure. The web was mentioned before, but ARM, Wifi, Bluetooth, the CD, all European inventions. There are core parts of the internet that are completely dominated by a European company but nobody knows. If we go back to the past, everyone had a Nokia phone at some point. There are services companies like Booking and Spotify. Then Linux and Python are from Europe as well.

The situation in Europe is even more crazy. The US needs the bases in Europe to project power in the Middle East. If every country in Europe would ask the US to leave then the US would have a very serious issue projecting power around the world.

The US bases are also pretty expensive to set up. Lots of logistic support has to be in place to let those bases function. That require a lot of support from the host country. Normally, you would expect the US to be friendly with the host countries, but that seems lost on the current administration.

What is really wrong is that it is known that russia is fighting in Ukraine with drones designed in Iran. And we have seen how hard it is for US designed weapons to deal with those drones. To the point that a lot of development is happening in Ukraine to deal with this problem.

By attacking Iran, the US has shown the world that Ukraine is the weapon supplier of choice against future drone wars.

I think what matters is the size of (for example) the German economy with and without the EU.

Futhermore, what matter is the amount of tax collected by the EU. Energy subsidy is not money collected by the EU and distributed.

Why not? If the increase in cake size is bigger than the subsidies then it can be a net win, even for the people paying the subsidies.

It also ignores the fact that absent the EU, countries would still have a lot of subsidies.

The Netherlands recognized the problems with the last-in-first-out system and requires that after a reorganization, the statistical distribution remains the same. How well that works is hard to say because the level of unemployment in The Netherlands has been quite low for many yours.

What I hear is that Switzerland is a bad example. Many people there struggle to make a living.

If DNSSEC is part of your security model, you want local validation. Not relying on third party resolver that you don't have a contract with.

Beyond that, DNS has the AD bit. If you need DNSSEC secure data (for example for the TLSA record), then when Cloudflare turns off DNSSEC validation, the AD bit will be clear and things will stop working.

I'd say that if the original Ada was introduced at the same time as Rust development started then people would pick Rust. Ada is also a product of its time would have to be modernized quite a bit.

Given how similar the syntax is of C, C++, Javascript, and Go, I think a language with the syntax of Ada would have a hard time.

I think that is not correct.

One of the big differences between K&R C and C89 is the introduction of function prototypes. Strong typing was certainly considered positive for compiled languages. Of course C is a lot less strict than Ada.

If we compare the Rust subset that has similar functionality as C then there is not much difference. You get 'fn'. The is 'let' but Rust often leaves out the type, so 'int x = 42;' becomes 'let x = 42;' in Rust. Rust has 'mut' but C has 'const'. Rust introduced '=>' and removed '->' from object access and moved it to the return type of a function.

The C language has support for long variable names. Some early linkers didn't, but that's an implementation issue, people were certainly unhappy about that.

C++ started in the 80s. Objects were not controversial back then. The same applies to exceptions.

I don't have a metric for the size of a standard library. For its time, the C library in Unix system had a large number of functions. Later that was split in a C standard part and a POSIX part. But that was for practical reasons. Lot's of non-Unix systems have trouble implementing fork().

I have no clue what you mean with annotations. If you mean non-function annotations along with code, then generally Rust programs don't have those.

I'd say that is even more so with Rust and Rust got popular in a very short amount of time.

The article gives another reason "A second answer is aesthetic. Ada's syntax is verbose in a way that programmers with a background in C find unpleasant. if X then Y; end if; instead of if (x) { y; }. procedure Sort (A : in out Array_Type) instead of void sort(int* a)."

I think this should not be underestimated. There is a huge number of small C compilers. People write their own C compiler because they want to have one.

That doesn't happen we Ada. Very few people liked Ada enough that they would write a compiler for a subset of the language. For example, an Ada subset similar to the feature set of Modula-2 should be quite doable with a modest effort.

I agree. There are quite a few places where they author claims that Ada had a concept first and some language got the same concept later, but the two concepts are different enough that examples would help to show where they are similar.

Especially if we assume that most readers are not Ada experts and that enough languages are mentioned that most people don't know the details of all of them.