Game_Ender

Planet money podcast said we did about $7 trillion in stock buy backs over the last 10 years [0]. That is $700 billion a year, so a 5% tax is $35 billion a year.

It’s a lot of money, but not enough for fundamental change. It would of been enough collectively to pay for the stimulus we are doing now though.

0 - https://www.marketwatch.com/story/sp-500-companies-spent-7-t...

Facebook rewrote Mercurial, while Microsoft has essentially expanded git with their own virtual file system VFSforGit [0] and a bunch of performance improvements.

0 - https://vfsforgit.org/

We have had awesome success with Buildkite [0] and self hosted build agents on EC2. We use the provided autoscale lambda and it’s pretty hands off system [1]. You also get the upside of controlling how much local caching you want to do.

0 - http://www.buildkite.com

1 - https://buildkite.com/docs/tutorials/elastic-ci-stack-aws

The first step on the road to a freeze is a headcount cap. If you have 10k engineers and 2% are fired/quit each year that still means 4 new people are starting each week.

I believe this machine is really the NORC [0]. Some highlights from the Wikipedia article: It had 2000 words of memory, each that stored a ~13 digit decimal number and it ran at about ~15000 operations/second. It was considered the most powerful computer in the word when released, and at the dedication it set a record for pi @ 3089 digits, calculated in 13 minutes.

0 - https://en.m.wikipedia.org/wiki/IBM_Naval_Ordnance_Research_...

I think the point is you cannot go infinitely far with that concept. Wealth allows you to get a share of the productive capacity of the world. Giving everyone a billion dollars does not automatically mean we have enough production capacity and land to have everyone live in a mansion.

Now we can certainly say that "hey maybe if these guys all didn't have such a big mansion or as many cars everyone else would be better off", but you have to be explicit about that. It's about taking away things people like and to put that effort elsewhere.

That feature breaks down in the presence of merges. But when those are not present it works OK, you see lines like this:

> force-pushed the aojea:affinity branch from 8eab3f7 to ee626e7 yesterday [0]

Where the "force pushed" links to a pretty decent UI [1], but it will include a bunch of non-import information if the person rebased and force pushed, which is a common reason for force pushing.

You can see that in this [2] long lived Kubernetes PR that was rebased, the resulting "helpful" link shows me 2094 changed files [3]. In a tool like Gerrit or Phabricator this is automatically handled and it would basically ignore this operation unless the rebase changed the code being reviewed.

0 - https://github.com/kubernetes/kubernetes/pull/88409

1 - https://github.com/kubernetes/kubernetes/compare/8eab3f73163...

2 - https://github.com/kubernetes/kubernetes/pull/85000

3 - https://github.com/kubernetes/kubernetes/compare/375873cb532...

According to the CEO's twitter account [0] they are release better support for dependent PRs this year, track progress of that feature here [1].

The crucial problem with code review on GitHub is that it's 100% dependent on Git to store the history of a PR. This too closely couples what a developer does locally on their machine to the code review process. This in turn means that force pushing drops the history of their "Checks" system, which annotate the PR with CI job an lint/test results. It also means junk commits on PRs make the whole review process more difficult. The app Reviewable [2] works with GitHub and fixes some of these issues if you want to give it a try.

0 - https://twitter.com/natfriedman/status/1170804894241972224

1 - https://github.com/isaacs/github/issues/959

2 - https://reviewable.io

Phabricator works great at the scale you are talking about. With a single monotonic issue number for your company (like Apple's Radar). You have to ditch GitHub totally though, and use Phabricator for code review or the wiki too to get the benefit. Avoid it's repo hosting and CI component (harbormaster). The thing you will miss most is the web based file editing.

My advise would be to deploy: Phabricator (issues, code review, wiki), Buildkite (CI - with your own AWS runners), gitolite (repo hosting).

Pittsburgh does not have the best air quality, but I was surprised to find it listed as better than SF in this article which is overall negative on Pittsburgh [0]. Neither is in a good place, being in the top 15 most worst cities in the country for air quality.

If you want some charts it looks it really does very by section of the city as well [1].

I know people in the area and they responded by getting a Purple Air quality monitor and indoor air purifiers. The simply staying inside when the it was particularly bad day. Which definitely echos China’s big cities, and not in a good way.

0 - https://www.post-gazette.com/local/2019/04/24/Pittsburgh-reg...

1 - https://www.wesa.fm/post/pittsburghs-air-quality-better-past...

Basel’s built in caching requires you build the test (even with cached this takes a bit to love the bites) then you can figure out your already have the result.

You save a large amount of time if you can tell Bazel only to evaluate the part of the tree you know a change effects.

It assumes most do not, but it’s entirely possible for someone to change a common library which makes several down stream changes wait. Even if there are no merge conflicts, if they effect the same tests, changes will have to wait.

Well first step is to optimize, parallelize and refactor so you do not have a single process that takes hours, but many separate ones you can run at once in a cluster.

If those get too expensive to run or you cannot speed them up them you have to do what Chromium does: run them post commit then bisect and revert any changes that break the tests. If things are truly broken you close the tree for a bit while you get the break reverted or fixed.

Also the system that is landing changes tests the optimistically in parallel assuming they will all succeed, so it does land a change only 30 minutes for example.

The queue and test system Uber and Google use for their monorepos essentially do both of those. The restructuring you mention was to use a build system such as Bazel or Buck universally.

1) Two changes which don’t effect intersecting parts of the repo are landed separately. Similar to having infinite separate repos.

2) Only the tests that your code effects are run.

This is all possible because Bazel let’s you look at a commit and determine with certainty which test needs to run a and which targets are effected.

I think you missed a key section in the article where he talks about how miss-steps with a franchise can build, and that Disney made many miss-steps with Star Wars. He wrote a whole article about it [0], which he claims they:

- rushed the films out

- lacked singular vision to keep them consistent

- subverted audience expectations in a bad way, re Luke Skywalker

- retread too much of the same old ground leading to inability to generate momentum (ie. killing off characters in Rogue One).

0 - https://redef.com/original/star-wars-fatigue-is-a-myth-but-d...

Sign us both up :).

In this case they lost there C++ team, so following Conways law they went back to separate code based.

Also the open source C++ ecosystem has advanced quite a bit since when they did there project. You would be able to spend much more time on the problem domain, and zero time on writing a JSON library for example.

Their DocSearch program for open source projects is really great [0]. Check out the Jekyll docs [1] instant results that usually find just what you want. My only complaint is I want a plugin and play solution I can deploy for private internal documentation websites.

0 - https://community.algolia.com/docsearch/

1 - https://jekyllrb.com/docs/

Everything is relative and in the Web usually large is quite a bit smaller than native, so here I assume “large” really meant “bigger than 2D Canvas or SVG could handle”. This example has a few 100k things [0] so you could judge by how well that works.

Not sure about the 64 bit statement, but I assume it means relative to normal 32 GL shader math. Which is definitely not “unparalleled”, but I assume better than the truncated doubles of native JavaScript or the standard shader math.

0 - https://deck.gl/#/examples/core-layers/geojson-layer-paths

If you are looking for something to handle large amounts of data I would take a look at deck.gl [0]. It useful when you have some rich data you want to layer on top of a high quality map, with built in Mapbox GL integration [1].

0 - https://deck.gl

1 - https://deck.gl/#/examples/core-layers/geojson-layer-polygon...

Most impressive demo and marketing video of a product I have seen in a while.

What’s your take on Bazel? Have you considered offering support in Bazel for your package manager?

What made Buck fail at Uber vs Facebook? I thought they successfully used it for larger repos there.

Interviews take 2-3 man days from a company per candidate you end up doing a full onsight interview. That is on the order of $1000’s per interview, and you generally have to do several per role. Then for high demand roles even the best will take several months to ramp up which costs a large fraction, say 25-50% of their total compensation. So replacing a dev can cost you in total $100k+ at least.

That is not really cheap, I am sure technology has helped reduce the amount of man administrative man hours, and helped fill a pipeline, but you still need to train new hires and actually interview them, which is no cheap.

What is disappointing here is that they did not run on Firefox or Chrome. The independent WASM runtimes are not as mature as the browser based ones, so it would be great to see the difference.

Does it have any distributed build or caching support? That is my minimum bar for a C++ build system. ccache and distcc/icecc are too limited, you want something integrated with your build system directly.

Yeah there is MoltenGL which will probably be open sourced eventually. The real future is Vulkan which is moving to replace OpenGL and for the Apple platforms there is MoltenVK [0] (Vulkan re-implemented on top of Apple's new Metal) which is open source. Magnum has an initial Vulkan backend [1], and many other engines have them or are building them as well.

0 - https://github.com/KhronosGroup/MoltenVK

1 - https://blog.magnum.graphics/announcements/2018.10/

The combination of C++ and OpenGL is really the ultimate in portability. A language supported on almost every platform by one if not more implementations (sometimes 3), coupled with probably the most widely supported graphics API. Of course you lose accessibility, and many platform API conveniences, but you get a more stable and performant platform to work with. In fact it's the platform that most web browser themselves are heavily based on. For another example just look at what Epic was able to do with Fortnite, one code base that literally runs everywhere.

Magnum [0] is a favorite of mine for creating portable OpenGL C++ applications. It also has support for compiling to WebAssembly [1] and using WebGL2.

0 - https://magnum.graphics

1 - https://magnum.graphics/showcase/picking/

Do you have any more details on your recommendations?

The common theory is that additional 9s for self driving are not inremental, they require more like exponential effort. Possibly and probably needing new sensors or additional compute power to handle those corner cases. So you cannot linearly extrapolate progress.