acconsta

In the current Redox design, everything runs in privileged mode, so it's kind of the ultimate monolith?

Along with iOS ad blocking, this seems like a big shift in Apple's stance toward Google.

That looks excellent. What hardware?

I know this is a young project, but right now it looks like a terrible waste of Rust's features. Raw pointers everywhere, most allocations unchecked, and 264 unsafes in just the kernel.

unsafe is a necessary escape hatch, but the temptation to use it to write C-style code is strong.

>I could probably write a lengthy blog post on our experiences of C++ vs Java

I'd be interested in reading that. There's still a lot of FUD around using C++ for new projects.

>the code usually doesn't even pretend to work

It does pretend to work for a while, often failing in another function, in another file, with a cryptic message. All preventable by a simple type check.

Already exists for memcached!

https://github.com/scylladb/seastar/wiki/Memcached-Benchmark

On Windows

So it comes down to historical compatibility with B? Wow.

Do any IDEs support large (million+ LOC) code bases?

Yeah, although I don't know how parallel it is because OCaml. I think they might have gotten a multiprocess architecture working?

Very interesting, thanks

Source? How do you get 80% CPU utilization if you have to physically separate all your job types?

http://csl.stanford.edu/~christos/publications/2015.heracles...

For... building software? I thought dependent types haven't escaped research languages.

Yeah... so it seems like Linux containers can be sufficiently hardened?

Take a look at sched_setaffinity and Intel DPDK.

Google built multi-row transactions on top of a partitioned row store though? I guess I'm not really sure which applications have a shared memory architecture like the one you're describing.

And to be fair, some people are pretty productive in modern C++. It's a shame the JNI isn't better so you can have the best of both worlds.

(for the record, Quasar is #1 on my list of libraries to try if I go back to Java)

Yeah, I get the impression Linus fucking hates GCC :P

That's good though. Compiler freedom is better for everyone.

Me too. I've been thinking about doing an analogous benchmark in C++ for a while.

No, but the Gmail team might be worried about some Russian guy finding a buffer overflow in YouTube's application. Then what? They can escalate privileges and read your email?

It's not quite plug-and-play, but it does seem like there's been some progress.

https://lwn.net/Articles/644681/

You can still offer isolated transactions, tunable consistency, etc. within a shard though, which Cassandra does.

And yes, you can write high performance Java, but for whatever reasons the Cassandra codebase isn't an example of that. They just did a big storage engine rewrite and the result is slower.

https://issues.apache.org/jira/browse/CASSANDRA-7486

Are linux containers really not securable? That's how Google runs all their stuff in production.

http://research.google.com/pubs/pub43438.html

Oh, oops. 471, 508 679, 766.

What's weird is five hours after asking that question, no one has provided a reasonable explanation of why C requires arrays to become pointers on function boundaries.

My "online search" found Walter Bright, who knows a thing or two about C compilers, wondering the same thing:

https://news.ycombinator.com/item?id=7572011

You can pass structs by value. Why not arrays?

Right. I think that's mostly immutable containers though, right? Or is the compiler smarter than that?

OK, data definitely helps. It's not always easy to predict what modern CPUs will do!

For the record, there seem to be a lot of bounds checking independent of indexing:

https://github.com/rust-lang/rust/blob/master/src/libcollect...

https://github.com/rust-lang/rust/blob/master/src/libcollect...

https://github.com/rust-lang/rust/blob/master/src/libcollect...

https://github.com/rust-lang/rust/blob/master/src/libcollect...

Cassandra's performance scales linearly with the number of nodes though, so per-node performance definitely matters. Probably not 10x, but probably not 1x either.

Great! Please implement them in Rust as soon as possible.

But until then, Rust's approach is runtime bounds checking.