pipeep

Isn't that pretty much what `#![no_std]` is for? You can still use an allocator with no_std, but you have to explicitly import it.

https://docs.rust-embedded.org/book/intro/no-std.html

I left the team before most of the work to open source it happened. It looks like a lot of work went into the documentation, command line interface, and configuration system. Congrats to the whole team! I hope this can be useful to other projects outside of Facebook.

The internet connectivity is sold as an additional feature so that you can use your blu-ray player to watch Netflix. I agree that I don't want logging on a device like this, but if I was going to connect one of these to the internet, I would at least want regular security updates.

- Containers are a feature built into Firefox, these extensions just expose a UI for it. The Multi-Account Containers plugin [1] is published by Mozilla. You don't need to trust anyone but Mozilla to use that base set of functionality.

- The container functionality in Firefox is the result of some work from the Tor Browser being upstreamed into Firefox [2]. It seems reasonable to assume that it's well-implemented.

- The limitations of the extension that you linked to don't seem any worse than your profile-segmentation approach. It's just saying that it's possible for multiple websites to get opened in the same container, which is similar to how you could end up opening multiple websites in the same profile.

[1]: https://addons.mozilla.org/en-US/firefox/addon/multi-account... [2]: https://blog.torproject.org/tor-heart-firefox

E.g. Debian currently has a 5.5 kernel in buster-backports[1]. However, Debian's backported kernel doesn't get the same level of attention and isn't subject to the same security policies as stable releases, so may be lacking some security patches that the stable kernel has.

[1]: https://packages.debian.org/buster-backports/linux-image-amd...

The physical server has a fixed set of resources. If you let customers pick what resource they want to buy, you'll run out of one resource before the rest, leaving the server underutilized and increasing your costs. You can't sell KVM instances with no ram, no disk, or no CPU.

If you have enough physical servers and small enough customers, you can mostly solve this by carefully figuring out which customers to put on which machines. However, you've created a complicated jigsaw puzzle. And what happens if you need to shift customers between servers to balance things out?

I think Google is able to offer custom machine types because they're big enough, and because they're able to perform live migrations between physical hosts (most hosting providers can't do this), so the customer likely won't even notice if they need to be migrated.

Instead, most of these providers offer a few different SKUs to satisfy different use-cases, or they just pick one target market (e.g. lots of disk space for backups or lots of CPU resource for compute) and focus on that. A few offer networked block storage, which gives some more flexibility, but at the (potential) cost of reliability and performance.

> None in Asia though? You need it to be in Taiwan to service the region well!

Bandwidth in Asia is significantly more expensive (https://blog.cloudflare.com/bandwidth-costs-around-the-world...), so most budget hosting providers stay away.

Any other hypervisor. QEMU/KVM, Xen, VMWare, and Parallels all have good track records.

If you're looking for something even smaller and cheaper than $5/mo, I've had luck with BuyVM. They've very cheap, have good customer support, a nice panel, and you get an entire /64.

https://www.theverge.com/2017/5/18/15659414/facebook-messeng... https://play.google.com/store/apps/details?id=com.facebook.m...

The value of the network does go up the more people use it, and therefore, there are more transactions per user. However, the amount of transactions that each user produces will probably not scale linearly with the network size.

Web search engines:

- Outride (2001)

- Kaltix (2003)

- Akwan Information Technologies (2005)

- Orion (2006)

- Aardvark (2010)

- PlinkArt (2010)

- Metaweb (2010)

- Like.com (2010)

- Apture (2011)

Granted, none of these were very high-profile, and Google hasn't acquired any other web search engines either, but to say "Google has never had to buy a competitor" is naive.

They've also spent a lot of money acquiring competing companies that aren't related to their core business. YouTube competed with Google Video before they were acquired. DoubleClick competed with AdSense (and arguably, Google stole DoubleClick's model). Waze competed (and still competes) with Google Maps.

Acquisitions aren't a sign of weakness.

They're intentionally contradictory, but that's just an acknowledgement that perfection is impossible. When you choose to focus on one aspect of your career, that's often going to be at the detriment of something else. This also means that there's always room for career development and self-improvement.

A sufficiently intelligent compiler would be able to heuristically determine if the synchronization overhead for a program segment would be greater than the performance gain. Plus, there's lots of little cases where synchronization overhead is trivial, like map().

C isn't the best language for this, but there's plenty of languages (e.g. Haskell) that have data flows that can be thoroughly statically analyzed for dependencies.

> It's also a bad idea to take away control from the programmer.

Ideally you'd have compiler pragma to disable this on a case by case basis, and you'd still have more traditional parallel programming tools available.

> What if every compiler did automatic parallelisation differently? Then you'd have impossible to fix performance problems.

If you had a bad enough performance regression, you'd disable automatic parallelization and file a compiler bug (because it shouldn't regress below single-core performance). You could make this same argument against any optimizing compiler. They all apply different optimizations, and do sometimes lead to "impossible" to fix performance problems or even contradictory execution behaviors between implementations. But I still think `gcc -03` is invaluable.

I don't think automatic parallelization is a cure-all, or even that it should be enabled by default on compilers any time soon, but it's better to have it as an option than not.

https://github.com/bgw/dash-button/blob/master/openwrt.sh

http://www.wsj.com/articles/silicon-valley-cafeterias-whet-a...

Beyond that, flash drives tend to have low write durability and horrible performance on large writes (because of poorly implemented garbage collection).