Chapter 3: The Bottom of the Bowl

Welcome to Last Minute Lecture.

This free chapter overview is designed to help students review and understand key concepts.

These summaries supplement, not replace, the original textbook and may not be redistributed or resold.

For complete coverage, always consult the official text.

Welcome to a new Deep Dives.

Today we are cracking open Chapter 3 of Why Machines Learn, The Elegant Math Behind Modern AI.

That's right.

This one's called The Bottom of the Bowl.

And it's got some really fascinating insights.

We're looking at how some surprisingly simple math ideas plus a bit of history really set the stage for machine learning as we know it.

Yeah, our mission, as always, is to guide you through the key stuff, the concepts, the people, those aha moments of the chapter we're taking, the source material that one of you shared, and we'll try to turn it into something clear, memorable, and really help you grasp the math and the algorithms that are so foundational to AI.

We're talking adaptive filters, calculus that hopefully you can actually get your head around.

Fingers crossed.

Right.

Navigating these bowl -shaped functions and this amazing algorithm that was literally invented on a blackboard but still drives a ton of tech today.

Okay, let's unpack this then.

We'll see what nuggets we can pull from the bottom of the bowl.

All right, so the story kicks off back in 1959,

autumn, Stanford University campus.

We've got Bernard Widrow, a young academic, maybe late 20s.

Just about 30, yeah.

And this promising grad student, Marcy and Hoff, but everyone called him Ted, walks into his office.

Ted Hoff, right.

Yeah.

And he wasn't just any student.

He was recommended by a senior professor.

Exactly.

This professor knew Widrow was diving into adaptive filters and using calculus and thought Hoff would be a good fit.

And what happened in that office?

Well, it was pretty historic, actually.

I love this scene.

So Widrow's at the blackboard, right?

Chalking up equations, explaining adaptive filters.

Yeah.

And as they're talking, Hoff's jumping in, asking questions, suggesting things.

It stops being just an explanation.

And right there, with the chalk dust flying, they basically invent the least mean squares algorithm, LMS.

Just like that.

Pretty much.

Widrow apparently knew instantly it was, quote, a profound thing.

He always regretted not having a camera right then to snap a picture of that blackboard.

That's amazing.

And Widrow's own journey to that point is kind of cool, too.

Grew up in Connecticut.

His dad ran an ice plant.

Right.

And he used to hang around, watch the plant's electrician, thought that looked like a good job.

But his dad set him straight.

Yeah, his dad was like, no, no, you don't want to be an electrician.

You want to be an electrical engineer,

which turned out to be pretty good advice.

Led him to MIT.

And while he was there, 1956,

he gets invited to this workshop at Dartmouth.

The famous Dartmouth workshop on artificial intelligence, where the term itself was coined by John McCarthy.

And that proposal for the workshop, wow.

McCarthy, Minsky, Rochester,

Shannon, saying they could basically figure out how to simulate any aspect of intelligence with a machine.

Pretty bold for 56.

Incredibly bold.

So Widrow goes, listens to all these giants and comes back to MIT just buzzing, totally fired up.

Ready to build a thinking machine.

For about six months.

Yeah.

He was deep in thought, just pondering thinking itself.

But then reality kind of hit.

The limits of the tech back then.

Exactly.

He figured true AI, the kind they were talking about at Dartmouth, was probably 25 years away.

And for a young academic just starting out, that's a long time.

Way too long, maybe too risky.

So he made a pragmatic choice.

He pivoted, focused on more concrete, solvable problems you could tackle with existing tech.

Problems like adaptive filters.

Which brings us right back to that conversation with Ted Hoff a few years later.

Smart move.

Okay, adaptive filters.

Let's make sure we're all on the same page before we dive into LMS itself.

What is an adaptive filter?

Well, okay, first a basic filter in signal processing, right?

It takes some input signal, does something to it, and gives you an output you want.

Like, maybe you've got some audio with that annoying 60 hertz hum from the power line.

Yeah, that buzzing sound.

Right.

You can build a filter specifically to notch out that frequency because you know exactly what it is.

That's a non -adaptive fixed filter.

But what if the noise isn't constant?

What if it changes or you don't even know what kind of noise it is?

Ah, see that's where you need adaptive filters.

They're designed to figure out the characteristics of the noise, or maybe the signal itself, as they go and adjust what they're doing.

The book uses the dial -up modem example, which is just perfect.

That crazy sequence of sounds when you connect it.

The screeching and beeping.

Woodrow's grandson called it grandpa music apparently.

Ah, love it.

That sound, that whole sequence, was literally the adaptive filters on each end of the phone line doing a handshake.

They were learning about the specific noise and echo happening on that exact phone connection at that exact moment.

Because every phone line is slightly different, right?

The noise is random.

Totally random, yeah.

So they'd send test signals back and forth, figure out, okay, this is the noise profile, and then the filters could effectively subtract that noise out.

Creating a clean channel to send the actual data, the zeros and ones.

Wow.

So they adapted to that specific call.

Precisely.

Learning on the fly.

So how does that learning actually work?

Mechanically.

Okay, think of a simple loop.

You've got your input signal coming in, let's call it Xn.

The filter does its thing and produces an output, In.

But critically, there's also this thing called the desired signal, Don.

The signal you wish you had.

Kind of, yeah.

The filter compares its output, Y and N, to this desired signal, Don, and calculates the difference.

That's the error, N.

So error, desired output.

Okay, so it sees how far off it was.

Exactly.

And then this is the key, that error signal, N, is fed back into the filter itself.

The filter uses that error information to tweak its own internal settings, its parameters, or REITs, as we usually call them.

So it learns from its mistakes, basically.

That's a great way to put it.

This constant loop of output, baggy, compare error, calculate error, adjust parameters.

That's the adaptive part.

It's how it gets better over time.

Hold on, though.

If you already know the desired signal, Don, why bother with the filter?

Couldn't you just use Don?

Ugh.

Good question.

That's a really common point of confusion.

The thing is, you don't know the desired signal for the actual real -world data you want to process later.

But during a training phase, like that modem handshake,

the devices send no known signals, signals where they do know what the clean output should be.

So the filter gets the noisy input, which is that known signal plus all the line noise.

It produces its own output, compares it to the known clean version, the desired signal for training, sees the error, and learns, ah, this is what the noise does on this line.

So it learns the noise characteristics during training using known signals.

So that later, when the actual unknown data comes through, it knows how to filter out that specific noise profile it just learned.

Makes sense.

Got it.

Training first, then filtering the real stuff.

Okay, so the big goal then is to adjust those filter parameters, the weights, to make that error signal, and as tiny as possible over time.

Exactly.

Minimize the error.

And this is where the math comes in, defining what small error means.

You can't just average the raw errors.

Right, because if you're off by plus one half the time, and I missed one the other half, the average error is zero, but you're actually wrong every single time.

Precisely.

So averaging doesn't work.

You could average the absolute value of the error that's called mean absolute error, or MAE, that avoids the canceling out problem.

Okay, so just take the size of the error, ignore the sign.

Yeah.

But the approach Widrow and Hoff used, and the one that's really foundational, is mean squared error,

MSE.

So you square the error term on squared.

Exactly.

Squaring it obviously makes negative errors positive, so that solves the cancellation issue, but it has some other really key advantages.

Like what?

Well, statistically it behaves nicely, but the really crucial thing, especially for the algorithms we use to train these filters and neurons, is that the MSE function is differentiable everywhere.

Differentiable everywhere.

Okay, unpack that a bit.

Why is that so important?

It means the function describing the error is smooth.

Think of a smooth curve versus one with sharp corners.

You can calculate the slope, the rate of change, at absolutely any point on a smooth differentiable curve.

Whereas MAE, the absolute value one, would have a sharp point at zero error, right, like a V shape.

The slope isn't defined right at the bottom.

Spot on.

MSE gives you a nice smooth U shape, or a bowl shape in higher dimensions.

And having a defined slope everywhere is absolutely essential if you want to use calculus -based methods to find the minimum point.

Which we do.

Okay, smooth slope everywhere, got it.

And squaring the error.

Doesn't that also make bigger errors seem much worse?

Like, an error of 3 becomes 9, but an error of 5 becomes 25.

It absolutely does.

It punishes extreme outliers much more heavily than MAE does.

A big error contributes massively to the total squared error, so the learning algorithm gets a really strong signal to fix those big mistakes first.

So formally the goal is to minimize J, which is the expected value of the average of that squared error.

J in 2.

That's the mathematical target.

Minimize J.

And you said minimizing J is like finding the bottom of a bowl.

Exactly right.

That function J, the expected squared error, plotted against the filter weights.

It mathematically forms a convex shape.

If you only had one weight to adjust, the graph of error versus weight would look like a simple parabola.

Y equals X squared.

Like a 2D bowl.

And with more weights.

It becomes a multi -dimensional bowl.

Like with two weights you could visualize it as Z equals X squared plus Y squared, which is a 3D bowl shape.

With thousands of weights, it's a bowl in thousands of dimensions, which we can't visualize, but the math still works the same way.

OK, so finding the best weights, the ones that give the least error, is literally finding the coordinates of the lowest point at the very bottom of this N -dimensional bowl.

That's it, exactly.

And what's true about the bottom of any bowl, mathematically speaking?

At flat, the slope is zero.

Precisely.

At the minimum point, the slope, or what we call the gradient in multiple dimensions, is zero.

So the problem becomes, how do we find that point where the gradient is zero?

And the method is called the gradient descent,

or steepest descent.

Yeah, gradient descent is the usual term.

The source material has this great analogy.

Imagine you're trying to get down a terraced hillside, maybe like rice paddies.

You're up on the hill.

It's maybe getting dark.

You want to get down to the village in the valley, which is the lowest point.

You can only really see the terraces right around you.

So what do you do?

Well, from where you're standing, you look around, figure out which direction goes downhill most steeply to the next terrace below you.

And you take a step in that direction.

Right.

Then you stop, look around again from your new spot, find the new steepest way down, and take another step.

You keep repeating that.

You might zigzag a bit, but you're always heading generally downwards.

Exactly.

You're intuitively following the path of steepest descent.

You're letting the local slope, the local gradient, guide your steps towards the bottom.

OK, let's formalize that slope idea a bit using calculus, maybe back with the simple y x squared ball.

Good idea.

So plot y equals x squared.

Simple parabola.

Pick any point on that curve.

Now imagine drawing a straight line that just barely touches the curve at that single point.

That's called a tangent line.

Right.

It just kisses the curve.

And the slope of that straight line tells you how steep the curve itself is right at that exact point.

Exactly.

And slope is just rise over run, right?

A small change in y divided by a small change in x.

Now differential calculus is the tool that lets us find the exact slope of the curve itself, not just an approximating tangent line.

It does this by looking at what happens to that ratio of x as the step x gets incredibly infinitesimally small, like approaches zero.

And that limiting value is the derivative written dx.

That's it.

And for our simple y x squared, the calculus rule tells us the derivative dx is just 2x.

Okay.

And again, we don't need to worry about how to calculate 2x, just what it means.

Exactly.

Just know that the derivative function, 2x in this case, gives you the slope of the original function, x squared, at any value of x.

So if x is 2, the slope is 2 times 2, which is 4.

Steep.

If x is 1, the slope is 2 times 1, which is 2.

Less steep.

Right.

If x is 0 .5, the slope is 1.

And crucially, if x is 0, right at the very bottom of the bowl.

The slope is 2 times 0, which is 0.

Point flat.

Bingo.

The slope is 0 at the minimum.

So gradient descent in this simple 1D case works like this.

Start somewhere, say at x with 3.

Calculate the slope there.

The derivative 2x is 23 equals 6.

The slope is positive, meaning the function goes uphill to the right.

So to go downhill towards the minimum at x low, you need to move the opposite direction of the slope.

You need to move left, decrease x.

Exactly.

You take a step proportional to the negative of the gradient.

The update rule is x new,

sold to uro, slope at sold.

Where, Ika, is that step size?

Like how big a step you take.

Right.

The learning rate or step size.

It needs to be small enough that you don't just leap over the minimum entirely.

If the slope is 6 and e is, say, 0 .1, your step is point y, 6, so it's 0 .6.

So you move from x3 to x will be 0 .6 equals 2 .4.

And then you recalculate the slope at 2 .4, take another small step left and repeat.

And notice something cool.

Even if a stays the same, as you get closer to the minimum x0, the slope 2x gets smaller.

Ah, right.

So the steps automatically get smaller the closer you get to the bottom.

Even with a fixie arc.

Exactly.

You naturally slow down as you approach the target.

Okay.

That makes sense for one dimension, one weight.

But our filter, our neuron, could have dozens, hundreds, thousands of weights.

How do you descend the bowl in, like, a thousand dimensions?

Great question.

Now we need multivariable calculus.

Instead of just y, fx, we have functions like our 3D bowl, zfxy equals by 2 plus y2.

We want to find the xy pair that minimizes z.

So we need slopes with respect to both x and y.

Right.

And that's where partial derivatives come in.

You see that curly earth symbol like x.

Looks like NCD.

It basically means the derivative of z with respect to x while treating all other variables, in this case just y, as if they were constants, you're isolating the slope purely in the x direction.

Okay.

So is x is the slope parallel to the x -axis?

Exactly.

And or is a is the slope parallel to the x -axis holding x constant.

For our xy equals by 2 plus y2 example, the math is simple.

x equals 2x and x equals 2y.

So we have the slope in the x direction, 2x, and the slope in the y direction, 2y.

How do we combine those to find the overall steepest direction down the bowl?

This is the really crucial concept.

You combine all the partial derivatives into a vector called the gradient.

For xxy, the gradient is the vector x.

So for z equals by 2 plus y2, the gradient is just the vector 2x, 2y.

Exactly.

Let's say you're standing on the bowl surface at the point where x3 and y4.

The gradient vector there would be 23, 24 equals 6, 8.

Okay, so 6, 8 is a vector.

What does it represent?

That vector 6, 8 points in the direction of the steepest ascent from the point 3, 4 on the bowl surface.

It points directly uphill.

Ah, so just like in 1D where the positive slope pointed uphill, the gradient vector points uphill.

To go downhill towards the minimum.

You need to move in the direction of the negative gradient.

So you'd move in the direction opposite to 6, 8, which is negative 6, and it gets 8.

So you update both x and y.

The update rule becomes x new equals old es, and e new equals yold as es.

You calculate all the partial derivatives,

assemble the gradient vector, and subtract a small fraction of that vector from your current position vector xy.

And this works even if you have, say, a function fw1, w2, w1000 that you can't possibly visualize.

Absolutely.

As long as the function is differentiable, you can calculate the partial derivative with respect to each of the 1 ,000 variables.

That gives you a 1 ,000 dimensional gradient vector.

That vector points uphill, so you take a small step in the direction of the negative gradient vector to move towards a minimum.

Wow.

OK, so calculus gives you the direction even in crazy high dimensions.

That's the power of it.

Gradient descent gives you a systematic way to navigate down the error bowl no matter how many dimensions or weights you have.

All right, so connecting this back to the adaptive filter.

The goal is to minimize j, the expected squared error, which is a multi -dimensional bowl function of the weights.

The obvious approach seems to be calculate the gradient of j with respect to all the weights and use gradient descent.

That's the standard textbook method of steepest descent, yes.

But applying it directly to minimize j into 2 had some practical hurdles back in 1959.

Such as?

Well, first, to calculate the true gradient of the expected error, you ideally need to know things about the statistical nature of your input signals and the noise things like correlations.

There were mathematical solutions like the Wienerhoff equations that use this, but they required knowing those statistics upfront, which you often don't.

OK, so you might not have the needed info.

What else?

Calculating the expected error implies you need to average the squared error over many, many data samples to get a stable estimate of j and its gradient.

That could be computationally heavy, requiring lots of data and processing.

Right, and maybe the noise is changing anyway, so a long term average isn't even right.

That too, plus just writing down the calculus expressions for the partial derivatives of j, the expected value, with respect to every single weight.

J and Gv is zero, J is your J -O.

That could get mathematically very complicated, especially if you had a lot of weights.

And that set of problems is exactly what Wienerhoff were grappling with at the blackboard, wasn't it?

They needed something simpler than calculating the true gradient of the expected error.

Precisely.

They were looking for a shortcut, an easier way to estimate the direction down the bowl.

And their big idea, the LMS breakthrough,

was, well, it was both incredibly simple and slightly cheeky, mathematically speaking.

Instead of trying to calculate the gradient of the average squared error over many samples, they thought, what if we just estimate the gradient using the squared error from one single data sample at a time?

Just one sample.

But wouldn't that be wildly inaccurate?

Oh, yeah.

It's an extremely approximate estimate, as the source says.

Very noisy.

The gradient based on one sample might point kind of sort of towards the minimum, but it could easily be pointing a bit off, maybe even slightly uphill in some directions momentarily.

This sounds like the drunkard's walk analogy we mentioned earlier.

Instead of striding purposefully downhill, you're staggering around based on very limited, noisy information.

That's a perfect analogy.

Woodrow himself apparently felt they were sort of swallowing hard and telling a mathematical lie by treating the instantaneous squared error, N2 for one sample, as if it was the mean squared error, J.

But the payoff was simplicity.

Huge simplicity.

Because when they worked through the math using the single sample error, the update rule for the weights became incredibly straightforward algebra.

No complex derivatives of J needed.

What did the rule look like?

It boiled down to this.

Your nu plus 2 me x.

OK, let's break that down.

Me nu is the updated weight vector.

Wold is the current one.

Me is.

Nu is the step size, like eta before, just a small constant controlling how big a step you take, usually called the learning rate here.

OK.

Epsilon is.

That's the error calculated for that single data sample.

Ae is dnyn, where or n is the filter's output for input xn.

And dn is the desired output for that specific sample.

Me x is.

That's the input vector for that same single data sample, xn.

That's it.

Just multiply the error by the input, scale it by 2, and add it to the old weights.

That's the whole update.

That's the core of the LMS algorithm right there.

Simple arithmetic.

They completely sidestep the need to calculate the complicated partial derivatives of the true mean squared error function, j.

This rule approximates taking a step in the negative gradient direction using only the immediate error and input.

But how can such a noisy approximate step possibly lead you to the minimum?

That was the counterintuitive leap.

It felt wrong, maybe unstable.

But Widrow apparently had this insight later, sketching on the back of a plane ticket or something.

He realized that even though each individual step is noisy and approximate, if you take many, many small steps, the noise tends to average out over time.

The general downhill trend dominates, and the process still converges, staggering its way towards the bottom of the bowl.

Wow.

So the noise cancels out in the long run if the steps are small enough.

Kind of, yeah.

It's an emergent property of the process.

And this wonderfully simple yet effective algorithm got named the least mean squares algorithm, LMS.

Apparently, Widrow credited one of his students for the name.

And this LMS algorithm, it wasn't just for cleaning up phone line noise and adaptive filters, right?

It could be used for training artificial neurons too.

Absolutely.

Because the basic structure of an adaptive linear filter and a simple artificial neuron, like the ones being explored then, are mathematically almost identical.

How so?

Well, a neuron takes multiple inputs, right?

By 1, by 2, by 3, each input connection has a weight, w1, w2, w3.

The neuron calculates a weighted sum of its inputs.

Output y equals w1 by 1 plus w2 by 2 plus w3 by 3 plus maybe a bias term, w0.

Exactly, which you can write compactly using vectors as y equals 0 or might x, or often y equals wtx, w transpose times x, where the x vector usually includes a constant 1 input, so w0, x is the bias.

That structure is an adaptive filter.

OK, I see the parallel.

So you can train this neuron using LMS.

Yes.

You give the neuron an input pattern x.

It calculates its output y.

You compare that to the desired output for that pattern.

Calculate the error a dy.

And then update all the weights using that simple LMS rule,

w nu cus, w plus 2.

Precisely.

You repeat this process over and over with different input patterns and their corresponding desired outputs.

The source gives the example of teaching a neuron to tell apart the letters t and j.

Yeah, on a simple four by four pixel grid.

So each letter is represented by a 16 element input vector.

Each pixel is either on or off, 1 or 0, or maybe 1 or negative 1.

You want the neuron to output, say, plus 1 if it sees a t and next 1 if it sees a j.

Right.

So you show it a t pattern, a 16 element vector.

It computes its output y.

If y isn't plus 1, you calculate the error, equal plus 1y, and use LMS to nudge the 16 weights.

Then you show it a j, calculate the error, equal 1y if needed, and nudge the weights again.

Keep doing that.

And eventually the weights adjust so the neuron correctly classifies t's and j's.

If the patterns are linearly separable, yes.

And the actual hardware Widrow and Hoff built to implement this single neuron trained with LMS was called Adeline.

Adeline.

Adaptive linear neuron.

Makes sense.

And what Adeline essentially does, geometrically, is find a dividing line, or more accurately, a hyperplane in higher dimensions that separates the input patterns.

In the 16 pixel case, it finds a 15 dimensional plane that puts all the t patterns on one side and all the j patterns on the other.

Why 4 by 4 pixels?

Seems kind of small.

They apparently chose it because it was just complex enough to have distinct patterns like t and j, but simple enough that they could literally build the Adeline hardware with adjustable knobs for each weight and tune it by hand in the early days.

Wow, hands on machine learning.

Now how did this compare to Rosenblatt's Perceptron, which we've talked about before.

It sounds similar.

It's very similar in goal.

Both Adeline and the Perceptron were single neurons trying to find a linear separation between classes.

The key difference was the learning algorithm.

Rosenblatt's Perceptron used a different rule to update its weights, whereas Adeline used Woodrow and Hoff's LMS algorithm, derived from that approximate gradient descent idea.

So LMS is a big deal.

What happened next for the inventors in the algorithm?

Well, Ted Hoff, after finishing his THD with Woodrow, famously went to Intel.

And he played a absolutely central role in developing the world's first microprocessor, the Intel 4004.

Talk about impact.

No kidding, and Woodrow.

Woodrow stayed in academia at Stanford and continued working extensively on adaptive systems.

He applied LMS all over the place, adaptive filters for noise cancellation in airplane cockpits, adaptive antennas for radar and communications,

echo cancellation on phone lines, really foundational work.

He also started building networks of Adelines called Madeline for many Adeline.

Trying to tackle more complex problems.

Exactly.

Though training these larger multi -layer networks effectively was still a major challenge back then.

They didn't quite have all the pieces yet, like efficient back propagation.

There's a funny story of the source about Madeline on TV in 1963.

Oh yeah, the show Science in Action.

They featured Madeline doing a classic demo, balancing a broomstick upright.

Apparently the host asked Woodrow why he gave it a feminine name, Adeline.

Oh boy, how did Woodrow respond?

Just totally deadpan, ignoring the gender angle completely.

He just said, well, this happens to spell adaptive linear neuron, and that's it.

Just focused on the tech.

Classic engineer answer, maybe.

Definitely highlights the times.

So looking back, how significant was LMS?

Woodrow himself put it very strongly later in his career.

He said, quote, the LMS algorithm is the foundation of back prop, and back prop is the foundation of AI.

Wow, that's a direct line from LMS to modern deep learning.

It really is.

Back propagation, the algorithm used to train almost all the huge neural networks today, is essentially a clever way of applying the core gradient descent idea akin to LMS across multiple layers of neurons.

So while Rosenblatt's Perceptron was also crucial foundational work, LMS has this very direct algorithmic lineage to today's AI.

Though the source also notes, importantly, that this wasn't the only game in town.

Other approaches using probability and statistics were also being developed, right?

Absolutely.

And those statistical methods became quite dominant at times, especially during periods when neural network research hit obstacles, like after Minsky and Papert published their critique of single layer perceptrons.

It wasn't a straight line, but the seeds planted by LMS and Adeline were definitely growing.

Okay, so let's wrap this up.

We started with Woodrow and Hoff at a Stanford Blackboard in 1959, chalking up some math.

And ended up inventing this incredibly simple, but powerful algorithm, LMS, that really bridged adaptive filters, the concept of gradient descent and early artificial neurons like Adeline.

We've seen how the goal is minimizing error,

often mean squared error, because it's smooth and differentiable everywhere.

Right, and how we can think of that error as a bowl.

And finding the best solution means finding the bottom of that bowl using gradient descent, taking steps downhill, using calculus, specifically derivatives and partial derivatives to find the gradient.

But the full gradient calculation was tricky, so LMS used a brilliant approximation.

The drunkard's walk, using the error from just one sample at a time to estimate the downhill direction.

Noisy, yes, but simple.

And crucially, it worked over time with small steps.

Leading to a simple algebraic update rule,

realized in hardware as Adeline, capable of learning tasks like pattern recognition.

And we saw its legacy, both through Ted Hoff's work on the microprocessor and Woodrow's direct claim that LMS is the foundation of back propagation, the engine driving so much of modern AI.

We've definitely extracted the core ideas from this chapter.

It really is amazing how a clever approximation, the sort of mathematical lie, that felt shaky at first, could turn out to be so incredibly impactful and foundational.

It makes you think, doesn't it?

If taking many small, noisy approximate steps in roughly the right direction can eventually get you to the bottom of the bowl, where else might that principle apply?

Where else could good enough, consistently applied, be the secret to success, even if the path isn't perfectly straight?

Something to definitely ponder.

This has been another deep dive.