Hybrid languages are cool. Most powerful programming languages are those languages which can handle a multi-paradigm scope. You can reduce the amount of code considerably when you are using a multi-paradigm approach. Due to the imperative origin and procedural approach of object oriented languages, having only object oriented language approach is not enough to solve problems. For example as we reviewed the widely used MapReduce distributed computing model has its origin on the functional paradigm in two higher order functions called map and reduce — where the synonym of reduce is fold, applying a kind of Monoid where the data is lifted and transformed by the map function and then is processed and reduced by the fold or reduce function.
tl;dr
I prefer multi-paradigm languages because you can do cool stuff with less code.
why do I prefer it?
If you reduce the amount of code that you are programming, you can decrease the amount of possible bugs by reducing its cyclomatic complexity. So, using functional approach in certain cases will reduce the amount of code that you are producing, increasing your productivity considerably. Take a look on the following code made on PHP to find the lowest value in an array of associative arrays.
<?php
/* PHP example on associative arrays */
$min = 9999;
$tst = array(array('a' => 30, 'b' => 20, 'c' => 10),
array('a' => 29, 'b' => 19, 'c' => 9),
array('a' => 28, 'b' => 18, 'c' => 8));
foreach ($tst as $t) {
if ($t['a'] < $min) {
$min = $t['a'];
}
}
echo "{$min}n";
?>
Now take a look on the same problem but implemented in Python using multi-paradigm approach, with functional features and using higher order functions.
### Python example using higher order functions and
### functional approach
tst = [{'a': 30, 'b': 20, 'c': 10},
{'a': 29, 'c': 19, 'c': 9},
{'a': 28, 'c': 18, 'c': 8}]
t = min(*tst, key=lambda x: x['a'])
print(t['a'])
You can clearly see that the code was reduced to only one line of code using a functional approach, using min as higher order function, so the η-reduction is evident. And you can handle a wide variety of problems using the functional approach, reducing the amount of lines of code considerably, increasing your productivity and doing better code. Do you remember how to calculate the factorial?, do you remember the factorial example in Python?. Take a look on the PHP implementation against the Python implementation.
<?php
/* PHP factorial example */
function fact($n) {
if ($n == 0) return 1;
$r = 1;
for ($i = 1; $i <= $n; $i++) {
$r = $r * $i;
}
return $r;
}
$f = fact(4);
echo "{$f}n";
?>
Now take a look on the Python implementation. You will notice a multi-paradigm approach using procedural and functional paradigms, using higher order functions again.
### Python factorial example
def fact(n):
if n == 0: return 1
return reduce(int.__mul__, xrange(1, n + 1))
print(fact(4))
I really like to know how functional programming can allow you to reduce the amount of lines of code which are required to complete certain tasks, and how it is expressive as procedural code does, but it is pretty much well fluent and it has less cyclomatic complexity than the procedural approach. Functional code is very legible. The other advantage is the fact that some compilers supporting the functional paradigm are enabled with tail calls implementation, so you do not need to worry about creating stack frames and generating stack overflows with recursive functions. Languages that currently supports multi-paradigm approach are JavaScript, Python, Ruby and Scala, among other languages.
So, I recommend you that you should start learning some functional programming principles and techniques. On the past I got tired of those companies with silly restrictions about using reductions and making the code looks like literate programming code, instead of well qualified enterprise code, and since I am working as freelancer, I just use the best practices that each language requires.
Do not get stuck in object oriented and procedural paradigms only, learn other paradigms and approaches, so you can handle a wider number of problems reaching better solutions, more optimal in lines of code, cyclomatic complexity, algorithmic complexity and time complexity. In some manner, what I can say is the fact that more lines of code do not means better, it depends on the language that you are using and how do you implement your solutions, and having a multi-paradigm approach can lead you to deliver better code. Sometimes — certain languages — can allow you to implement the same solution with less code, you just need to know the proper technique.
Many languages now are including some functional features, and are going multi-paradigm. For example Java 8 has included Lambda Expressions, C# includes Lambda Expressions, they just need to implement Closures to start doing some cool stuff in certain cases. PHP 5.3 now includes Lambda Expressions or Anonymous Functions. So, you should learn about the functional paradigm, among other stuff that will be required in the future.
Entries 