@mdrights https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/read looks like being allowed to read the clipboard is behind a permission that you have to grant (and Firefox only allows it for browser extensions).
@xerz for integrals (and derivatives) I don't even try anymore, I've learned that for all practical purposes they are just done by looking up in a table (and wolfram alpha is the quickest way to perform that lookup)
@xerz Gonna wake up from a coma 20 years from now and ask "so is most property ownership tracked as NFTs on the blockchain yet" 🙃
@martijnbraam I've done it by installing the desktop Plasma system settings app, then going to the power section there and disabling the timeout stuff in there (although it would be convenient if that section was just added to the mobile settings app)
@EdwardTorvalds ...and so, even if the usages of `unsafe` in the standard library require manual auditing to verify that they are safe, programs that then use those functions from the standard library do *not* need manual auditing to prove they're safe, unless they themselves decide to include some code marked `unsafe` (which is rare).
@EdwardTorvalds The second idea that follows from this first idea is then that you provide safe APIs to your routines or structures that might use (a few lines of) `unsafe` code on the inside. If someone has manually verified that you're not doing anything memory unsafe in your `unsafe` lines of code, then it becomes trivial to provide a safe API to those routines that *can't* be used to cause memory unsafety to happen.
@EdwardTorvalds The idea is that you only need a little bit (like a couple of lines) of code that's marked `unsafe`, if you need it at all. (Also `unsafe` doesn't allow literally everything, it basically only allows you to dereference raw pointers and call FFI functions) That means it's *way* easier to audit the few lines where you've explicitly pointed out that you're doing something "suspicious" to show that it's safe, and then infer that the rest of the codebase must then also be safe.
@zens the probability of *symbol* error is just the probability that noise in the channel will cause a transmitted symbol (e.g. one of the 16 points in your QAM constellation) to be received as a different one of those points, and using your code (e.g. Gray code) you can estimate how many bits inside the symbol (since one symbol in that case contains 4 bits) would be changed by that error
(and channel=tape, transmitted=recorded, received=read back)
@zens I only found http://www.comlab.hut.fi/opetus/333/reports/Jing_error_probability_of_digital_signaling.pdf which is just a set of lecture slides, but it was a bit hard to find good resources with concrete answers. Some key concepts to know when reading it (look these up on Wikipedia) are AWGN or average white Gaussian noise (the most common mathematical model of a channel with noise), the Q function (a probability-related function), and "Eb/N0" (a sort of normalised SNR measurement, also the Wikipedia page really is named that).
Enthusiast of memes, Rust, Matrix, Godot, maybe some other stuff as well. @vurpo:hacklab.fi
The social network of the future: No ads, no corporate surveillance, ethical design, and decentralization! Own your data with Mastodon!