“Dynamic programming” is not referring to “computer programming”

https://www.vidarholen.net/contents/blog/?p=1172

by r4um • 1 year ago

422 211 1 year ago

smokel3• 1 year ago

Also, the term "dynamic programming" has slightly different meanings in the context of leetcode problems and in the context of reinforcement learning.

In the first it's for optimizing a relatively small deterministic system, in the latter it is for optimizing a stochastic process.

Pretty confusing.

jeltz2• 1 year ago

The idea is way older than both leetcode and reinforcement learning and is used everywhere (for example when planning SQL queries). If reinforcement learning invented a new way to use the word then that is all their fault because leetcode is true to the original meaning.

smokel3• 1 year ago

Both meanings derive from Bellman. "Reinforcement learning" did not invent a new way, and the field of reinforcement learning predates leetcode by a large margin.

mrbluecoat• 1 year ago

Reminds me of "Extreme Programming" [0], which is referring to project programming rather than computer programming.

[0] https://en.m.wikipedia.org/wiki/Extreme_programming

rzzzt• 1 year ago

Compare with "Extreme Ironing": https://www.ebaumsworld.com/pictures/23-insane-examples-of-e...

userbinator• 1 year ago

If it weren't for the fact that the page is 10 years old, I would've thought those were AI-generated images at first glance.

stephenlf• 1 year ago

I love that origin story.

gsf_emergency_2• 1 year ago

It seems dynamic programming (some predetermined sequence of steps) as envisioned by Bellman is strictly less dynamic than ordinary programming today, hence the confusion?

Elevating "memoization+recursion" to "dynamic programming" seems like a development that Bellman didn't anticipate

https://cs.stackexchange.com/questions/99513/dynamic-program...

There is another mid century term which is oddly specific for something oddly general (or the other way?) "Operations Research"

Guess Bellman should have called it "Reactive Optimization", then we would have the totally appropriate "Recursive Memoization" or "Memoized Recursion"

LPisGood2• 1 year ago

You should think of the “programming” in dynamic programming the same way you think of in linear programming, integer programming, and constraint programming.

Indeed even in layman’s terms, thinking of it as in television programming is more accurate than thinking it is related to computer programming (as is mentioned in TFA)

TeMPOraL2• 1 year ago

linear programming, integer programming, and constraint programming

Can't think of a universe in which you'd learn about these things before learning "computer programming".

agumonkey2• 1 year ago

I always find funny how many meanings "programming" has.

mort964• 1 year ago

I think of "programming" in "dynamic programming" the exact same way I think of it in "linear programming", "integer programming" and "constraint programming": it's probably some kind of software development that some computer scientists came up once and that I don't need to think about, because my normal programming has worked out pretty well so far

(Except, well, I guess I understand what "dynamic programming" is more than I understand what the other forms of programming you mention is; "dynamic programming" is solving certain classes of recursive problems by using arrays, sometimes nested arrays, to avoid re-computation, and somehow that's supposed to be more "dynamic" than not doing that)

Certhas6• 1 year ago

The sequence of steps is the result of dynamic programming. Not every sequence of steps is a dynamic programme. And (what I would argue are) the core results are fairly mathematical, memoization and recursion don't feature, but partial differential equations do. Check out the Hamilton Jacobi Bellman equation to get a flavour.

thaumasiotes2• 1 year ago

Elevating "memoization+recursion" to "dynamic programming" seems like a development that Bellman didn't anticipate

Well, it also isn't a development that happened. You can (always) implement dynamic programming as recursion with memoization. But an algorithm that is recursive and memoized isn't necessarily an example of dynamic programming.

The point of dynamic programming is that you set up the recursion so that recursive calls do hit the cache, not that there is a cache and if you're lucky they might hit it.

zelphirkalt5• 1 year ago

Usually though when using recursion to solve an algorithmic problem, people memoize results they know will be needed later again. So in most cases that should automatically become the same thing in practice.

npsomaratna5• 1 year ago

Sri Lankan here. I used to compete in the IOI (International Olympiad in Informatics), back in the '90s.

I aced the competition in Sri Lanka, but I failed to win a medal the first time I competed internationally. I solved several problems with recursion, but these failed to complete within the strict time limits allowed.

One of the contestants from another country told me: "You needed dynamic programming to solve problems 1 and 5." I then spent the next year trying to figure out what dynamic programming was. The folks over here weren't familiar with the term. In fact, I was often asked "did you mean dynamic memory allocation?"

After a while, I managed to find a book that talked about dynamic programming, and I was like "Oh, it's recursion + storing results" and "Ah, you can also do this iteratively in certain circumstances"

Bottom line, armed with this new knowledge, I ended up winning a gold medal at IOI 2001. Fun times.

zekica• 1 year ago

I had the same experience: no one knew of my mentors what "dynamic programming" was and our country-level competition (that had created problems inspired by IOI) required dynamic programming for 2 out of 5 problems. And of course I failed the first time (2004). Then I learned what it was about and aced the next time (2005).

snthpy2• 1 year ago

I was part of the hosting team at IOI 1997 in Cape Town and had similar conversations with the participants that you described and also learned about Dynamic Programming there. Your description of it as "recursion + storing results which you can sometimes do iteratively" is the best summary. Good example is iterative Fibonacci algorithm.

Another fun anecdote from that time is that we had to take special precautions with the scoring program which connected to the participants machine over the serial port. The previous year one participant had hacked the serial port interface to manipulate the results. :-)

npsomaratna5• 1 year ago

Nice! I guess you must know Bruce Merry. Once, when practicing, I kept on hitting my head on a problem. On the spur of the moment, I decided to fire off an email to Bruce (given his track record, I was like "if anyone can figure this out, he can"). I was shocked (and very pleased) to get a reply a few days later outlining his thought process and how he went around solving the problem.

I used to know the ZA team leaders as well (after competing, I was a team leader for several more years).

BobbyTables2• 1 year ago

The term always made me insufficient as I always assumed it meant much more and I just didn’t understand how.

In the Fibonacci example, it seems more like common sense to avoid recomputing expensive things. Instead we should give derogatory names to the inefficient implementations, not an opaque name to the only sane implementation.

krackers• 1 year ago

Has there been an "arms race" of sorts with programming contests, as knowledge percolates and harder categories of problems need to be chosen? Since these days dynamic programming is basically table stakes for ICPC-type problems.

paldepind2• 1 year ago

Yes, absolutely. I did programming competitions back in high-school (around 10 years ago) and common folklore was that back in the days knowing dynamic programming could win you a medal, but today it was just basic expected knowledge.

kindkang20242• 1 year ago

Loved your wonderful story—here’s my plain one.

I came to programming after I graduated, and I never really understood Dynamic Programming until I watched one of Stanford’s algorithm courses (kudos to MOOCs).

But honestly, I’ve never done anything truly useful with it—except that it gave me a new perspective on ordinary things. For example, I found that there may be great wisdom in the Taiji symbol (image here: https://commons.wikimedia.org/wiki/File:Yin_yang.svg). We can divide the current problem and conquer it at the lower levels (like one of the dots in yin and yang). And of course, those lower levels still contain their own divisions and computations—until there are none left.

At the same time, we can also start from the base and build upward (bottom-up), moving toward higher-level computations—where possible divisions await, until eventually one big unified answer emerges.

Pretty useless for its actual usage here, isn’t it? ^^

matsemann2• 1 year ago

Dynamic programming is for me one of the things that really scratched an itch and made me start liking programming. The invariant/inductions of composing smaller things into a bigger solution is so elegant.

I do feel dynamic programming influences how I solve problems in my work. How, if you compose the problem correctly, it can never reach a fault state in a sense. Not sure if I'm able to explain what I mean, but for instance I recently refactored an old application at work that had lots of bugs, was hard to grasp and had loads of error checking code / asserts. However, by composing it a bit differently, modeling it properly, I could remove swaths of code / defensive programming because I with the help of the compilator now can guarantee the base cases holds etc.

Edit: one a bit contrived example might be an Order. If you have one big model tracking the lifetime of an order, some fields will have to be null until they have a value. For instance a field sent_at_time. Then you have a function that generates an email to the customers, which uses that field. How do you handle that field possibly being null? Do you say "I know that at this point in time, this field is always set since the email is generated after sending" and tell the compiler to ignore the possibly null value? Or do you handle the possible null with some error handling / fallback value, that in practice is dead and cluttered code and will just confuse a future developer seeing it with questions like "how can this happen"?

With the lessons from dynamic programming in mind, I think both are bad solutions. You want to be able to go from state n to n+1 with safety (order purchased, ordered sent, email sent). So model it in a way that the email sending code only ever can get an order in the correct previous state as input. Then if the assumption were to break in the future (maybe some orders are digital and the email is sent without the order having been physically sent), that breaking assumption will immediately be obvious in how the state/models are composed, and not in runtime when either the not-null-assert fails or the emails start having the fallback value.

nicknash• 1 year ago

I wonder if you can clear up a memory of mine from IOI 2001. The first day results were delayed, and I seem to remember this is because a contestant encoded the search in one of the problems into a compile time c++ template metaprogram. On the second day, there was then also a compile time limit for solutions, from what I remember. Do you remember any more details of this?

xandrius• 1 year ago

That sounds very smart :D

npsomaratna5• 1 year ago

No, sorry. I vaguely remember compile time limits, but they were high enough (30 seconds, I think?) that I didn't bother worrying about them (at least, that's my memory).

hnfong4• 1 year ago

I think I know the culprit. The story I was told is that the person precomputed some of the results and submitted a huge source file (in tens of megabytes) of hard coded data. This probably led to subsequent amendment of the rules regarding source file sizes.

I'll report back once I find the persons involved.

mort964• 1 year ago

One thing I always wondered is: what makes dynamic programming more "dynamic" than regular programming? Why is recursion "static" but it becomes "dynamic" if you store results?

bazoom42• 1 year ago

According the article, the term “dynamic” was chosen because it has positive connotations.

hnfong4• 1 year ago

When I learned dynamic programming, I was told this was in contrast to simple memoization in that memoization is a cache of computation, dynamic programming involves a "choice" in each step.

For example let's look at the fibonacci sequence, F(n) = F(n-1) + F(n-2), naively you just fill in a (1 dimensional) table with the results [1, 1, 2, 3, 5, 8, 13...] and it feels static because there's nothing to choose or decide.

In contrast for example the longest common subsequence looks like this:

  lcs[m, n] = 0                 if m = 0 or n = 0
  lcs[m, n] = lcs[m-1, n-1] + 1  if X[m] = Y[n]
  lcs[m, n] = max(lcs[m-1, n], lcs[m, n-1])  if X[m] != Y[n]

At every step there's a "choice" to be made depending on the situation. The functions like "max()" are quite typical for dynamic programming. At least this is how I interpret the "dynamic" part.

eloisant• 1 year ago

I also discovered the term "dynamic programming" 20 years in my career, when doing leetcode training for a job interview.

I still have no idea why it's called "dynamic".

sidewndr46• 1 year ago

As others have mentioned the term was chosen to be distinctive and attractive.

stonemetal12• 1 year ago

Marketing, Richard Bellman was trying to get funding and needed his work to sound high tech and fancy.

According to wikipedia: https://en.wikipedia.org/wiki/Dynamic_programming#History_of...

The word dynamic was chosen by Bellman to capture the time-varying aspect of the problems, and because it sounded impressive.The word programming referred to the use of the method to find an optimal program, in the sense of a military schedule for training or logistics. This usage is the same as that in the phrases linear programming and mathematical programming, a synonym for mathematical optimization.

Also, Harold J. Kushner stated in a speech that, "On the other hand, when I asked [Bellman] the same question, he replied that he was trying to upstage Dantzig's linear programming by adding dynamic.

HarHarVeryFunny3• 1 year ago

With dynamic programming the order of computation isn't necessarily fixed, even though you can sometimes order it to reduce or eliminate recursion. You are just reusing past results when they exist, else computing and storing if they don't.

marcellus23• 1 year ago

I know this is trite and arguably against the guidelines and I'm sorry. But this is simply a crazy thing to comment on an article whose whole point is to explain why it's called that.

ncruces• 1 year ago

Oh that's the year I went. Trip down memory lane. I was woefully unprepared. The mobile phone cell summation problem underlined how much I didn't know, and later figuring it out, how much I had to learn; it cemented my love for the field. I just loved the experience.

mrits• 1 year ago

As a US born native English speaker, I always struggled with the phrase. Eventually I just mentally called it a misnomer as the phrase provided no value to the actual problem set they described.

Sesse__• 1 year ago

For my first programming competition (the national ICPC prequalifier, in 2002), I asked my teammates (who I didn't know very well, we had just cobbled together a team) a couple of minutes before the contest what this dynamic programming thing was. One of them was “oh, it's only caching the output of a recursive function” (technically, that's memoization, but who cares).

I ended up solving a problem using DP a couple of minutes before the deadline, which was enough to get us to 3rd and to ICPC. Fun times.

aljgz• 1 year ago

In the university, we had a team for ACM ICPC. We helped our professor organize a local competition, to encourage more people to practice. We participated in that competition, of course. One question would give you a few numbers no greater than 13, and you would output the number of ways to put N queens on the cheeseboard of those sizes. Not a difficult problem, but our first implementation, needed 2 minutes while time limit was 1 minute. We could optimize, but we decided to run it for all possible numbers, write a new program with just a switch-case. This was q perfectly legal move. We could see his face while judging our submission, his huge surprise when code ended in milliseconds, his look of admiration at us, the curiosity about the solution, and finally his reaction when he checked out our code. Priceless.

ivan_gammel• 1 year ago

Fun enough, in commercial software engineering your solution won’t raise eyebrows as something routine and expected, but an efficient algorithm could do.

TheJoeMan• 1 year ago

Had a similar problem in a highschool comp. sci. class with a maze-following algorithm where you got points off for back-tracking. Turns out your code could pre-fetch the entire maze before making a move, which I think goes against the spirit of the exercise.

radicalbyte• 1 year ago

I had to laugh hard the first time I heard about it, I mean it's a really obvious technique if you've ever done low-level programming on limited machines as it's very close to something we used to do all the time - calculate result tables and use lookups which we built in to our code.

Trades memory for CPU when it's worth it. Dynamic programming takes the same idea but does it at runtime.

bo1024• 1 year ago

To be fair, DP generally also involves recursion in some way. You could describe it as a lookup table where, to fill in later entries of the table, you need to use the earlier entries.

hinkley9• 1 year ago

I found this video very helpful:

https://m.youtube.com/watch?v=oBt53YbR9Kk

Yes, it is 5 hours long. At least 4 of those are worth it.

Many people confuse caching with DP. I’ve had that conversation too often. I think it’s down to the memoization examples people choose being too toy and just looking like caching. Caching is global shared state, whereas memoization can be scoped to the current calculation and still be useful.

But they always skip over tabulation, which is where I believe DP distinguishes itself.

bjourne3• 1 year ago

But dp is a form of caching, no? It sacrifices space by caching intermediate results to compute successive results. The only reason it is called dp is because the "inventor" (Iirc Bell) needed a cool name.

afpx• 1 year ago

I was given a programming interview once where the interviewer gave me a DP problem (which I didn't know at the time), and he failed me because I used a cache instead of memoization. Asides from being inelegant, what are the downsides to caching?

mekoka4• 1 year ago

The key difference between caching and memoization is not global shared state, it's determinism. That's why the latter mostly applies locally. In that sense, they're only semantically different. Data in a cache can be expected to go stale; it must not if you rely on the structure as a memoized equivalent to calling the function with the given inputs. In practice, you can have global cache whose data is deterministic and you can also have local cache that goes stale. The latter is not memoization.

deaddodo• 1 year ago

Technically, "dynamic programming" (god, I hate that term) is focused on memoization/tabulation. It doesn't necessarily require recursion or an iterative approach, although they almost always go hand-in-hand in common leetcode/hackerrank/etc exercises.

ygritte2• 1 year ago

Try thinking of some combination that will possibly give [the word, dynamic] a pejorative meaning. It’s impossible*.
*This Haskell fan’s contender is “dynamic typing” :P

Nothing is impossible!

zoky• 1 year ago

It’s certainly possible to use it as a euphemism, if not an outright pejorative. “Dynamic truthfulness”, “dynamic sense of morality”, etc.

eru10• 1 year ago

There's also dynamic scoping; as opposed to lexical scoping a.k.a. static scoping.

You can find defenders of dynamic typing, but dynamic scope is now widely seen as a mistake. Or at least dynamic scope by default; it has specialised uses--and in Haskell the Reader Monad is basically isomorphic to dynamic scoping and no one complains about it.

ygritte2• 1 year ago

dynamic scoping

Right you are. Even more horrible. The tcl language still has it!

rat87• 1 year ago

Isnt dynamic scoping a bit similar to Dependency Injection? Maybe there's a form of it that could be useful. Like explicit dynamic scopes?

marcosdumay3• 1 year ago

Those are not pejorative names. They are descriptive names for (arguably) bad things.

And they are all much more enticing than the things deserve.

commandersaki• 1 year ago

Same for "linear programming".

marcosdumay3• 1 year ago

The "linear" in linear programming at least is related to the problem it's solving (linear optimization).

IshKebab• 1 year ago

Possibly the worst named thing in computing? Not only is "programming" not referring to programming, but "dynamic" is meaningless and just there to try to make it sound fancy.

I prefer "cached recursion".

eru10• 1 year ago

Well, cached recursion is a bit too generic. Almost anything can be done with both caches and recursion.

We had a different characterisation in one of our mathematical optimisation classes: dynamic programming is basically every problem that isomorphic to finding the longest path in a graph, with suitable 'overloading' of 'maximum' (for picking among multiple alternative paths) and 'addition' (for combining multiple sub-paths).

First, to illustrate what I mean by this overloading: matrix multiplication usually has multiplication () and addition (+). However, in the min-plus-algebra you overload (+) with minimum and () with plus, and then multiplying matrices becomes equivalent to hopping two paths in the adjacency matrix of a graph. (Sorry, if this is a bit confusing.) Specifically, taking an adjacency matrix A and calculating A* := 1 + A + AA + AAA + ... is equivalent to taking the transitive closure of edge hopping in your graph, ie the shortest paths between all pairs of vertices.

If you overload (+) with maximum and () with plus instead, you can find longest paths. For that to make sense, you should not have cycles in your graph.

Now let's go back to dynamic programming: the shared optimal sub-structure property of dynamic programming is exactly the same as what you have in finding longest paths.

The structure might sound overly restrictive, but you'll find that it works for all (most?) examples of dynamic programming.

P.S. My recollection was a bit vague, so I asked ChatGPT for some help, and apparently I wasn't completely wrong: https://chatgpt.com/share/687de24c-c674-8009-9984-0fda56d1c1...

P.P.S. Despite everything I said above, I agree that 'cached recursion' is still a better name than dynamic programming.

tgma5• 1 year ago

I actually think overly focusing on the memoized recursion undermines the core conception of dynamic programming. Remember, as noted in the post, the term programming refers to a tabular method of planning, i.e. specifically, the bottom-up calculation to solve a problem. The emphasis here is on a predetermined order on how to tabulate the plan to get to the desired result which will be the solution to the broader problem.

The memoized recursive function is an implementation methodology on a digital computer that specifically side-steps the question of in which order one should do the tabulation. I would argue that recursive memoization is a possible solution technique to dynamic programming problems (defined as the universe of problems that admit a dynamic programming solution,) but strictly speaking, in and of itself, is not dynamic programming.

eru10• 1 year ago

I'd actually go the other way round: figuring out a suitable recurrence relation is usually the first step in any dynamic programming solution. As a next step, sure, you can explicit construct a table to fill in, but that's not actually a requirement: dynamic programming also works when your parameters aren't things like numbers that you can easily use to enumerate rows in a table.

Memoisation is a more general tactic that hands more of the busy work over to the computer.

3170703• 1 year ago

I think "cached recursion" is too broad. I tend to go with "Minimal Memory Memoization".

1) the recursion solution is often too slow, but uses little memory.

2) the memoization solution can make the algorithms from 1 a lot faster, but blows up memory use.

3) the dynamic programming solution only keeps the previous partial solutions in memory that will be needed for future partial solutions. Therefore it is the "Minimal Memory Memoized" solution. It often requires a smart ordering of partial solutions that allows for the earliest cache eviction.

Your "cached recursion" sounds like number 2 to me, and the crux about dynamic programming is to figure out when to remove an entry from your cache.

zelphirkalt5• 1 year ago

Even just keeping the partial solutions in memory that will later be needed can use much more memory than a bottom up solution. Recursion being slow depends on the implementation of your programming language.

Certhas6• 1 year ago

Dynamic is definitely not meaningless. I am familiar with dynamic programming from the optimal control theory point of view, and it's squarely focused on dynamical systems. The central equation of dynamic programming is the Hamilton-Jacobi-Bellmann equation, a generalization of the Hamilton-Jacobi equations of classical mechanics. And the terminology programming in this context also exists in linear programming and stochastic programming. It's definitely confusing today, but these terms simply predate the modern use of programming, as well as modern computers. I am honestly a bit puzzled by everyone in this comment section talking about recursion + memoization (as a way to efficiently implement backward induction I presume?). It seems like computer science teaches a particular application and implementation of dynamic programming ideas and people mistake that for the whole thing?

tgma5• 1 year ago

Well, to be fair, you are questioning terminology bastardization in "computer science," a field that is named after "computers" and "science" but has little to do with either. One should temper their expectations :) Informatics, a commonly used term in Europe, would have been a much better name.

mort964• 1 year ago

I don't understand most of what you wrote. But can you, in simple terms, explain to me why recursion without caching is "static"?

rochak• 1 year ago

Yup. I don’t mind it though as this field is riddled with names that convey absolutely nothing about the actual thing.

emmelaich• 1 year ago

It's deliberately obscure. Per the article it's for promotion not description.

tgma5• 1 year ago

Programming terminology is in the same vein as "Linear Programming..."

As per Wikipedia, that origin story is somewhat disputed:

"According to Russell and Norvig, the above story "cannot be strictly true, because his first paper using the term (Bellman, 1952) appeared before Wilson became Secretary of Defense in 1953." Also, Harold J. Kushner stated in a speech that, "On the other hand, when I asked [Bellman] the same question, he replied that he was trying to upstage Dantzig's linear programming by adding dynamic. Perhaps both motivations were true."

random3• 1 year ago

I can't find the resource, but, according to Bellman he needed a name that wouldn't sound like something the army would scrape— effectively protecting his research. He had a few options and "dynamic" sounded "cool" enough, in his opinion, for army.

This said, the "programming" part is pretty accurate, but IMO the author misses the point with what "computer programming" meaning is, afterall.

mr_toad2• 1 year ago

Linear programming gets confused with programming, but also with linear algebra and linear modelling.

nextaccountic• 1 year ago

Programming in this sense means just optimization

bob1029• 1 year ago

Dynamic optimality is a way more interesting concept to me. Data structures like the splay tree can effectively write the "ideal program" for accessing data based on the current use patterns by maintaining the data in a particular way over time. Instructions and data are mostly the same thing when you really think about it.

lblume3• 1 year ago

Dynamic optimality sounds like a very euphemistic description of Levin's Universal Search to me – it is definitely optimal, just in a very, hmm, dynamic, let's say, way.

sureglymop• 1 year ago

I first learned about Dynamic Programming in the algorithms and datastructures class in the first semester at uni. But the lecturer very quickly moved on to only ever refer to it as "DP". This makes me think he may have done that as to not confuse students.

Even though I knew it wasn't referring to programming I did wonder why it was called that, interesting!

eric-burel• 1 year ago

The article would probably be more complete with references to similar terms "linear program" or "integer program", unless this is also a slightly different meaning?

pss314• 1 year ago

Richard Bellman on the Birth of Dynamic Programming (2002) [pdf] https://news.ycombinator.com/item?id=42482289

nottorp3• 1 year ago

Thus, I thought dynamic programming was a good name. It was something not even a Congressman could object to. So I used it as an umbrella for my activities.

That reminds me of, much later, getting my first basic programming book. In communist Romania. It was titled "Let's learn interactive microelectronics" because "programming" books were considered a waste of resources and did not get approved.

lblume3• 1 year ago

I thought communist nations heavily relied on programs (in the author's sense) for their planned economies?

nottorp3• 1 year ago

No, on "plans". Mostly five year plans. At least in Romanian.

The only other use of "program" I remember from back then is "tv program".

sigmoid10• 1 year ago

Looks like someone discovered this reddit post [1] and wrote a whole blog around the top answer. Since the example is copied verbatim, it might even be an LLM that was hooked up to web search.

[1] https://www.reddit.com/r/learnprogramming/comments/1ac9zbl/d...

globular-toast• 1 year ago

Huh, I've never realised this. It actually makes more sense if I revert to my native British spelling of programme in this sense.

A program can use dynamic programming to dynamically figure out the programme required to perform a computation.

cousin_it• 1 year ago

My favorite dynamic programming problem is computing the percent of relatedness between two people, given a set of people and a partial graph of parenthood among them (with the assumption that any relatedness not implied by the graph is zero). If seems very confusing at first, but then you realize that if A is not a descendant of B, rel(A,B)=(rel(A,father(B))+rel(A,mother(B)))/2, which allows you to compute all relatedness values from top to bottom of the graph as fast as possible.

DonHopkins3• 1 year ago

James Gosling's infamous Emacs screen redisplay algorithm uses dynamic programming.

https://en.wikipedia.org/wiki/Gosling_Emacs

It computed the minimal cost path through a cost matrix of string edit operations (the costs depended i.e. on the number of characters to draw, length of the escape codes to insert/delete lines/characters, padding for slow terminals, etc).

The algorithm used is a dynamic programming one, where

   M[i,j] = MIN (M[i-1,j]+dcost,             # UP,   implies delete
                 M[i,j-1]+icost+redraw cost, # LEFT, implies ins+redraw
                 M[i-1,j-1]+rewrite cost)    # BACK, implies rewrite

Each terminal type would configure the display driver according to its supported escape codes and screen update times (some terminals were REALLY SLOW inserting and deleting lines or even scrolling, and you had to send null padding to wait for it to finish).

It's infamous both for its skull-and-crossbones warning comment [designed by Brian Reed] and correspondingly poisonous complex code, and also RMS's battle with UniPress software, incorporating it into Gnu Emacs, getting threatened by UniPress, then rewriting it from scratch.

https://features.slashdot.org/story/13/01/06/163248/richard-...

Q: Give me your best hack. [...]
RMS: I can't remember all the hacks that I was proud of, so I can't pick the best. But here's something I remember fondly. The last piece of Gosmacs code that I replaced was the serial terminal scrolling optimizer, a few pages of Gosling's code which was proceeded by a comment with a skull and crossbones, meaning that it was so hard to understand that it was poison. I had to replace it, but worried that the job would be hard. I found a simpler algorithm and got it to work in a few hours, producing code that was shorter, faster, clearer, and more extensible. Then I made it use the terminal commands to insert or delete multiple lines as a single operation, which made screen updating far more efficient.

There's some more discussion about it here that ended up being pretty accurate once all was said and done:

https://www.reddit.com/r/emacs/comments/bek5b2/til_emacs_was...

Emacs's infamous "Ultra-hot screen management package" with its "Skull and Crossbones" warning was definitely black magic!

The algorithm worked great and was well worth it over a 300 / 1200 / 2400 baud connection to a Vax 780 / 750 / etc, and as modems and computers got faster it was still useful, but at today's network bandwidths and cpu speeds it's thunderous overkill.

https://news.ycombinator.com/item?id=38996713

A redisplay algorithm, by James Gosling (ACM SIGPLAN Notices, April 1981):

https://donhopkins.com/home/documents/EmacsRedisplayAlgorith...

7. Acknowledgements: The people who did the real work behind this paper are Mike Kazar, Charles Liescrson and Craig Everhart; all from CMU.
Bibliography: 1. Kevin Q. Brown. Dynamic Programming in Computer Science. CMU, February, 1979.

That code was also used in Maryland Windows (a text based overlapping/tiled window system developed at the University of Maryland by Chris Torek, like Emacs - Text Editor + Window System, kind of like "screen" or "mux" or "mgr").

https://donhopkins.com/home/archive/emacs/mw/display.c

https://en.wikipedia.org/wiki/Dynamic_programming

https://wiki.c2.com/?DynamicProgramming

https://en.wikipedia.org/wiki/ManaGeR

https://news.ycombinator.com/item?id=22849522

Gosling Emacs was especially noteworthy because of the effective redisplay code, which used a dynamic programming technique to solve the classical string-to-string correction problem. The algorithm was quite sophisticated; that section of the source was headed by a skull-and-crossbones in ASCII art, warning any would-be improver that even if they thought they understood how the display code worked, they probably did not.

https://donhopkins.com/home/archive/emacs/mw/display.c

    /*  1   2   3   4   ....            Each Mij represents the minumum cost of
          +---+---+---+---+-----        rearranging the first i lines to map onto
        1 |   |   |   |   |             the first j lines (the j direction
          +---+---+---+---+-----        represents the desired contents of a line,
        2 |   |  \| ^ |   |             i the current contents).  The algorithm
          +---+---\-|-+---+-----        used is a dynamic programming one, where
        3 |   | <-+Mij|   |             M[i,j] = min( M[i-1,j],
          +---+---+---+---+-----                      M[i,j-1]+redraw cost for j,2
        4 |   |   |   |   |                           M[i-1,j-1]+the cost of
          +---+---+---+---+-----                        converting line i to line j);
        . |   |   |   |   |             Line i can be converted to line j by either
        .                               just drawing j, or if they match, by moving
        .                               line i to line j (with insert/delete line)
     */

Trivia: That "Skull and Crossbones" ASCII art is originally from Brian Reid's Scribe program, and is not copyrighted.

https://donhopkins.com/home/archive/emacs/skull-and-crossbon...

                         /-------------\ 
                        /               \ 
                       /                 \ 
                      /                   \ 
                      |   XXXX     XXXX   | 
                      |   XXXX     XXXX   | 
                      |   XXX       XXX   | 
                      \         X         / 
                       --\     XXX     /-- 
                        | |    XXX    | | 
                        | |           | | 
                        | I I I I I I I | 
                        |  I I I I I I  | 
                         \             / 
                          --         -- 
                            \-------/ 
                    XXX                    XXX 
                   XXXXX                  XXXXX 
                   XXXXXXXXX         XXXXXXXXXX 
                          XXXXX   XXXXX 
                             XXXXXXX 
                          XXXXX   XXXXX 
                   XXXXXXXXX         XXXXXXXXXX 
                   XXXXX                  XXXXX 
                    XXX                    XXX 

                          ************** 
                          *  BEWARE!!  * 
                          ************** 

                        All ye who enter here: 
                    Most of the code in this module 
                       is twisted beyond belief! 

                           Tread carefully. 

                    If you think you understand it, 
                              You Don't, 
                            So Look Again.

But if you're not trying to support old terminals (but might still have a slow "thin wire" network connection), there is an orders of magnitude better approach: The Emacs NeWS display driver (for both UniPress and Gnu Emacs) downloaded PostScript code to define an efficient application specific network protocol with instantaneous local input tracking and feedback (unlike how X-Windows uses a fixed protocol, but like how AJAX uses JavaScript).

The source code to Gosling's UniPress Emacs 2.20 just recently surfaced, and the display code is well commented (still including the skull and crossbones and ascii art diagrams):

https://github.com/SimHacker/NeMACS/blob/main/src/DspVScreen...

And the lower level terminal driver layer:

https://github.com/SimHacker/NeMACS/blob/main/src/DspTrm.c

The NeWS terminal drivers I worked on for UniPress and Gnu Emacs were layered on top of that dynamic programming screen update code. But instead of sending escape codes to a dumb terminal, it downloaded PostScript code into the NeWS server to implement drawing, mouse tracking, text selection feedback, pie menus, tabbed windows, etc, and sent binary PostScript tokens back and forth (a practice now called "AJAX" for X = XML or JSON text instead of binary PostScript data and code):

TrmPS.c: https://github.com/SimHacker/NeMACS/blob/main/src/D.term/Trm...

TrmPS.cps: https://github.com/SimHacker/NeMACS/blob/main/src/D.term/Trm...

PostScript stuff for Emacs: https://github.com/SimHacker/NeMACS/tree/main/ps

Emacs 2.20 Demo (NeWS, multiple frames, tabbed windows, pie menus, hypermedia authoring):

https://www.youtube.com/watch?v=hhmU2B79EDU

Here's a brochure from February 1988 about UniPress Emacs 2.20 and "SoftWire" (NeWS without graphics, kind of like Node with PostScript instead of JavaScript).

What is Emacs: https://www.donhopkins.com/home/ties/scans/WhatIsEmacs.pdf

I also worked on the Gnu Emacs 18 NeWS display driver (supporting a single tabbed windows and pie menus in The NeWS Toolkit 2.0):

tnt.ps: https://www.donhopkins.com/home/code/emacs18/src/tnt.ps

tnt.cps: https://www.donhopkins.com/home/code/emacs18/src/tnt_cps.cps

tnt.c: https://www.donhopkins.com/home/code/emacs18/src/tnt.c

tnt-win.el: https://www.donhopkins.com/home/code/emacs18/lisp/term/tnt-w...

More on the NeWS versions of Emacs with links to code here:

https://news.ycombinator.com/item?id=26113192

amelius4• 1 year ago

Makes sense as the most widely known algorithm for finding the minimal edit distance between two strings also relies on DP. It was invented around 1968.

https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorit...

amelius4• 1 year ago

What would we call it if it were invented today?

GuB-42• 1 year ago

Probably AI something.

The name "dynamic programming" was chosen to impress bureaucrats, and AI is where it is at today.

"Subtask training" maybe, as the idea is to train the algorithm on smaller tasks to to make it more efficient at solving larger tasks. Ok, it is just storing intermediate results, but it sounds more AI-ish like that.

inopinatus• 1 year ago

Partial/Intermediate Solution Storage

amelius4• 1 year ago

Tabularized memoization?

Bottom-up memoization?

Iterative memoization?

cubefox• 1 year ago

I thought both recursive top-down memoization and iterative bottom-up tabulation are considered instances of "dynamic programming".

qprofyeh• 1 year ago

Thanks for sharing. I always viewed DP as finding partials to cache. Something not done a lot in day to day algos. Did not appreciate the name as being related to execution order optimization.

montebicyclelo• 1 year ago

I always found that badly named things did make learning harder / more jarring; especially if an explanation for the incongruous name wasn't provided.

layer8• 1 year ago

Similar for “linear optimization”, which doesn’t refer to program optimization.

omnibrain• 1 year ago

Ok, but how do you call what we are doing:

We have an interpreted language in which you can call "subroutines" by name. But you can build the name in you program "on the fly", for example out of data.

throwawayffffas2• 1 year ago

Dynamic programming is a subfield of mathematical programming. The field of studying optimization problems.

It's called programming because programming means scheduling. And most of the problems the field initially concerned itself with were logistics scheduling problems.

Computer programming is called programming because it involves scheduling instructions.

jbreckmckye• 1 year ago

I did not know that. Fascinating.

throwawayffffas2• 1 year ago

For all the people looking for different terminology, the word you are looking for is optimization.

Dynamic optimization makes just as much sense. Same as Mathematical optimization does for the wider field of study.

m3nu• 1 year ago

In strength training 'programming' means the details of your workout plan. Like how many sets, reps and exercises.

ChrisMarshallNY• 1 year ago

That's a really interesting origin story. I had no idea, but I also totally believe it. I've seen things, man...

graycat• 1 year ago

Yup: And stochastic dynamic programming and stochastic optimal control! Suppose a cargo plane is to fly from Kansas City to St. Louis, Chicago, Indianapolis, Dayton, Nashville, and Memphis and at each city pickup cargo. Suppose the cargo weights are known only in probability distribution from history and otherwise are probabilistically independent. Have weather reports for the winds and temperatures, but the actual values can vary from the reports. And suppose the fuel prices vary significantly among the stops but are known.

Then, how much fuel should the pilot buy at each stop to minimize expected cost for the trip? I.e., in simple terms, buy extra fuel where it's cheap and carry (tanker) it to where it's expensive but in so doing burn extra fuel from the extra weight of the extra fuel.

Solution: Stochastic dynamic programming.

Hint: In Canada, the solution is illegal!

Was meeting with Nemhauser (see references below); my cab back to the airport was waiting; and he gave me a 15 second lecture. On the plane thought about his lecture, ..., and stood for my Ph.D. orals and passed (extra credit for guessing my employer).

Some references (with TeX markup):

Stuart E.\ Dreyfus and Averill M.\ Law, {\it The Art and Theory of Dynamic Programming,\/} ISBN 0-12-221860-4, Academic Press, New York.\ \

Dimitri P.\ Bertsekas, {\it Dynamic Programming: Deterministic and Stochastic Models,\/} ISBN 0-13-221581-0, Prentice-Hall.\ \

George L.\ Nemhauser, {\it Dynamic Programming,\/} ISBN 0-471-63150-7, John Wiley and Sons, New York\ \

E.\ B.\ Dynkin and A.\ A.\ Yushkevich, {\it Controlled Markov Processes,\/} ISBN 0-387-90387-9, Springer-Verlag, Berlin.\ \

Wendell H.\ Fleming and Raymond W.\ Rishel, {\it Deterministic and Stochastic Optimal Control,\/} ISBN 0-387-90155-8, Springer-Verlag, Berlin.\ \

Michael Athans and Peter L.\ Falb, {\it Optimal Control:\ \ An Introduction to the Theory and Its Applications,\/} McGraw-Hill Book Company, New York.\ \

Dimitri P.\ Bertsekas and Steven E.\ Shreve, {\it Stochastic Optimal Control: The Discrete Time Case,\/} ISBN 0-12-093260-1, Academic Press, New York.\ \

E.\ B.\ Lee and L.\ Markus, {\it Foundations of Optimal Control Theory,\/} ISBN 0471-52263-5, John Wiley, New York,

cjfd• 1 year ago

Just call it caching. The whole concept is a bit too simple to be a word.

monkeyelite• 1 year ago

That thought comes from a programmer perspective.

What’s interesting in terms of the theoretical properties and classification of a problem is the recursive nature with overlapping recursion.

Jtsummers7• 1 year ago

It doesn't require caching, though. So that's a wrong description of the concept.

NoThisIsMe• 1 year ago

You're thinking of memoization, which is related to but distinct from DP. Memoization is "top down", DP is "bottom up". DP generally has better space complexity (memory requirements). For example, for a function that computers the Fibonacci sequence, space complexity with memoization is O(n), vs O(1) with DP.

https://en.wikipedia.org/wiki/Dynamic_programming#Fibonacci_...

Jtsummers7• 1 year ago

Both top down and bottom up approaches can be used with dynamic programming. DP is about how you approach solving a problem by breaking it into subproblems (see the term used, "optimal substructure"). Whether you use that information for a top-down (often memoized) solution or a bottom-up solution is a choice for the implementor (and which depends on how you're using your solver and solutions).

If you need to solve one problem, bottom-up is often most efficient. But if you need to solve many related problems (say trialing many different initial conditions) then you may want the memoized solution.

duped• 1 year ago

Fibonacci is a bad example because it relies on the linearity of `prev + current` to be O(1) memory complexity. A lot of divide-and-conquer schemes exploit symmetry and linearity of their internals but if the operation is nonlinear then it requires memoization/caching.

On that note, I really struggle to understand what's special about "bottom up" versus "top down" DP or what categorizes it as unique from any other algorithms.

almostgotcaught• 1 year ago

Dynamic programming has absolutely nothing to do with caching (or programming). You should read the article.

manoji• 1 year ago

DP(Dynamic Programming) is such a beautiful technique .It took a while for me to grasp it . There are many applications in real world systems as well. Eg Duck DB's join order optimizer is built on https://15721.courses.cs.cmu.edu/spring2020/papers/20-optimi... .

https://github.com/duckdb/duckdb/blob/61f07c3221e01674d8fe40...

aldousd666• 1 year ago

I learned what 'dynamic programming' was from studying the 'BLAST' algorithm for DNA sequence search. BLAST is a heuristic approximation for the otherwise Dynamic Programming algorithm created by 'Smith & Waterman' Before that, I would have misunderstood the term too.

dang• 1 year ago

Many past related threads, but these seem to be the interesting ones. Other interesting ones?

Richard Bellman on the Birth of Dynamic Programming (2002) [pdf] - https://news.ycombinator.com/item?id=42482289 - Dec 2024 (9 comments)

Dynamic programming is not black magic - https://news.ycombinator.com/item?id=38988948 - Jan 2024 (202 comments)

Dynamic Programming vs. Divide-and-Conquer (2018) - https://news.ycombinator.com/item?id=26930667 - April 2021 (115 comments)

Real-world dynamic programming: seam carving - https://news.ycombinator.com/item?id=20285242 - June 2019 (66 comments)

Graphical Introduction to Dynamic Programming - https://news.ycombinator.com/item?id=19682258 - April 2019 (11 comments)

Dynamic Programming for Technical Interviews - https://news.ycombinator.com/item?id=19395578 - March 2019 (218 comments)

Solving dynamic programming interview problems - https://news.ycombinator.com/item?id=17102604 - May 2018 (164 comments)

Dynamic Progamming: First Principles - https://news.ycombinator.com/item?id=15545686 - Oct 2017 (98 comments)

What is difference between memoization and dynamic programming? - https://news.ycombinator.com/item?id=13281884 - Dec 2016 (1 comment)

Dynamic Programming: The Name (1984) - https://news.ycombinator.com/item?id=12476597 - Sept 2016 (61 comments)

Fibonacci series and Dynamic programming - https://news.ycombinator.com/item?id=5893237 - June 2013 (28 comments)

Dynamic Programming versus Memoization - https://news.ycombinator.com/item?id=4434671 - Aug 2012 (26 comments)

Visualizing dynamic programming - https://news.ycombinator.com/item?id=2243297 - Feb 2011 (11 comments)

Ask HN: Have you ever used Dynamic programming in your dev job? - https://news.ycombinator.com/item?id=1796861 - Oct 2010 (11 comments)

Why the name "dynamic programming"? - https://news.ycombinator.com/item?id=1290397 - April 2010 (25 comments)

The Edit Distance Problem - https://news.ycombinator.com/item?id=571570 - April 2009 (13 comments)

Introduction to Dynamic Programming - https://news.ycombinator.com/item?id=329953 - Oct 2008 (12 comments)

AndrewKemendo• 1 year ago

If you haven’t, everyone should read Eye of the Storm

It’s Bellmans autobiography and it’s very good though he doesn’t go as much into depth as I wanted on how he came up with DP and his inequality

andreygrehov• 1 year ago

If anyone's interested, I published a short, ad-free YouTube series on Dynamic Programming about 4-5 years ago [1]. I haven't had a chance to continue it, but many people have found the course eye-opening.

[1] https://www.youtube.com/@andreygrehov

an0malous• 1 year ago

I read the post and all these comments and I still have no idea what dynamic programming is. I’m also slightly infuriated by the rationalization for the name mentioned in the post.

stockresearcher• 1 year ago

I've seen this many times before and it always presents Charles Wilson's aversion to "research" in a "haha what a luddite" manner.

You have to understand that Eisenhower believed that the military industrial complex was out of control. He brought Wilson in to help rein it in and reorganize the defense department.

The military and military contractors were conducting "research" in the form of doing chemical and biological weapons experimentation on soldiers and civilians without their knowledge or consent. Wilson was trying to stop that.

And of course many of the think tanks were trying to lead the United States into an offensive war against the Soviet Union, which Wilson and Eisenhower did not want or think was necessary. It's entirely probable that the only reason Bellman got funding to do this work at RAND was because they intended to use it for running their desired war.

ajuc• 1 year ago

Top 3 worst name ever (along with "toxic masculinity" and "oxygen").

teleforce• 12 months ago

Fun facts the venerable Border Gateway Protocol or BGP is using distant-vector algorithm for global Internet routing calculation based on Bellman-Ford dynamic programming approach due to its scability in updating the routing table [1].

For intranet routing however shortest path algorithm based on Dijkstra approach underlies the OSPF and IS-IS protocols.

In the old days distant-vector protocol like Routing Information Protocol protocol or RIP is also used but it's now becoming obsolete and humorously known as Rest In Peace protocol.

Distant-vector now is making a comeback for intranet in the form of mobile ad hoc and mesh networks (guerilla networks for routing without infrastructure) with Ad hoc On-Demand Distance Vector Routing protovol or AODV [2]. This setup can be very beneficial for disaster and also for mobile group or platoon communication.

[1] Distance-vector routing protocol:

https://en.wikipedia.org/wiki/Distance-vector_routing_protoc...

[2] Ad hoc On-Demand Distance Vector Routing:

https://en.wikipedia.org/wiki/Ad_hoc_On-Demand_Distance_Vect...

“Dynamic programming” is not referring to “computer programming”

Related Stories