arielb1

There's nothing preventing you from transporting an SSH public key over some other secured channel. Then it's "I know that you are someone that has access to the SSH key transported over that secure channel".

It is very easy to write a virus that is not detected by any anti-virus. I don't see how dropping an SSH key on some machine is worse than dropping a remote shell on it.

It's not like SSH keys are stealthy or something - any sysadmin worth his salt will occasionally look at his authorized_keys list.

We already have `std` for that. The point of a "Rust platform" is that you can have confidence that the libraries you are using are of decent quality, reasonable popularity, and will be maintained.

A hacked server can have the backup server pull false backups as well.

Of course, your servers shouldn't be SSHing to your backup servers, but that goes both ways.

Many of the (non-techie) people I know have Whatsapp push notifications disabled, because otherwise there are way too many of them.

That part is certainly extreme because of ownership. It can be refactored to

        let mut words = HashSet::new();
        for line in file.lines() {
            let line_words = line.unwrap().split_whitespace();
            words.extend(
                line_words.map(|s| s.to_string())
            );
        }
        words.into_iter().map(move |word| (word, f))

Closing the connection would cause the client to believe that the file has been fully downloaded - resulting in a truncated file. Not good.

HTTP does not have a way of sending an error in-mid-transfer, so a TCP reset has to suffice. The other option would be to blackhole the connection, but that would be worse for both sides.

PCs are still used more than mobile. It's just that the average person had bought a Pentium 4 PC running XP a decade ago and is not going to upgrade it until it breaks.

PCs are now a mature technology, just like cars, and have the resulting long lifecycle.

Smartphones are also getting into this stage.

We do have a planned optimization that would fold the tags for cases like `Option<ForkResult>` to give a word pair, which should be returned in %eax:%edx (or %rax:%rdx).

The complicated part of Paxos is not these 25 lines of code, but all the extensions people add over them.

> That's not really high praises, "I expected Foo and you gave a Bar" is pretty much level 0 of static type checking which even javac manages, you'd have to work hard to fail to provide even that.

If you know the language well, there really isn't anything more to say - your code wants the `Debug` bound, but it is not present. Either change your code or add the bound.

I am going to improve the error reporting to use a better error message in this case.

But if you have r=sqrt(n) that works out fine.

You need unsafe to implement the C API part of a DNS resolver, but the API can be given a safe wrapper without much effort. Then parsing and buffer management bugs would occur only in safe code and only affect it.

Rust does not really have an RTS per se. libstd is just a standard library.

Also, even if rustc has soundness bugs, you won't find them if you don't look for them, and even then, just trying to make your program fit the types will prevent most bugs.

By the way, glibc's code is too horrible to be read - musl is a more modern alternative.

As a brute-force fix, you can disable DNS in /etc/nsswitch.conf and put the addresses you need (at least security.debian.org, YOUR_MIRROR) in /etc/hosts.

Rust can have the same ABI as C - rewriting NSS in Rust should not pose ABI problems.

That's what you get when you have thousands of lines of code with variable names like `thisanssizp`. glibc should die in a fire.

200-character-long-lines don't fit in an eye's useful field of view. The problem is that websites have multiple columns of varying fixed width, so that a narrow window will give some websites a tiny actual line-width.

Rust only provides short reexports for a stable set of a few dozen items, rather than the "entire universe" of `using namespace std`. The only types that have a default reexport are `Option`, `Result`, `Box`, `String` and `Vec`.

If you are serious, you should limit SSH access to a bastion host with no unprivileged users.

> as they seem to have made a correct calculation that they can extract money out of taxpayers through this junk paper, and that is not what any economist would praise as markets functioning for the benefit of society.

Well, it's not like the credit agencies bailed out the banks themselves. The version of the criticism I have heard was that the banks (and credit agencies) knew that the taxpayers will bail them out if they fail, and therefore they took unnecessary risk - making investments just as useless as the nails made by Soviet nail factories.

This may be better than allowing the bit to desynchronise your firewall's state machine. However, if you want to be nazi like that you may actually prefer not to route your network to the Internet at the IP layer but rather provide application-level proxies (IIRC Check Point products can be configured like this).

Certainly they may have covered many edge cases, but they may have covered them in a way that interacts poorly with your program. Unicode uppercase to lowercase is ill-defined enough there is no single good solution.

No, even vanilla ARM. x86-64 instructions are 3-5 bytes in size and compilers don't use complex instructions effectively.

x86-64 somehow manages to be less compact than ARM while still being variable-length. Thumb is still much saner than x86/x86-64.

All operating systems with separate user and kernel modes have a privilege-level round-trip on every syscall (typically `sysenter`/`sysexit`, on older systems the classic `int $0x80`/`iret`). This is just a controlled jump that changes the privilege level, and is what is bypassed by vsyscall.

Non-shared-cr3 Macs (and IIRC some versions of PaX) also change `%cr3`, which means user-space and kernel-space have completely different address spaces (rather than a shared kernel-space and per-process user-space). This is much more expensive.

Of course using regexes on general-purpose HTML is a bad idea. Using regexes to ensure the sanity of a restricted markdown converter isn't, especially if you want to err on the side of conservatism.

You can write a doubly-linked list rather easily with `RefCell<Rc<..>>`/`RefCell<Weak<..>>`.

That still won't prevent a zero-ish noisy `q` from causing a totally messed-up `rel_val`.

C certainly can do SIMD just as well as assembly (via intrinsics). It does not allow high-level code to be compiled to SIMD, but there is no known way to compile high-level general-purpose code to SIMD. Finding such a method is an Open Research Problem AFAIK (of course, solving it would be Very Welcome).