Dynamic programming (DP) is a technique used to solve innately inefficient recursive problems by storing solutions to pre-computed subproblems. The idea is to break a problem into smaller subproblems and save the result of each subproblem so that it is only calculated once. Dynamic programming involves two parts: restating the problem in terms of overlapping subproblems and saving the solution of the subproblems so that we can build the solution to the bigger problem.
In my previous blog post we have discussed the evaluation strategies in Scala and the difference between call-by-value, call-by-name and call-by-need. Also, I have shown a small workaround for evaluating the arguments lazily (aka call-by-need). As previously presented, the workaround for call-by-need arguments consists of local lazy values which are initialised with the call-by-name arguments we want to be evaluated at most once:
Evaluation strategies are one of the most important traits of programming languages. Hence, I chose this topic for the current blog post. We are going to have a quick introduction to evaluation strategies and then look at the evaluation strategies supported by Scala.
As I mentioned in my previous post, I recently took the course. Being a Scala developer, I was always wondering how different languages apply the Functional Programming paradigm, especially when it comes to the main source of inspiration for Akka.
A new course on functional programming has finished on . Now it was the time for some . Organised by The University of Kent and taught by Professor this course is a very good opportunity to explore how Erlang applies the functional programming paradigm.