I’ll wait until it gets crash-safe filesystem.

Sure, something like ZFS would be nice, but in a router not needed as you'd mount the fs rw only during update, wouldn't you? Logs are either on a separate, RAM based fs (tmpfs) or (preferably) sent to a remote logging host.

You might want to have a look at e.g. https://www.mimar.rs/blog/how-to-increase-openbsds-resilienc...

FFS can crash quite safely. The chance of lost data is incredibly small, especially with "softdep" out of the way. It just doesn't come back online as fast as a journaled file system will.

One of our mac mini CI server also failed to boot after update today. When it happens on Linux I usually try to troubleshoot the problem rather than resetting a whole machine. It does not seems to be feasible on macos with reasonable effort because of recently-introduced security features (and also my lack of understanding of macos boot process).

`Just a` / `Nothing` in case of Haskell :)

Could the algorithm be applied to block cache problem with single item size, like filesystem block cache or database cache?

I was wondering the same thing. I suspect its value would decrease in those cases, due to the lower-level representation providing less semantic association, and therefore less information (per unit object) for modeling hit rate and lifetime. Also, the higher objects count would require more resources.

Edit: perhaps in a file system, the higher-level information could still be provided?

Even within database caches, while the page size is often fixed you are still caching and operating on more abstract multi-page objects of variable size. In a good cache replacement algorithm there is some implicit awareness of the relative sizes of these objects to optimize the replacement policy.

I used it frequently when mixing `Result` with `Future`. For example,

  fn do_something() -> Box<Future<Item=(), Error=Error>> {
    let val = match do_result() {
      Ok(x) => x,
      Err(e) => return Box::new(err(e.into())),
    };
    // do something with `val`
    unimplemented!();
  }

If you want to cut down on lines, this is equivalent:

    let val = do_result().map_err(|e| Box::new(err(e.into())))?;

It's a feature, just like strace or something.

I seems that someone discovered KASLR from NT kernel. https://twitter.com/aionescu/status/930412525111296000

Could you write default username/password on a release page? :)

I have added it. The username is `user` with an empty password, or `root` with a password of `password`.

The only way to change this at the moment is to edit `/etc/passwd`, where they are stored after being encrypted using argon2.

>after being encrypted using argon2.

Nitpick: s/encrypted/hashed/

True

more general, adaptive version: https://github.com/armon/libart

Yes, that's pretty elaborate :-)

There's space in qp tries for jumbo nodes - they currently use flag values of 0, 1, 2, so 3 is available for byte-at-a-time branches.

Careful, you're going to reinvent libjudy. :P

Faster version with SIMD instructions: https://github.com/lemire/simdcomp

Yes, Simdcomp has faster encryption/decryption, but with Delta compression. FOR is a bit simpler and has faster random access.