Comments by "xybersurfer" (@xybersurfer) on "You Need Kubernetes?" video.

it depends. it's probably the side effects that make debugging recursion hard. i think that recursion which only builds a return value (an expression) requires less debugging, because it's easier to reason about
3
@AG-ur1lj "Changing some value until some condition is met" changing stuff is pretty much a side effect, so yeah that's trickier to reason about but it's not because of recursion. you can make recursion look just like a loop if you pass on to the next call, what you would pass on to the next loop iteration. so it's not necessarily harder to reason about. but i get that syntax wise it would require creating a whole new function (i know that feeling in most languages). in functional programming languages you get away with this, because the syntax for creating a recursive function is about as heavy as writing a loop (only slightly heavier). loops are only a subset of what you can do with recursion. typically it's problems that work with trees that are easier with recursion. but lots of things are trees. like finding an employee's highest level manager by going through the manager's manager etc, or problems like adding 1 to every node in a tree. XML is also an example of a tree. but even in functional programming people try avoid dropping to recursion: most things, can be done with just a function call, because function definitions are values an so can be passed in and returned as values like in JavaScript (a.k.a. Higher Order functions). but also because a function call with missing parameters, results in a new function that expects the missing parameters (a.k.a. Lambda Calculus). so you get a lot of one liners like in this video. side effects (including global mutable state) are typically avoided in functional programming. you still need them to change the outside world, but they are typically confined to only a few parts of your program, and make the rest easier to reason about. bugs can still occur of course in functional programming, but a strict type system and the increased simplicity of the code makes it less likely (the whole program is basically 1 expression instead a statement like in most other Imperative programming languages). TLDR: basically it helps if the language is flexible enough to not have to write out recursion, every time you need it.
1
@AG-ur1lj "Changing some value until some condition is met" changing stuff is pretty much a side effect, so yeah that's trickier to reason about but it's not because of recursion. you can make recursion look just like a loop if you pass on to the next call, what you would pass on to the next loop iteration. so it's not necessarily harder to reason about. but i get that syntax wise it would require creating a whole new function (i know that feeling in most languages). in functional programming languages you get away with this, because the syntax for creating a recursive function is about as heavy as writing a loop (only slightly heavier). loops are only a subset of what you can do with recursion. typically it's problems that work with trees that are easier with recursion. but lots of things are trees. like finding an employee's highest level manager by going through the manager's manager etc, or problems like adding 1 to every node in a tree. XML is also an example of a tree. but even in functional programming people try avoid dropping to recursion: most things, can be done with just a function call, because function definitions are values an so can be passed in and returned as values like in JavaScript (aka Higher Order functions). but also because a function call with missing parameters, results in a new function that expects the missing parameters (aka Lambda Calculus). so you get a lot of one liners like in this video. side effects (including global mutable state) are typically avoided in functional programming. you still need them to change the outside world, but they are typically confined to only a few parts of your program, and make the rest easier to reason about. bugs can still occur of course in functional programming, but a strict type system and the increased simplicity of the code makes it less likely (the whole program is basically 1 expression instead a statement like in most other Imperative programming languages). TLDR: basically it helps if the language is flexible enough to not have to write out recursion, every time you need it.
1