http://conferences.yapceurope.org/ipw2009/news/422

Perl.It is trying to organize, around the Italian Perl Workshop 2009, a day devoted to Moose with Dave Rolsky. All the details are available here:

http://conferences.yapceurope.org/ipw2009/news/422

Da oggi sono ufficialmente aperti iscrizioni e call for paper per l'edizione 2009 (la 5a) dell'Italian Perl Workshop. L'evento si terrà a Pisa, presso l'Area di Ricerca del CNR, che è sponsor di questa edizione dell'evento.

Lo scorso anno si sono registrati numeri piuttosto interessanti per un workshop: oltre 30 talk (2 tracce per 2 giorni), 120 partecipanti, 20 sponsor, ospiti internazionali del calibro di Marcus Ramberg, Matt Trout, Tim Bunce e Rafael Garcia Suarez.

Quest'anno si punta a fare ancora meglio. Pertanto, il mio suggerimento è di non mancare assolutamente. Cliccate qui per visitare il sito del workshop

The project already has something which actually works, but which needs to be polished. If you can and want to help, take a look at the web site!

Italian: per gli italiani, qui c'è un articolo in merito.

Pocket Perl
Stefano Rodighiero
Apogeo, 2008
ISBN: 978-88-503-2778-2
€ 7.90

Rating: 4.5/5

Pocket Perl ha due virtù immediatamente riconoscibili: il prezzo contenuto ed il piccolo formato. Quest'ultima caratteristica fornisce al novizio di Perl che si accinge alla lettura un'idea di "snellezza" che lo spinge a cimentarsi nell'impresa, a differenza di un testo di grosse dimensioni che potrebbe scoraggiare qualcuno.

Va bene, siamo solo alle apparenze per ora. Il contenuto sarà ciò che ci si aspetta, e cioè una guida chiara, sufficientemente sintetica ma al contempo approfondita al punto giusto, per imparare Perl? Andiamo dunque ad indagare.

Intelligentemente, il libro non parte subito parlando di Perl come linguaggio: la prima cosa che assomiglia ad un "Hello, World" è infatti a pagina 10 (e si tratta solo di un test per verificare che l'installazione sia funzionante, l'"Hello World" vero è a pagina 15). Prima di ciò viene sinteticamente indicato come installare l'interprete, e soprattutto vengono messi in evidenza i punti di forza di Perl non relativi al linguaggio in sé. Anzitutto Rodighiero parla di CPAN, l'immenso archivio di moduli Perl che è opportuno che ogni sviluppatore o aspirante tale impari ad utilizzare sin dall'inizio; a questo scopo vengono fornite preziose indicazioni su come configurare CPAN, scaricare ed installare i moduli. Il secondo punto di forza svelato è la community: è altamente probabile che attorno a Perl ruoti una delle più interessanti comunità di sviluppatori nel mondo dei linguaggi di programmazione, e qui ne vengono indicati i principali "punti di ingresso" a livello italiano ed internazionale. Infine, viene presentato l'immenso mondo della documentazione fornita con l'interprete, vera e propria colonna portante della distribuzione.

La trattazione relativa agli aspetti del linguaggio, pur trovandoci di fronte ad un libro tascabile, è alquanto articolata e rigorosa: si spazia dalle basi fino ad oggetti, regular expression e persino vere e proprie "chicche" come la trasformata di Schwartz. Il capitolo 8, inoltre, fornisce un'interessante panoramica su quanto disponibile per quanto riguarda programmazione web, GUI, ed altre interazioni della propria applicazione con il mondo esterno - chiaramente, in questo caso, viene solo scalfita la superficie dei singoli argomenti.

I contenuti sono piuttosto aggiornati, pertanto tutte le principali caratteristiche della versione 5.10 di perl vengono trattate. È un peccato che alcune tecnologie, come Moose (qui comunque accennato) e DBIx::Class (al posto del quale qui viene proposto il più rudimentale Class::DBI) si siano consolidate solo di recente e quindi non ci sia stata la chance di trattarle: andate dunque ad esplorarle su CPAN!

Nel complesso, a mio avviso Pocket Perl copre una precedente lacuna nel panorama italiano relativo a Perl, che era la mancanza di un testo "introduttivo ma non solo", chiaro e ben scritto, una guida che partisse dalle basi ma che fosse al contempo in grado di mostrare gli aspetti più interessanti del linguaggio, avvicinando nuovi programmatori a Perl. A livello di "mancanze", per quanto mi riguarda ce n'è solo una: il libro rimanda alla documentazione fornita con l'interprete quanto riguarda la gestione di stringhe Unicode. Considerata l'importanza dell'argomento ed il fatto che la documentazione in linea è spesso nebulosa, sarebbe forse stato opportuno dedicarvi una sezione.

The backend of MCImageManger is in PHP or .NET: I decided to stick with the PHP version, as my web server is on Unix, but still had to find out how to integrate it with my web application (which is in Perl) making sure only logged in users would be allowed to upload files. There are code examples for JSP, ASP Classic and several PHP configurations, but nothing related to Perl. So, I ported the authentication script - it was easy enough and here's the result.

If you use Perl and you want to integrate authentication with the one of your system, you need to use ExternalAuthenticator in order to share sessions between Perl and PHP/.NET. It's not that difficult: since the Perl ExternalAuthenticator script is not provided, you can find one I wrote myself here.

MCImageManager configuration

File to edit is likely ''config.php''. If you use ''Web.config'', these instructions still apply.
First of all, you need to enable the ''ExternalAuthenticator'':

$mcImageManagerConfig['authenticator'] = "ExternalAuthenticator";

Scroll down a bit and you'll find the relevant configuration options for ''ExternalAuthenticator'':

// ExternalAuthenticator config
$mcImageManagerConfig['ExternalAuthenticator.external_auth_url'] = "/manage/tinymce_auth.pl";
$mcImageManagerConfig['ExternalAuthenticator.secret_key'] = "TheKey";

tinymce_auth.pl

Put this file at the location you specified in ''config.php''. You need to edit some parth: the secret key and, of course, the part which verifies the user is authenticated.

#!/usr/bin/perl

use strict;
use warnings;

use CGI::Carp qw/fatalsToBrowser/;
use CGI::Simple;
use CGI::Session;
use HTML::Entities;
use Digest::MD5 qw/md5_hex/;

# Must match the one in config.php
my $secretKey = "TheKey";

my $q = CGI::Simple->new();
print $q->header(
    -type   => 'text/html; charset=UTF-8',
);

my $session = CGI::Session->new();

# See if session-id is OK
if ( !$session->param('idadmin') =~ /^\d+$/ ) {
     print "Not logged in";
     exit;
}

# Come configuration variables can be overridden here
my %configuration = (
    #'filesystem.rootpath'   => '/some/path',
    #'filesystem.path'       => '/some/path',
);

my $data = '';
for my $cv (values %configuration) {
    $data .= $cv;
}
my $key = md5_hex($data . $secretKey);

print '<html>';
print '<body onload="document.forms[0].submit();">';
print '<form method="post" action="' . encode_entities($q->param('return_url')) . '">';
print '<input type="hidden" name="key" value="'. encode_entities($key) . '" />';
for my $ck (keys %configuration) {
     my $enc_ck = $ck; $enc_ck =~ s/\./_/g;
     print '<input type="hidden" name="'
        . encode_entities($enc_ck)
        . '" value="'
        . encode_entities($configuration{$ck})
        . '" />'
    ;
}
print '</form></body></html>';

This work is free software, by , and is provided as-is. If you need support, ask in the TinyMCE forums.

Sometimes things happen when few are still left to believe in them, nevertheless they are able to bring new enthusiasm and life to projects which seemed to be sentenced to a never ending gestational status. OK, I'm now going to come out of this "Barack Obama mode", but I hope I gave an idea of how much March 17, 2009, the date of the release of Parrot 1.0.0 is important for the Perl community (and not just for it).

Anyone who's got something to with Perl likely knows what Parrot is, but this moment deserves a brief refreshing about its main features. First of all, it's a virtual machine which aims at becoming the virtual machine. Even though its development started out from the Perl community, the goal is that other dynamic languages should be able - or even want - to use it as well, as Parrot will grant superior performance.

For other technical information, please read the Parrot Wikipedia page, as I'd like to write something about the second reason for which Parrot is important. It's maturation is fundamental to give a boost to Perl 6 development, in order to reach the much awaited first major release of our favourite language, an event we've been waiting for years: yt's current implementation, Rakudo, is being developed upon Parrot.

Many more steps still have to be performed, and maybe many folks will continue to state, as a joke or seriously, that Perl 6 will never see the light. However, as Parrot did, Perl 6 could surprise you as well.

Click here to read this review in Italian language.

Learning Perl (5th edition)
Randal L. Schwartz, Tom Phoenix & brian d foy
O'Reilly Media, 2008
ISBN: 9780596520106
US$ 39.99 (printed) - US$ 31.99 (electronic)

Rating: 4.5/5

Perl is a very flexible language. It has the most complex grammar you can find around,
and a context-dependent semantic, and this makes perl an easy and yet powerful scripting language. The 5th edition of Learning Perl is just about how to write scripts with it. It wonʼt teach you how to write huge and complex software or how to optimize your code to make it fast and yet extensible. After all, this book is just about learning the language. The big work made by Schwartz and co. was to write a book that lets you feel the extremely high level of flexibility you get from the perl syntax. The book is full of examples, and itʼs common to find a way to solve a given problem, just to read how it can be solved with fewer lines of code or in a faster way respect of a previous solution. The book also highlights the most famous perl features. Theyʼre text and list processing tools, such as regular expressions and sort routines. After the first chapters explaining basic language features like numbers, strings, arrays and hashes manipulation, three chapters are dedicated to regular expressions: how to write and understand them, how to use them to match text, and how to use them to replace text. Also, a whole chapter is dedicated to methods and techniques to sort arrays and hashes. The second part of the book is about manipulating files, processes, and other things needed for administrative purpose, a field where perl scripts are used very often. The other two books of the series, Intermediate Perl, and Advanced Perl, complete this book, covering things that you donʼt find here. If you donʼt know the language and want to learn it, or if you know it briefly and want to improve your basic knowledge, this is the right book for you.

British online technical newspaper The Register has this very interesting article which shows statistics about new open source projects born in 2008. Numbers are provided by license tracker Black Duck Software

C is (unsurprisingly) first: 47% of open source projects born in 2008 use it.

What's most interesting, however, is that Perl is the first of the dynamic languages (excluding client-side scripting ones, i.e. JavaScript): 18% of new projects chose it (PHP is stuck at 11% and Ruby at 6%). Anybody who was saying Perl was obsolete now has his answer.

• Link your original tagger(s), and list these rules on your blog.
• Share seven facts about yourself in the post - some random, some weird.
• Tag seven people at the end of your post by leaving their names and the links to their blogs.
• Let them know they've been tagged by leaving a comment on their blogs and/or other mean (Twitter, Facebook ...).

So, some facts about me:

• I work as computer programmer. It isn't always great, but I think I'm blessed because I have the opportunity do do what I like every single day.
• I live in Maniago, which is located in North-Eastern Italy. In the past I thought I didn't like this place, but after seeing a lot of places in the world I'm now confident this is among the best where to stay. I maintain a web forum related to my town.
• I play the bass guitar in a brit rock band (the Gin Tonics), but don't really know much about it as I never attended a single lesson regarding bass or music in general.
• I believe "fair play" is fundamental in every aspect of life.
• I'm often worried for many things, but I rarely admit it if asked.
• I haven't got a best friend and I consider myself lucky for this, as there is more than one person who I regard as a best friend.
• Should I ever need to escape somewhere to stay for some time on my own, that place would be the Orkney Islands.

I know the rules want me to tag seven people, but the ones who come to my mind don't have a blog - so I have to skip this.part of the game. ;-) If you're reading this, I'd be happy if you consider yourself tagged and play.

Here's the screenshot of my IRC session of tonight. I'm lordarthas, see how many ghosts of me are in there because of disconnections. Fun, uh?

The workshop was held on Saturday, so I decided to stay the entire week-end: even though I visited London a lot of times in the past, there's always something to see and do there. The event took place at the New Cavendish Campus of the University of Westminster, which is a quite central location, just opposite the British Telecom tower (one of London skyline's main fixtures) and conveniently near Great Portland Street tube station. Once I got there, I realized what the organizers already stated: the organization was quite basic. The was no real registration process, but just a list where to tick your name and a girl giving out badges - which is more than enough, anyway. There was no wi-fi access (there were networks, but they belonged to University of Westminster and required login credentials we didn't have), but since I didn't even bring my laptop to the UK it was hardly a problem. And, hey, attending the workshop was free of charge.

The conference was split in four tracks, and therefore in four rooms: the biggest one was quite nice, holding approximately 250 people and with quite comfortable seats; also the second one was big enough, while the other two were actually classrooms and therefore smaller. This was actually fine, as one of these last 2 was used for 3-hours tutorials (so it was far from being full) and the other one was for supposedly more specialist talks, even though it was very full at times.

The workshop kicked off with a talk about London.pm given out by its historical leader, Dave Cross: that was very fun and entertaining! Next I followed an introduction to 10 CPAN modules by Leon Brocard, and I found there are really some modules which would be useful for me and of which I didn't know about (I've always been sure of that, CPAN is so huge...). The two talks by Matt Trout I listened to were among my favourites: he's very passionate in his explanation, no matter whether he speaks about something useful (see DBIx::Class+Postgres) or about something which is almost just a mental exercise (such see Acme::Yorkshire).

Mike Whitaker give out two talks about Moose, one basic and one intermediate: it was really nice to hear some details about such a great object oriented framework - Mike get ready, we'll try to bring you to Italy for our workshop. :-) Andy Wardley's talk was about Badger, a toolkit which can be seen as sort of "lightweight Moose" and upon which Andy built many modules which abstract a lot of functionality provided by Perl and by other modules; also Template Toolkit 3, a product of Andy himself, is Badger-based and should be soon on CPAN (I can't wait, I'm an avid TT2 user). Hakim Cassimally's Functional Pearls was the greatest last talk a workshop could have had: if you've never heard about programmable semicolons, well take a look. One of the lightning talks was pure genius: David Leadbeater created a Wikipedia summary system which had a method of querying it using DNS TEXT records (think about caching for free...)!!

All in all, the workshop was great. As you might have already guessed, the mean level was quite high, with some impressive peaks. Even though there were 4 tracks, there was not a basic one to speak of, which makes the workshop very interesting for Perl programmers but, of course, a little less appealing for folks trying to learn the language. After all this food for thought, there was a need for food for the body (not to mention beer), and here came a big surprise: the workshop organization reserved an entire pub and food and beers were served free of charge for all the evening! Speaking with Mark Keating, one of the organization leaders, it turned out he wanted people to finally associate free software with free beer, not the opposite as we've always learned. What a great idea!!!

So, for all of this I would like to thank all London.pm and other Perl Mongers who organized this event, and all the sponsors who made this possible (click here to see who they are).

http://www.cattlegrid.info/files/italy_perl_success_story.pdf

(function(){
    dojo.provide("cryo.Tree");
    dojo.provide("cryo.ForestStoreModel");

    dojo.require("dijit.Tree");
    
    dojo.declare("cryo.ForestStoreModel", dijit.tree.ForestStoreModel, {
        // class definition
    });

    dojo.declare("cryo.Tree", dijit.Tree, {
        // class definition
    });
})();

just needs to become as follows to work with the Dojo cross-domain loader:

dojo._xdResourceLoaded(function(){ return {
    depends: [
        ["provide", "cryo.Tree"],
        ["provide", "cryo.ForestStoreModel"],
        ["require", "dijit.Tree"]
    ],
    defineResource: function(dojo) {
    
    dojo.provide("cryo.Tree");
    dojo.provide("cryo.ForestStoreModel");

    dojo.require("dijit.Tree");
    dojo.declare("cryo.ForestStoreModel", dijit.tree.ForestStoreModel, {
        // class definition
    });

    dojo.declare("cryo.Tree", dijit.Tree, {
        // class definition
    });
})();

Easy enough, but what usually happens is that you work with non-xd files while developing, while using the cross-domain features in production. Or maybe the opposite. Or something similar. Anyhow, in this case you most likely don't want to maintain two copies of the same JavaScript module where only header and footer are different. For sure I don't, so I wrote a small Perl script which converts non-xd modules to xd-enabled ones automatically by performing the following tasks:

• It parses dojo.require and dojo.provide statements in order to create the xd header.
• It substitutes the header with an xd one containing the information obtained in the parsing operation.
• It substitutes the closing parentheses with others which match the new header.

OK, I know, there's also the Dojo Build System, but I didn't want to install Ant and a ton of Java-related dependencies for a task which requires 20 lines of code.

This script is a quick hack so it has caveats:

• It's a quickly (and therefore poorly) coded dirty hack.
• Read the code before using it and edit it if needed.
• It's supposed to work if the code is formatted a bit differently than the examples above, but there's no guarantee - I just tried out some variations.
• It produces xd code only suitable for Dojo 1.2.0 (but changing it for 1.1.1 is trivial)

On the other hand, using it makes no harm to your existing code: it will either work and produce (possibly broken) output files, or produce no files at all. So, I would say it is safe to try it.

Usage:

make_xd.pl file1.js file2.js ... filen.js

You can pass one or more files on the command line: the script will produce filename.xd.js starting from filename.js, which is left untouched.

Click here to download the script.

If you improve this script, please let me know.

Mastering Dojo
Rawld Fill, Craig Riecke, Alex Russell
Pragmatic Bookshelf, 2008
ISBN: 978-1-934356-11-1
US$ 38.95

Rating: 4/5 (very good)

The Dojo toolkit is, arguably, the most advanced JavaScript framework available today. jQuery might be designed equally well and be more compact, but it lacks advanced and ready to use GUI components. Ext JS might provide a ton of colourful widgets, but it lacks the implementation and API elegance of Dojo, not to mention it features a licensing system which is awkward enough to turn away any sane open source developer.

Dojo still has, however, one major drawback: the documentation is sparse at best, and completely missing in some areas. The API reference is not rich enough, and parts of the online free Dojo Book are outdated; the best option for programmers is often to skim directly through the well-commented source code and through the accurately done test suites. Dojo is a big and complex project, so it will take a while for the community to document it properly; in the meanwhile, the excellent forums, Dojo Campus and the IRC channel provide an excellent resource. Printed books also come to the rescue of programmers who want to use Dojo: being the project so interesting, there are quite a lot of titles available, and Mastering Dojo ranks among the most up-to-date and interesting ones.

Despite its name, this book is targeted to the programmer who doesn't yet use Dojo, as opposed to the Dojo programmer who wants to dig more deeply into the framework details. It, however, spans a wide range of Dojo-related topics: from the basics to the most advanced widgets (trees, grids) and other areas (internationalisation, extension of the framework). Basically, you just need to know JavaScript to read this book: even though Dojo also features an HTML declarative syntax, to obtain something useful out of the framework you really need to be comfortable with JavaScript.

Every chapter is devoted to a topic, and is made of an introduction followed by well-made examples. It doesn't provide a reference: you learn the main things, and then if you want to know all the API you'll want to find more documentation elsewhere. What it provides is however what you need if you're new to Dojo: a description of what you can do and some examples on how to do it - so that basically you understand that you'll be able to use Dojo to create a modern web application in and easy (although, as all computer programming tasks, not always straightforward) way.

Even though absolutely not a reference, Mastering Dojo can be used as such to some extent: the sections about events, DOM introspection and editing, classes and data are, for instance, enough in-depth to provide reference for most of the tasks a developer needs to perform. Others, such as the Grid and the Tree, are more like introductions to those advanced widgets, but are nevertheless very appreciated as it's not easy (if at all possible) to find coherent documentation elsewhere regarding them.

All in all, if you plan to use Dojo because to have to create a serious web application, this book is an excellent starting point, and will likely remain useful also when your knowledge of the framework has grown.

CAPTCHAs" have been somewhat a solution for some years. Requiring you to type a word which is in a picture, they should be able to tell if you're a human or a piece of software. First CAPTCHAs were simple and easy to ready, but soon OCR software was able to read them too; so they became more and more complex, featuring noise, distorted words, fancy colours, etc. The art of designing a CAPTCHA is fairly simple: it should be unreadable by a machine and as simple as possible to read for a human, as you surely don't want anybody to be unable to use your web site no matter how stupid they might be because they are unable to figure out a few letters on an image.

Since it's a bit of a pain to always have to change and improve your CAPTCHA images in order to keep spammers outside, I recently began exploring reCAPTCHA.

This article is about reCAPTCHA and is usage with Perl both directly with Captcha::reCAPTCHA and with HTML::FormFu.