<img height="1" width="1" src="https://www.facebook.com/tr?id=&amp;ev=PageView &amp;noscript=1">

Posted by Amir Karimi
Mon, Jan 29, 2018

OK, you came to the conclusion that type-safety is good; it helps you get things done in a safer manner, at least for whatever you’re working on at the moment. So you started using types more than before to describe what a piece of code does without the need to run; in other words, to bring forward unwanted errors.

Posted by Javier Salcedo. Z
Tue, Jan 16, 2018


Posted by Miguel Vilá
Mon, Nov 20, 2017

In the previous posts, we saw an approach to solving problems in a bottom-up fashion and trying to be functional. In this last post we will see a functional approach when solving them top-down.

Posted by Miguel Vilá
Thu, Oct 12, 2017

In the previous post we saw a way to functionally solve the knapsack problem. Can we do the same when the dependencies between solutions have another shape?

Posted by Miguel Vilá
Wed, Oct 4, 2017

In the last post we saw an imperative solution to the knapsack problem. In this post we will see an initial approach for doing the same thing functionally.

Posted by Miguel Vilá
Mon, Sep 11, 2017

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.

Posted by Tudor Zgureanu
Thu, Jun 29, 2017

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:

Posted by Tudor Zgureanu
Sat, Jun 3, 2017

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.

Posted by Tudor Zgureanu
Tue, Mar 28, 2017

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.

Posted by Tudor Zgureanu
Mon, Mar 13, 2017

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.

Recent Posts

Posts by Topic

see all

Subscribe to Email Updates