anordal

Does this _need_ to be language specific, semantic and smart? Just a word-based diff would be so much better than a line-based diff.

Are there 2 things called fsync now?

I had to ask google, because the article fails to explain it. Google says yes, this is something else than the fsync syscall (man 2 fsync).

Have medical researchers not heard of gitignore? Any hypothesis about the mechanism here?

Absolutely not.

I wish everyone knew the difference between patents and copyright.

You can download an open source HEVC codec, and use it for all they care according to their copyright. But! You also owe MPEG-LA 0.2 USD if you want to use it, not to mention an undisclosed sum to actors like HEVC Advance and all the other patent owners I don't remember, because they have their own terms, and it's not their problem that you compiled an open source implementation.

Thanks for the link!

Hi fellow Kate user. I agree.

Ah, much better source: iOS is the answer to where the vulnerability was – right in the headline. I could not find that by searching for the usual keywords in the original post.

What a 90s thing to do! Shrug!

fast forward to the 2020s

Is there an app for that? I don't know how to put a shortcut on the a desktop anymore.

I thought so, but that's what I came to the comment section to know ;-)

Setting a variable by split identifier is surprisingly common in CMake (because functions can't return a value):

> set(${VAR}_VERSION ${VERSION})

This is the main reason I don't like CMake.

But not all governments, thankfully. Remember DVD-Jon? He won the trial for breaking DVD crypto, because consumer rights stood above trade secrets.

I see this as an attempt at a lesser evil, and I would support that (see my EME DRM comment), but I have one concern:

Does this new "privacy preserving attribution" feature respect multi-account containers? Or is it somehow not considered necessary, because it's meant to be less invasive than the tracking cookies it's supposed to replace? Call me skeptical for now.

I'm a happy user of multi-account containers, which lets me separate my cookie identities in Firefox. Before, I had to use different browsers for work and private, and yes, it solves this problem, but the best part is that I don't have to worry about tracking cookies, because they aren't tied to my personal accounts: In my experience, I can to a great extent escape the echo chamber I'm in, and the ads I see in it, by just deleting the cookies of my sacrificial default container.

Other than that, considering the status quo – that the web is already an unfriendly GDPR nightmare, I'm positive to the initiative. And because of the power of the default, I can understand that the feature wouldn't likely take off if it was opt-in, so I won't criticize Mozilla for that move either.

Yes, that line is important.

This has happened before. Remember the critique against Encrypted Media Extensions (https://en.wikipedia.org/wiki/Encrypted_Media_Extensions): Oh no, DRM in the browser! But remember that web video used to require Adobe Flash for the longest time, and even after a decade of HTML5 video, sites were still clinging onto Adobe Flash (and later also Microsoft Silverlight) for what turned out to be DRM purposes. At the time, these plagued proprietary blobs were not going anywhere. Except, after EME had widely supplanted this last holdout usecase, they were quietly allowed to die. The result is that we have much smaller-scoped proprietary blobs in the form of content delivery modules with a lot fewer bugs and portability issues.

Me too. I have a branch with some commits on top of git-revise where I implemented this config option:

~/.gitconfig

    [sequence]
        presentation-order-head-on-top = true

Branch: https://github.com/anordal/git-revise/commits/rebasehappy-in...

Why haven't more people heard of git revise? Unless you actually want to transplant your changes onto a new base, honestly, do yourself a favor and use this instead:

https://github.com/mystor/git-revise

Its inability to change your worktree (operates in memory instead) is a big speed and safety feature: It won't invalidate your build, and you can't screw up the end state.

It also has features that regular rebase lacks, like splitting a commit and editing all commits at once. I'm more than a big fan of it.

He couldn't have come up with a more french name? /s

The following heuristic has become increasingly true over the last couple of decades: If you have some kind of "charset" configuration anywhere, and it's not UTF-8, it's wrong.

Python 2 was charset agnostic, so it always worked, but the improvement with Python 3 was not only an improvement – how to tell a Python 3 script from a Python 2 script?

* If it contains the string "utf-8", it's Python3.

* If it only works if your locale is C.UTF-8, it's Python3.

Needless to say, I welcome this change. The way I understand it, it would "repair" Python 3.

I think you are onto it: Why don't we use a heavier hydrogen-bearing molecule that is actually possible to store as energy bearer?

You mention natural gas; that's one option (CH3 = methane).

Ammonia – NH3 – is another that's starting to look promising and really could use some of hydrogen's hype: https://en.wikipedia.org/wiki/Ammonia#Fuel

Not for personal transportation, though – it's toxic – but for big engines in ships and airplanes.

I'm skeptical because C++ is a slippery slope. Glad to see they are going for templates and concepts, and not constructors and destructors.

Yes, what C++ is supposedly good for – RAII, it actually got a little wrong:

1. Default construction / value initialization: Causes lots of initialization before assignment that is obviously unnecessary. Try allocating a buffer: `std::make_unique<char[]>` surprisingly memsets the buffer.

2. Constructors: No way to fail without exceptions. That buffer example again: Without exceptions, `std::make_unique<char[]>` will actually attempt to memset a nullptr on allocation failure … before your nullptr check (which btw makes the compiler entitled to delete your nullptr check as well).

3. Move is a (burdensome) runtime state that mandates nullability.

4. Destructors: Can't take arguments, forcing objects to contain implicit references to each other.

Rust's affine type system fixes 1-3, but not 4, which only a linear type system could: https://en.wikipedia.org/wiki/Substructural_type_system#The_...

Interesting. I can't help but think of Git as a benchmark for these criteria:

In my mind, Git is very guilty of 1-5, and any CLI would struggle with 6 (save for discoverability), but excels in 7-10.

As such, good criteria: I think they criticise Git the right way.

Do you totally disagree that this is the minimum? I'm only saying that the context is the minimum. I refuse to disagree with you about things I'm not saying.

I also want to slightly disagree, or rather state a minimum:

The most important part of a commit message is the context.

Good enough commit log:

    utils: Minor
    drivers: Fix
    assets: Update
    docs: Typo

Hopeless commit log:

    Minor
    Fix
    Update
    Typo

Context should answer the "what". Think of it as the one word you tell a new conversation participant to let them realize what you are talking about.

The irony is that most people who think they want an app would not see the difference between that and a shortcut to your webpage.

Whether you seek royalties or not, you only want to step on your own patents (or the participating parties, who can agree on licensing), not a patent troll (non-participating entity) whose biggest motivation is to sit on the fence until a deep-pocket company comes along.

Patents against standards: It's a failure of our society when it's near impossible to write a standard without stepping on someone's patent. When an open standard is patented, it is ruined.

France should have listened to GNU/Stallman: You can't have an antifeature in free software. If you try, someone is just going to comment it out.

Yes. I can't take the "untranslatable" claim for good fish when the article doesn't address this obvious objection: Any Norwegian or Danish reader can see that it's the same word as "koselig", likely even etymologically.

Yes, field termination is mostly for permanent installations, but luckily, there are also proper "industrial" connectors that are field terminable. Such as Harting's PreLink M12 connector: https://www.youtube.com/watch?v=35DKv6bhadI

When I say "industrial", I mean for home use, of course. There is obviously a lot of potential for a more robust yet cost effective and practical connector for home use. Field termination being no excuse. First off, even metal 8P8C connectors have plastic tabs. If single-pair ethernet ever takes off, the "industrial" M8 push-pull connector seems a good one.

https://en.wikipedia.org/wiki/Ethernet_over_twisted_pair#Con...

On a general note, I think it's time to call things "text" instead of "ascii".

Every time someone utters the word "ascii", they just mean text. Saying “I'm using ASCII” doesn't mean anything anymore, because nobody uses EBCDIC anymore – you are, no matter what, effectively using a superset of ASCII, by default UTF-8. The real question is which one.

Of all the codepoints below 0x100, why is it so bad at Å?

https://en.wikipedia.org/wiki/Å