GlitchMr

GDPR doesn't apply for entities outside EU if they aren't specifically targetting services at individuals in the EU (which can be indicated by using EU domains, supporting EU currencies, supporting EU languages or mentioning EU customers in promotional materials).

I'm not a lawyer, but I think it's unlikely that this browsewrap agreement is enforcable in United States as the website doesn't ask the user to actually consent to Terms of Service, see Nguyen v. Barnes & Noble, Inc. (763 F.3d 1171).

NixOS doesn't run Gixy anymore, see https://github.com/NixOS/nixpkgs/pull/209075.

This particular restriction is mostly arbitrary anyway because `this` and `super` accept arbitrary expressions (including static method calls), so in most cases it's possible to do this, just with much worse syntax.

Technically, this does introduce new functionality when extending a class, specifically it's possible to choose a constructor to overload depending on arguments, but in most cases there is usually one constructor that all other constructors use.

The problem with shorting cryptocurrency is that you are assuming that market is fair, when this is absolutely not the case - the market is heavily manipulated.

Using YouTube is legally not an option here due to Privacy Act of 1974.

Paying the criminals wouldn't help here. First, there is no guarantee that they wouldn't release the data anyway, second, the data already got leaked - criminals who were responsible for it have access to it, third, they publicly posted the information they have access to it.

Instead, the proper solution is after verifying legitimacy of the leak to immediately (within 72 hours) notify supervisory authority and users about personal data breach according to Articles 33 and 34 of GDPR.

Technically Google already has per-service bans for Google Ads and YouTube. That doesn't help if you get banned for a reason unrelated to those services however.

Certificate Transparency system requires certificates issued by CAs to be publicly reported, otherwise web browsers will reject them. Publicly reported certificates then can be monitored by anyone, and anything suspicious could be reported.

For ctest to work, it's necessary to start your User-Agent string with "NX NIFM/" (the console itself sends "NX NIFM/00" as an User-Agent string).

Technically there is sarcasm tag in HTML specification, it's one of tags that is specifically handled in https://html.spec.whatwg.org/multipage/parsing.html#parsing-... ('An end tag whose tag name is "sarcasm"').

However, a problem with sarcasm tag is that it wouldn't really help accessibility compared to say saying "Sarcasm:" or something like "(The preceding remark was sarcastic.)".

PHP is a much simpler language which helps a lot with optimizations. For instance, consider something like property access.

In PHP, doing `$a->b` accesses field `b` of object `$a`. The implementation is essentially type check (making sure `$a` is an object) and hash table lookup. If this fails, then it calls `__get` method if it exists.

In Python on the other hand, `a.b` involves `__getattr__`, `__getattribute__`, `__mro__`, `__get__`, `__set__`, `__delete__` and `__dict__`. Here is a description of how the attribute access works: https://docs.python.org/3/howto/descriptor.html#overview-of-....

> Records use : in their literal form, which is overloaded with type ascription. This is also annoying in cases where you might want to move a field into a let binding.

This one is getting fixed by removing type ascription - https://github.com/rust-lang/rfcs/pull/3307.

Minecraft website said the following:

> Once sales start dying and a minimum time has passed, I will release the game source code as some kind of open source. I'm not very happy with the draconian nature of (L)GPL, nor do I believe the other licenses have much merit other than to boost the egos of the original authors, so I might just possibly release it all as public domain.

This did not happen yet, Minecraft is still selling really well.

https://www.nintendo.com/switch/tech-specs/ says "USB Type-C".

I don't think there is anything wrong with storing passwords unencrypted locally assuming the machine itself has encrypted storage. Malware that retrieves passwords from password manager could get them from an unlocked password manager as well.

Helvetica typeface cannot be copyrighted in United States, see https://en.wikipedia.org/wiki/Intellectual_property_protecti...

Technically it may not be a copyright infringement - whether emojis can be copyrighted is quite complicated.

However, this is irrelevant as App Store Review guidelines say the following.

> Apps may use Unicode characters that render as Apple emoji in their app and app metadata. Apple emoji may not be used on other platforms or embedded directly in your app binary.

I think Apple would have to be stupid to block booting other operating systems on the devices they already have sold. This could easily lead to lawsuit, similar to one that Sony had when they removed OtherOS functionality from PlayStation 3.

Accessibility matters. If nothing else because it is a legal requirement with laws such as US's Americans with Disabilities Act, UK's Disability Discrimination Act, EU's European Accessibility Act, Australia's Disability Discrimination Act, and Ontario's Accessibility for Ontarians with Disabilities Act.

Breaking changes (https://vitejs.dev/guide/migration.html) are minimal and unlikely to affect most applications, and when they do the issues should be trivial to fix.

> I'm sure Google can send a cease-and-desist to all sorts of other stores instead of just Apple.

Google may dislike those applications and refuse to host them on Google Play, but they aren't doing anything illegal, so they cannot do anything about programs like https://f-droid.org/en/packages/org.schabi.newpipe/ on other stores.

> This would be breaking the sandbox model of the system, I don't think the regulation requires dismantling system security

I don't think it is breaking the sandbox, it could be implemented using NEAppProxyProvider, however this particular API is not available for App Store applications.

> Programs licensed under GPL as Apple App Store bans those.

iPhone version of VLC is licensed under MPL2 specifically for that reason. WebKit is LGPL2.1.

Apple will probably try to deal with requirement to not require developers to use WebKit by allowing alternate web browser engines in European Union only - a developer would be required to provide WebKit version of an application or else it would be only available in European Union. That wouldn't violate Digital Markets Act, as Digital Markets Act only applies to European Union.

- Web browsers with ad-blocking and plug-ins (Apple currently requires all web browsers to use system Webkit with very limited APIs).

- Game cloud streaming services (xCloud, Stadia, GeForce Now).

- Unofficial clients for websites such as YouTube that add features that official client doesn't have.

- Tools to disable advertisements in applications.

- Programs licensed under GPL as Apple App Store bans those.

This is an issue with Ruby's YAML implementation. YAML 1.2 processors should interpret documents without YAML directive as if they were YAML 1.2 documents - see https://yaml.org/spec/1.2.2/#681-yaml-directives.

Nintendo's Lot Check doesn't really establish anything. Nintendo Switch's game store is flooded with games that don't really work as the testing was minimized.

I don't think using String::intern makes sense, especially now that Java's garbage collector is capable of deduplicating strings (https://openjdk.org/jeps/192). In the past it could have been used to reduce memory usage when a given string was used a lot, but now there are better ways of dealing with that issue.

> 1: Amazing that Javascript is the most popular language, despite nobody has yet managed to write a fast FizzBuzz in it :)

The reason for that is that standard output implementation in Node.js is very slow. When the challenge is to write as fast as possible to standard output that's not ideal.

`process.stdout.write` is different to PHP's `echo` and Python's `print` in that it pushes a write to an event queue without waiting for the result which could result in filling event queue with writes. Instead, you can consider `await`-ing `write` so that it would write before pushing another `write` to an event queue.

    node -e '
        const stdoutWrite = util.promisify(process.stdout.write).bind(process.stdout);
        (async () => {
            while (true) {
                await stdoutWrite("1");
            }
        })();
    ' | pv > /dev/null