Glad you liked it, I'm personally working on switching to a more pure functional style myself and this video helped convince me a former die hard OOP guy to consider such a change.

Yeah, about halfway through I realized he was complaining about object oriented architectures, particularly very formal architectures that attempt to enforce rules about how object interact through a graph, a graph which actually does not correctly describe the architecture.

Towards the end the author is critical of this type of programming:

doSomething();
doAnotherThing();
doAThirdThing();
doTheFinalThing();

He argues that he would rather do this:

// do something:
for () {...}
// do another thing:
for () {...}
// do a third thing:
if () {...}
// do the final thing:
switch () {...}

which strikes me as extraordinarily foolish. The purpose of breaking up 100+ lines of procedural code into single-use functions is that it allows you to make modifications to the code on two levels: outside of the abstraction (in the top level function) and inside the abstraction (each of the inner functions). So you could change this:

taskApple();
taskBanana();
taskCherry();

into this:

taskCherry();
taskApple();
// taskBanana();

... or if you want to get really fancy, you could handle the functions themselves as references and produce dynamic code:

func plan[3] = (taskApple, taskBanana, taskCherry);
foreach (plan as step) {
  step();
}

which is of course something that no one ever does, at least in open source projects, because it requires a certain level of skill... and doesn't play well with your IDE.