zielmicha

I think this is a really bad idea unless paired with some regime that penalizes inappropiate use of alarms - and most societies don't treat noise pollution as a real problem. For example, people honk all the time even when there are no safety issues. Or have misconfigured home/car alarms. Outlawing using ANC for blocking "fake alarms" only makes the problem worse.

Can you explain this in more detail? It doesn't seem true on a first glance.

If you enable compression on ZFS that runs on top of dmcrypt volume, it will naturally happen before encryption (since dmcrypt is the lower layer). It's also unclear how it could be much faster, since dmcrypt generally is bottlenecked on AES-NI computation (https://blog.cloudflare.com/speeding-up-linux-disk-encryptio...), which ZFS has to do too.

SSH is actually really slow on high latency high bandwidth links (this is what HPN-SSH patches fix: https://www.psc.edu/hpn-ssh-home/hpn-ssh-faq). It's very apparent if you try running rsync between two datacenters on different contients.

HTTP/3 (and hopefully this project) does not have this problem.

(To be clear, I'm not the author of the post, the title just starts with "How I")

> It is impossible for something to be a good investment and affordable. They go against one another.

Why do you think that's the case? Many companies are a good investment, while they still provide affordable products. Something can be cheap in an absolute sense, while still providing a good return on investment.

Could you have instead changed your code? It's generally best to assume that it's not possible to delete secrets once they are shared (after all, in worst case, the driver could have just remembered the code from the previous visit)

Is there anything that stops patients from lying that they are in a different state (just temporarily)?

> I couldn't find a single datetime library that has a concept of instances that could be interpreted in different time zones.

Jane Street's Core has a good timezone support (the thing you need is pair Date.t * Time_ns.Ofday.t). sqlite3-ocaml [1] seems reasonably documented.

[1] https://github.com/mmottl/sqlite3-ocaml

You can also share arbitrary binary data between processes by using shared memory (e.g. Python has support for this in multiprocessing.shared_memory module).

Yes.

ZFS-based RAID-5 (called raidz1) doesn't have write hole.

https://blogs.oracle.com/ahl/what-is-raid-z

fsync is still a bit slow on BTRFS (on ZFS too, but to a smaller degree). For example, I just did a quick benchmark on Linux 5.3.0 - installing Emacs on fresh Ubuntu 18.04 chroot (dpkg calls fsync after every installed package).

ext4 - 33s, ZFS - 50s, btfrs - 74s

(test was ran on Vultr.com 2GB virtual machine, backing disk was allocated using "fallocate --length 10G" on ext4 filesystem, the results are very consistent)

PyPy doesn't completely implement Python C API (which anyway is specified only by the CPython implementation, not in any formal manner).

The variables would need to be constrained to be integers/booleans. And Integer Linear Programming is NP-complete.

What's the point of dual PSU if not reliability?

> PyPy is great, but not drop in.

Nowadays it works correctly with almost all C modules. Mostly you just need to use `pypy3 -m pip install foo` instead of `python3 -m pip install foo`.

You don't need fsync if you only care about your user process being killed. It protects only against power loss/kernel crash - the filesystem is not running as user process, so it can't be killed.

I think it shouldn't be hard to do that automatically in software - you only need to know exchange rates at time of every transaction.

You can imagine you are converting BTC to dollars right before purchase. If you had 1 BTC worth $1000 at the beginning of the year and then 6 months later (when it was worth $1500) bought something with it - you earned $500 in capital gains. (Not saying this is the current law, but that method seems to make sense)

OpenWRT runs on routers with 8MB of flash and 64MB of RAM and it includes whole wifi stack, routing and browser based GUI.

https://openwrt.org/supported_devices/432_warning

Maybe the problem is that you can use uncomputable numbers in the matrix? (e.g. https://en.wikipedia.org/wiki/Chaitin%27s_constant)

Address/Undefined Sanitizer (-fsanitize=undefined) will detect many undefined behaviours (but at runtime).

- fsync on btrfs is extremly slow. The situation has improved in last 3 years, but it is still much slower than ZFS. I just did a simple test and BTFS is 12x slower than ZFS (on my customer SSD, for small writes).

- RAID5/6 mode is only experimental in btrfs, while it is really stable in ZFS.

- I don't have concrete data for that, but in my experience, BTRFS has high latency (>1 second) even for small file operations when under load.

- While that should not be a problem for production systems, I have some crappy hardware where BTRFS oopses or corrupts data, while other filesystems (Ext4, ZFS) work fine.

There is an open standard - it's called Web Push (https://www.w3.org/TR/push-api/). It's already used by Firefox and Chrome to implement push notifications for web pages (via service workers). The notifications are proxied via Mozilla/Google server respectively, but there is no reason you could not run your own server.

> The only wireless security I put any real trust in is WPA2 Enterprise with 802.1x certificate-based authentication specifically.

802.1x with a certificate for Radius server (TTLS mode, which simply layers the plaintext password via TLS) and plain passwords for users is also good enough.

Google Translate (to English) works really well on this article.

In Poland, for example, the chairman of this regulatory body has 4 year term and is unremovable. So he doesn't have many reasons to be political.

You can use "objdump -S" on a binary compiled with debugging symbols. (This way you can get assembly in Intel syntax with "-M intel")

Is it true?

You can get depth sensing (time of flight) 2D camera Orbecc Astra for $150 or 1D laser scanner RPLIDAR for $300. Of course they are probably not suited for automotive, but for me even extra $2000 for self-driving car sensors isn't that much.

Even Python doesn't need to have stack limit - just make sure C stack is large enough (e.g. using ulimit or pthread_attr_setstacksize) and use `sys.setrecursionlimit(1000000000)`.