adament

But a synchronous function can and many do make network calls or write to files. It is a rather vague signal about the functions behavior as opposed to the lack of the IO monad in Haskell.

To me the difficulty is more with writing generic code and maintaining abstraction boundaries. Unless the language provides a way to generalise over asyncness of functions, we need a combinatorial explosion of async variants of generic functions. Consider a simple filter algorithm it needs versions for: (synchronous vs asynchronous iterator) times (synchronous vs asynchronous predicate). We end up with a pragmatic but ugly solution: provide 2 versions of each algorithm: an async and a sync, and force the user of the async one to wrap their synchronous arguments.

Similarly changing some implementation detail of a function might change it from a synchronous to an asynchronous function, and this change must now propagate through the entire call chain (or the function must start its own async runtime). Again we end up in a place where the most future proof promise to give for an abstraction barrier is to mark everything as async.

This is function overloading, you can do the same thing in C++. In Python you type this using the overload decorator from the typing module.

It is not a matter of the age of your hardware but your software. Ipad mini 4 got its latest OS update in 2023. The problem is that in the Android ecosystem it is unfortunately common to only have a short window of OS updates from the release date of the hardware.

But usually these other devices can also update their software, it is quite unique for the android operating system to run old and unupdatable software.

Or they should if they are web facing. For security reasons at least.

But would you version it by storing it as output in an ipnyb file where it is overwritten if you rerun that cell? I would store the data in a versioned database or as separate data files in the repository (possibly stored in git-lfs). And I would store results of the analysis as data files / image files / whatever else, NOT as ephemereal outputs in an ipynb file. But I am pretty far down the “ipynb files are for local use only” path.

If for some reason you really wanted to compute Fib(n) for ridiculously large numbers of n, you would probably use that [Fib(n), Fib(n-1)] = A [Fib(n-1), Fib(n-2)] for the transition matrix A = [[1, 1], [1, 0]] and thus [Fib(n+1), Fib(n)] = A^n [Fib(1), Fib(0)] and then use exponentiation by squaring to compute A^n directly and thus Fib(n) in log_2(n) steps.

When I was a kid and trying to learn LaTeX this happened to me all the time on the library computers.

I do not think I have a point, you just made me remember some fun and dreadful moments.

I think your point is valid and important, especially considering the average user. However in my experience it worked surprisingly well with a long word based master password. Since I only needed to remember 1 password that I then used daily it was not that difficult. And typing it was quick since it was all lowercase which most keyboards are optimized for. However the issue came when I started using my password vault on my phone and tablet. I was way too slow at typing on them. I now have a 22 character password which takes the same time for me to type on a keyboard, maybe a bit slower, but is faster on my phone though still annoyingly slow.

As for 70 bits password, it might be enough, but you need a lot of iterations (2^58) if you want to completely make up for the lost security margin. Which will also be unusably slow in practice.

I am not a cryptographer but to my understanding, the number of PBKDF iterations is really only of concern for weak (low-entropy) passwords. If you know that your password has high entropy (>128 bit), for example because you generated it randomly uniformly from at least 2^128 possible outcomes[1], you are safe even if you used only 1 iteration. PBKDF is all about password strengthening, so if you are making changes for yourself the most effective change is just to use a secure password and stop worrying about key derivation functions.

[1] 28 characters in a single case, 23 characters if both upper and lower case are used, 22 characters if you include numbers, 12 words if you use a word list of 2000 words and sample uniformly

If I recall correctly it is the standard libraries(such as libstdc++) that need this exception and not the compiler itself.

That is good news, thank you! And I apologize for spreading incorrect information.

Interestingly the FSF also requires copyright assignment for contributions to GCC, Emacs and some other GNU software.

I had the same thought about the 200% thing. Actually I think it is either empty boasting or a difference of terminology. I understand giving 100% to mean: I give as much as I possible can. Giving 200%(or anything above 100%) sustainably for all your career sounds impossible by definition to me.

As an aside(since you used him for the author) I found it interesting that the author (according to her LinkedIn profile) is a woman. My initial prejudice was that giving so much more than everything to your work sounded like something that is only possible if you have a partner taking care of everything at home. And I immediately assumed this must be due to traditional family roles.

But this is exactly what happens when you fine a company.

Unless you fine the company enough for it to go into bankruptcy in which case the shareholders are protected by limited liability and the creditors take the hit instead. But the bankruptcy angle is completely irrelevant to this case, none of the fines considered are close yo bankrupting Google.