Why on earth not? It’s very easy for a computer to check the length of a string, and compare that to a number, there’s absolutely no reason and no excuse for deferring that to the user.
The end user should have every expectation that a generated password will conform to the minimum length setting, and other password settings that are exposed.
Failing to generate passwords that meet the promised criteria is a bug, and not something users should need to have “common sense awareness of”.
Password managers are increasingly mandated by organisations, and Lastpass is a very common recommendation. Even in the minority of technical users that use this kind of tool I expect small mistakes - like accidentally pasting a password in a URL. A good tool doesn't let you shoot yourself in the foot by escalting that to a non-obvious leak. The password length being wrong is 100% on the tool. Th weak master password and the duplicates are again, things the tool shouldn't do - it claims to give good quality security reports.
With respect to Lastpass specifically, I dislike the tool immensely. Ive had to use it a number of times and have always found its UX significantly buggy - included blatant failures like not saving passwords with no indication; coupled with the acquisition by LogMeIn and I'm incredibly distrustful.
Are there more?
std::atomic<int> n = 0;
n++;
let n = std::sync::atomic::AtomicU32::new(0);
n.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
n += 1
In the C++ code, the programmer thinks this variable n "is" atomic. It's an atomic integer right? But that's not a thing. C++ is mapping atomic integer operations, which are a thing, onto the type, and not making the integer itself magically atomic, it's just an ordinary (aligned) integer.
So if we tweak both examples to do some slightly trickier arithmetic...
std::atomic<int> n = 0;
std::atomic<int> m = 0;
n++;
m= m + n;
use std::sync::atomic::{AtomicU32, Ordering};
let n = AtomicU32::new(0);
let m = AtomicU32::new(0);
n.fetch_add(1, Ordering::SeqCst);
m.fetch_add(n.load(Ordering::SeqCst), Ordering::SeqCst);
use std::sync::atomic::{AtomicU32, Ordering};
let n = AtomicU32::new(0);
let m = AtomicU32::new(0);
n.fetch_add(1, Ordering::SeqCst);
m.store(m.load(Ordering::SeqCst) + n.load(Ordering::SeqCst), Ordering::SeqCst);
1Password is fantastic, but expensive and closed source. Bitwarden is open source, but lacks certain auditing, team and sync features useful for enterprise. KeepassXC is excellent and open source, but with zero collaboration features is only suitable for self use.
disclaimer: was involved on the 2fa part of it.
It's a shame, because I think the idea of it is nicer and no less secure than Google Auth, but I'd much rather enter 6 numbers than wait for the app.
Disclaimer: This was around a year ago, perhaps it's improved since.
You can't delete an entry but you can deprecate it and stop updating it (it's not actually feasible to revoke access anyways).
Mainly driven by the combination of price increases, no improvements (and possibly getting worse) at things like the auto-fill buttons conflicting or not working with many apps I was using, the duplicate entries it would create, failure to match Android apps and web logins, and the constant battle to try to get it to work with several internal apps and test systems (same top-level domain, where I have a mix of unique and common logins) while also working on the web generally.
Bitwarden has per-domain selection of match type (full host, base domain, or regex), and a non-interfering UI. I can't think of a single thing LastPass does better.