Indeed it was. Exactly and precisely this.

[...] where you can't get anything done because there's a meeting soon. [...]

WTF.

What kind of undisciplined clowns are you employing there?

It's no different at all than lunchtime coming up. You work until it's time to take a break. A meeting is a break from work. Are you not able to get anything done in the three hours before lunch?

For fuck's sake! There are **no goddamn gyroscopes** in mobile devices. What's used are accelerometers, which are non-spinning. Gyroscopes spin.

Starting on #1 when the neighborhood pool opens up.

Book pool? Or swimming pool?

Look it up. It's been widely known (and reported here 3 years ago) that Apple was working on a new filesystem.

Well, since APFS has been in development for only a year or so

Uh, actually, AFPS has been in development for *several years*.

But the chance of losing your data is triple.

I was about to say, "That's not how probability works!" but it turns out that you are actually correct.

If each site has a 1% chance of being seized, then it means each site has a 99% chance of not being seized. Multiplying these probabilities together gives

The key here is that 1 – (1 – x)^3 is very close to 3x for small x.

"I am the one who clocks."

**Nope. FAIL. Not correct.**

Your solution only works if all leaf nodes have the same depth -- which is exceedingly unlikely.

You want:

`if (abs(left - right) > 1) throw exception;`

**Nope. FAIL!**

Your implementation only works for trees where all leaf nodes are at the same depth.

A binary tree is still balanced if one branch is depth *n* depth and the other branch is depth *n+1*.

So you have to compare like this:

`(abs(depthLeft - depthRight) <= 1)) {`

$35/month for anything with commercials is too much. Way too much.

...for something that was 100% twenty years ago.

*Every* embedded software design standard expressly forbids recursion

My embedded software design standard doesn't.

Thank you. GP is a fucking moron. As you go on to point out, many algorithms have natural limits on the recursion depth. A recursive mergesort, for example, can never go deeper than ceil(log2(n)) calls, where n is the number of elements to sort. If you have room on your stack for 30 calls deep, you can sort a list of a billion items. People who say recursion has no place in embedded software design either haven't thought their arguments through very carefully, or are very inexperienced programmers, or are just plain dumb.

I have a 2010-ear Apple that has 16 Mbytes of RAM.

You have an Apple with 2,010 ears?

sku that brings in less than **$50MM a year**

No product anywhere in the world brings in $50 trillion per year.

(1 million million = 1 trillion)

The reason computer chips are so small is computers don't eat much.