Facebook Engineering

First of all, the Facebook app is literally an entire operating system unto itself, among other things. Like someone pointed out, there's an entire Craigslist, an entire Snapchat, an entire Yelp, an entire YouTube, an entire web browser and so much more stuffed into a single app. On top of that, there are probably thousands of A/B tests and divergent code paths that are running simultaneously. Even if you have a feature, you probably have the code to switch between 10 different variants of that feature. There's also complex real time user instrumentation, media storage and backup features, tons of custom animation frameworks, networking frameworks, caching frameworks and on and on and on. The level of complexity and the millions of man-hours worth of code backing that app is insane.

At this point, it shouldn't be surprising in the slightest that the app is a cool ~300megs. Could it be better? Sure, and I'm sure they're working on it. After all, look at their developing country strategy and the stuff they do with "Facebook For Every Phone" to shave off every last byte from their apps: https://code.fb.com/android/how-we-built-facebook-lite-for-every-android-phone-and-network/

If you look at the incentives, it's NOT in their best interests to make updates hard. That's not how they make money and in developing countries it actively costs them business. It's not that they're intentionally bloating the app just to mess with you....it's just that there's really that much going on…

I think static typing is needed in a low, middle level programming language to help the optimizer, and make sure values doesn't go out of bounds. Fanny enough higher level languages like JavaScript (and probably python to, I don't know Python) are strictly typed eg. you can never go out of bound and get overflow errors, have dangling pointers, etc. When you already have strict typing, there's less need for static typing.

If the statically typed language is compiled to a dynamic language, you will lose most of the performance gains too, for example Dart is almost like JavaScript-with-static-typing, but it's twice as fast because the compiler can actually make use of the static types.

I also think static typing bolted on to a dynamic higher level languages do push you into an object oriented paradigm.
And I think the language becomes uglier with annotations.
And it makes people lazy so they name things x, y, z because the type annotation fills in the rest.
But who cares about syntactic preferences, code readability and naming things :) The real reason you use static typing is to catch bugs ... But the best way to catch bugs is to understand the code, and have many people read it. When I see less good programmers the workflow goes something like this:

-I want to do foo ... autocomplete ... fooBaz, fooBar, fooFoo ... hmm, what can I do with foo ... autocomplete ... foo.bar sounds like what I need, it takes a baz, new Baz() ... damnit how do I get rid of this null exception…

Nope. It's all 100GbE throughout as far as I know. And people do work really hard to be able to saturate that bandwidth as it is by no means a trivial task to saturate it through the usual, naive means without the use of RDMA and Verbs. Years ago when I was there it was (IIRC) 40Gbps to each node straight up.

It's a necessity really. All storage at Google has been remote and distributed for at least the past decade. That puts serious demands on network throughput if you want your CPUs to actually do work and not just sit there and wait for data.

Here's some detail as of 2012: https://storage.googleapis.com/pub-tools-public-publication-data/pdf/43837.pdf. Note that host speed is 40Gbps. And here's FB talking about migrating from 40Gbps to 100Gbps in 2016: https://code.fb.com/data-center-engineering/introducing-backpack-our-second-generation-modular-open-switch/

It's a theme I like to read about (I mean "practical issues around ML in production settings"). I find company blogs and some research publications are great resources. Examples:

- https://eng.uber.com/
- https://code.fb.com/

and many more. Google also publishes papers on various engineering practices obviously, some ML-related, but I can't find a blog where they focus on that specifically.

Also it's not "to keep up to date", but there's a great paper (from Google) that's often cited:

Machine Learning: The High Interest Credit Card of Technical Debt
https://ai.google/research/pubs/pub43146

It talks about issues you face over the long run (I've experienced some of those). It
also provides interesting pointers for further reading, e.g. about "pipeline jungles".

If others have pointers, I'm curious to hear about them as well.

There is a Ruby port [1] publicly available. From the encoding routine [2], it seems to be an sRGB correction followed by a two-dimensional DCT. The first two bytes encode parameters---the size of the output matrix n x m and the quantization scale used for ACs; next 4 bytes encode the DC, then (nm-1) quantized ACs (2 bytes per AC) follow. The comparison to Facebook's similar solution [3] would be interesting (but I realize that Blurhash tries to hide explicit images, so technically they have different goals).

[1] https://github.com/Gargron/blurhash/

[2] https://github.com/Gargron/blurhash/blob/master/ext/blurhash/encode.c

[3] https://code.fb.com/android/the-technology-behind-preview-photos/

I agree with the spirit of what you're saying. Too often I've seen folks on HN dismiss languages because they didn't have features X or Y, usually with a condescending "maybe this language's creators should read some PL theory". I remember circa 2013 or 2014, it became impossible to read threads related to Go because the entire thread would always be "a Real Language(TM) needs Generics". Look at the success Go has seen in the last decade while doing the opposite of what HN thought was correct.

That said, there do exist useful products written in Haskell. For example, Facebook writes a lot of spam fighting code in Haskell. https://code.fb.com/security/fighting-spam-with-haskell/