Claudiu Persoiu

Blog-ul lui Claudiu Persoiu

Archive for 21 April 2011

Yahoo! Open Hack Europe 2011 at Bucharest!

without comments

Yahoo! Open Hack Europe 2011 will be held in Bucharest! Between 14-15 May we are the lucky Europeans to host this event.

At this event there are two types of tickets: Tech Talk and Hacker. Those who choose Tech Talk will attend seminars and awarding only, while those who choose Hacker will stay overnight to work on the project they’ve chosen.

Important figures from the Yahoo! staff will be present, so in short is an event that you must not miss!

Written by Claudiu Persoiu

21 April 2011 at 7:23 PM

Posted in Diverse

Tagged with ,

Closures and lambda functions in PHP vs. JavaScript

with 2 comments

JavaScript and PHP support both lambda functions and closures. But the terms are poorly understood in both programming languages ​​and are often confused with each other.

Lambda functions

Also called anonymous functions. They refer to functions that can be called without being bound to an identifier. One of their purposes is to be passed as arguments. The Lambda name was introduced by Alonzo Church, inventor of lambda calculus in 1936. In lambda calculus all functions are anonymous.


In JavaScript lambdas are part of the standard set and there are the preferred method of defining functions.

For instance:

var add = function (a, b) {
     return a + b;
alert(add(1, 2)); // 3

Lambda functions are used almost in any context when it comes to JavaScript, like:

window.onload = function (e) {
     alert('The page has loaded!');


In PHP, lambda functions were introduced in version 4.0.1 using create_function. In version 5.3+ a similar syntax to JavaScript was added, a much more readable and elegant way of defining a function.

This means that in PHP there are two ways of creating a lambda function:

// PHP 4.0.1+
$add = create_function('$a, $b', 'return $a + $b;');

// vs.

// PHP 5.3+
$add = function ($a, $b) {
     return $a + $b;

echo $a(1,2); // 3

Lambda functions can be used as parameter for other functions, such as usort:

$array = array(4, 3, 5, 1, 2);
usort($array, function ($a, $b) {
     if ($a == $b) {
          return 0;
     return ($a < $b) ? -1 : 1;

Even more, PHP 5.3+ allows calling an object as a anonymous function:

class test {
     function __invoke($a) {
          echo $a;
$a = new test();
$a('test'); // 'test'


The closure is really the misunderstood concept of the two. In general confusion appears because closures may involve lambda functions. A closure refers to the ability of a function/object to access the scope in which it was created even if the parent function has ended it’s execution and returned. In other words, the function/object returned by a closure is running in the scope in which it was defined.

In JavaScript the notion of closure is part of the standard arsenal, because the language is not based on the traditional object model, but rather on prototypes and functions. But JavaScript has some traditional object model parts, like the fact that you can use “new” to construct an object based on a function that plays the role of a class. In PHP closures are more of an new way to approach problems, because PHP is part of the traditional object model family.


In JavaScript the notion of closure is widely used, it’s so popular because JavaScript is not a traditional object orientated language, but rather a functional one, based on prototype inheritance.

JavaScript doesn’t have Public, Private and Protected, but rather only Public and Private and objects an inherit from each other, without using classes.

Another issue is the scope, because the global scope is used by default. This issues can be fixed in an elegant fashion using closures:

var closure = function () {
     var sum = 0;
     return {
          add: function (nr) {
               sum += nr;
          getSum: function () {
               return sum;


In the example above, sum is a private property and in theory can only be accessed and modified by the closure function. The interesting part is that the parentheses from the end of the function definition, signify that this function will be immediately  executed and therefore will return the result which is an object. At this point the original function will only exist for serving the return object, encapsulating therefor the private variable.

Although the function has finished execution, through this closure the returned object can still access the variables defined in the function scope, because that was the environment in which it was created.

This becomes even more interesting when a function returns another function:

var counter = function () {
    var counter = 0;
    console.log('in closure');
    return function () {
        console.log('in the anonymous function');
        return ++counter;
var counter1 = counter();

console.log(counter1()); // 1

var counter2 = counter();
console.log(counter2()); // 1
console.log(counter1()); // 2

The output will be:

in closure
in the anonymous function
in closure
in the anonymous function
in the anonymous function

What actually happens is that the first function is executed and returns an anonymous function that can still access the environment in which it was created. In my opinion this is where the confusion between closures and lambda functions comes from, because a function returns another function.

The difference between examples is that in the first one the closure function executes immediately, and in the second example when counter is executed it’s returning a result that is actually a function definition, which in turn can be executed. Of course the second example can be modified to act just like in the first example using parenthesis.


As I said above, the notion of closure in PHP is not as important as in JavaScript.

Considering that lambda functions are available in the language since version 4, closures only appeared with PHP 5.3+.

Because of the block scope nature of PHP, there is a better encapsulation but there is a lot less flexibility compared to JavaScript. Basically in PHP you must specify using the use instruction what will the anonymous function be able to access from the closure scope.

function closure () {
     $c = 0;
     return function ($a) use (&$c) {
          $c += $a;
          echo $a . ', ' . $c . PHP_EOL;

$closure = closure();


Unlike JavaScript, in PHP closures can not return objects, or rather the object can not be bound to the scope in which it was created, unless you send the variables as a reference to the constructor, in which case is not very elegant and I can’t imagine a scenario that would absolutely need closure for this.

Like in the JavaScript examples, instead of parentheses “()” at the end of the function, in PHP to run a function immediately after defining it call_user_func() or call_user_func_array() can be used:

$closure = call_user_func(function () {
    $c = 0;
    return function ($a) use (&$c) {
        $c += $a;
        echo $a . ', ' . $c . PHP_EOL;



Written by Claudiu Persoiu

16 April 2011 at 6:02 PM

The story of JavaScript told by Douglas Crockford la Yahoo!

without comments

Douglas Crockford on JavaScript

As I am a big fan of Douglas Crockford, the inventor of JSON, several weeks back I’ve found a new series of presentations. The presentations took place in 2010 and can be found on the YUI blog dedicated page:

Why am I a Crockford fan? There were 3 thinks that surprised me on his first presentation I’ve seen:

  • he argued fiercely that JavaScript has good parts, but they are not understood,
  • said that JavaScript is a functional language, and as such should be taken in order to discover its beauty,
  • he was one of the few to write a true programming book for JavaScript and not just a collection of special effects like the majority did at the time.

The series “Crockford on JavaScript” at Yahoo!, is not exactly new but very topical.

What is different about this presentations is that there not completely focused on syntax, language and “good parts”, but rather on the overview picture, all the story of the language, including the storys of the languages that influenced it.

The presentations are quite long, over an hour each, but very interesting in my opinion, especially if you’re a fan of computer history.

Part Three can be a bit more difficult because there are some notions that may seem quite bizarre. But once you get familiar with them, many other things become more clear.

Written by Claudiu Persoiu

9 April 2011 at 2:55 PM

Posted in JavaScript

Tagged with ,

ssh key based authentication

without comments

The ssh key based authentication is useful when you don’t want to type the password each time. Also is useful when for instance sshfs is used and mounting takes place without entering a password.

The end result should do login with the following command:

$ ssh work


In Ubuntu the server installation is done with:

$ sudo apt-get install ssh

For other distributions the packege is usually called ssh or OpenSSH.

On server-side you must activate the public key authentication in the sshd_config file:


PubkeyAuthentication yes


On client-side the public/private key pair must be generate:

$ ssh-keygen -t rsa -b 1024

Where the type of the key is rsa and 1024 is the size. Bigger is safer.

The public key must be copied on the server using the following command:

$ ssh-copy-id -i ~/.ssh/id_rsa user@

The -i option and key path are optional, if there was generated a single key on the client in ~/.ssh directory that one will be used as default.

Right now it should work to login using the next command without prompting for password:

$ ssh user@


The last step is creating an alias, in this case it will be called “work”.

You must make a config file in the ~/.ssh directory. The file must have 600 rights, that is reading and writing only for owner.

$ cd ~/.ssh
$ touch config
$ chmod 600 ~/.ssh/config

In this file aliases will be set:

Host work
User user
IdentityFile ~/.ssh/id_rsa

At this step authentication to the previously defined host can be made with the command:

$ ssh work

To learn more about ssh aliases checkout the manual:

$ man ssh_config

Written by Claudiu Persoiu

5 April 2011 at 8:35 PM

Posted in Diverse,Linux-Unix

Tagged with