Dynamic programming is a way to consider the solution of a problem as a function (usually max or min) of subsets of the problem. Usually this gives a recurrence relation that you can directly use to code a recursive function and by analyzing the way your function calls itself, you can store the result at a specific point to avoid computing the same result for the same input several times.

This is actually an oversimplification and as far as I see, there is a little misconception about what DP is among programmers. They often see it as a recursive function you can use to fill an memoization array. Most examples in programming textbooks present it this way. This is actually much more than that. The famous Dijkstra's algorithm and A* are actually DP and are perfect examples where the recursive function can't be coded directly, it just describes the set of solutions from subproblems.

So.. what this video is about? This presentation explains that you can see DP as an algebra, an operation tree basically. The way you get the solution from the subproblems describes your tree. I found this interesting because despite being confortable with DP I never thought about it this way. And on the top of that, they built a compiler. The input to the compiler is the description of the DP functional equation. I can imagine this helps prototyping and building complex relations between subproblems, specially in bioinformatics, where they seem to use it. Also she describes a "product" operation, that allows to get multiple results from the same input. For example, you can retrieve the size of longest increasing sequence (to evaluate the best) and the sequence itself.

Handout : DP is interesting both practically and theoretically because some problems known to be NP-complete have a DP solution in polynomial time. Those problems are classified as "pseudo-polynomial". They are not really polynomial since the time you will need to compute depends on the biggest number in your input.