El seminario es teórico-práctico y será impartido por Uriel Lizama (autor de Perl en Español) y su servidor. El principal objetivo es presentar una introducción completa y amena al lenguaje, así como proveer de las herramientas y técnicas necesarias para comenzar a desarrollar aplicaciones de uso múltiple y con esto brindarte la confianza de mezclar dichos conocimientos con alguna otra tecnología.

La información completa del seminario, datos, costos y temario se encuentran en la haciendo click a la imagen que aparece en la parte de arriba.

Saludos.

Let's see where to start... First of all, and maybe the most important and noteworthy event is.... that I'm getting married next year!. Yeah... after all, life with Dafne is all fun and nifty. A very productive, interesting and learning experience was acquired by those seven years of amazing relationship that needed to take us to a different landscape, a different challenge and of course, a whole different adventure. So... about that, everything is going smooth; planning, wishing and why not? dreaming.

On the other hand, I've been very busy (fortunately) at work. I'm getting more involved in it day by day, improving certain aspects/components of the project, proposing design ideas and best practices and learning all about the business within.

However, my personal projects didn't get my attention appropriately, they were set on-hold for a very big period of time, but this year (yeah.... right), hopefully, I will continue where I was left.

In fact... I've been working in other projects, mostly related to my work. I wrote a nice JDBC framework (Java) based mostly on Spring's JDBC model, integrating some design patterns like Abstract Factory, Factory method, Template pattern and Façade.

What about Net::RMI? Well... fortunately it is almost finished. Implementation is done, testing is almost done and the only thing left is documentation. Yeah, I need to document every user-land class and write more examples for it. I really hope to put it online very soon, so it will be available through CPAN.

Since I tend to procrastinate (often)... my mind likes to put challenges on me. Last time I was thinking about the idea of writing a series of small articles about design pattern implementations, in at least, the languages I like (ex. Perl and Java). Considering something like drawbacks, pros, implementation issues, design overview and of course: code. All of this, with my very very humble point of view and sense of "where is this useful".

At the end, we have a whole year in front of us again, I will try to make a good use of it, and, putting all my efforts, I'll try to make all those promises and wishes become true.

Until then.... cya.

A week ago, I just gave a speech about Unix Systems Programming, Chapter 3 - Working with files for the Open Source Community at work. It was practically a two-hour technical discussion on how a Unix-like system sees/handles files and a general overview of syscalls, user-level calls and other topics like the multipurpose fcntl syscall and memory mapped I/O. It was quite fun.

The other side of the story is about Net::RMI, my pure-Perl Remote Method Invocation implementation. Yes, the project is going quite slow, but the design and implementation is near to its final release. While coding the first version of the API, I discovered some design flaws that made me rethink the way the server part was doing its job and also rethink the request-response interchange between the proxy object and the server object.

Here's the UML diagram for the second draft:

As you can see, there are several changes to the API compared to the new version, new classes and a whole new idea on how stuff works internally, In the end, for the user it needs to be transparent.

There's a bad symbol usage in the diagram, the prmiregistry, since this is a class diagram and prmiregistry is not a class, is an independent daemon that waits for requests from the Net::RMI::Registry class. But I wanted to use it to remember that Net::RMI::Registry depends on that process.

Well, we will see what happens, I really hope to finish this stuff as fast as I can, provide a complete test suite and some code examples for the public release.

Until then, have fun.

Work has been tough, I've been doing several stuff including some speeches, courses and like always... code. In my free time, I have been working on the Net::RMI Perl module, that it is going slow, but going.

On the other hand, I have been helping the guys of Perl en Español to offer some interfactive tutorials about Perl via IRC. The first session of the first tutorial was a success, we had more people than expected and still looking forward for more.

Nevertheless, while preparing and checking the first tutorial contents with Uriel, the owner of Perl en Español, I wrote a small irc bot for the channel, an irc bot that executes perl code in a secure and resource-limited enviroment, that will help the interactive tutorials. However, that bot was written for a very specific task, and I didn't really like it, so, I changed that bot to become a pluggable one.

p5bot is written entirely in Perl, using an Event-Driven programming style thanks to the power of POE. You can use it anywhere, anytime, for any needs. You can add any plugin you want to perform whatever specific task. Adding (writing) plugins is very easy, you just need to follow some conventions ( ex. inheriting from Plugin.pm), or you can run more tasks in a secure enviroment (inheriting from TaskRunner.pm).

You can get the source code via svn:

svn co http://sesshoumaru.homeunix.net/svn/p5bot

or check the src code from svnweb.

By the way, congratulations Uriel for providing the first interactive tutorial about "Perl Basics". More tutorials are in the way, check the information and schedules at Perl en Español.

The current status of Net::RMI is actually good, I'm writting the Net::RMI::Registry and the prmiregistry process server, which will handle all the object activation and registration.

Anyways... yesterday while reading Perl en Español I found a post about a small Perl contest. This contest tests your parsing skills ( in a small scale ), what you need to do is to parse a certain file with a given format, in this case a .srt file, which is a movie subtitiles file format.

The program accepts a filename ( the srt file ) and an amount of time to be added/substracted to each dialog. The fun part is that you cannot use any of the subtitle parsing modules from CPAN and that you need to produce a short/clean code. The output will be sent to STDOUT with the same format as the input file with each dialog modified.

For Spanish readers, here's the post, you can read all the details from there.

Here's my solution (the post has also my solution).

Nice eh? well, laziness is not always that bad, Have fun!.

Anyways, what is RPC? Without going into too much details, RPC is a client-server protocol that allows an application to call/invoke a remote function that is/isn't in the same host, giving us the illusion that it was a mere local function call.

When speaking in the Object Oriented lingo, normally this is also known as Remote Method Invocation, but isn't this a bit too much to worry about? what about all the networking layer behind this? what about all the data marshaling/serialization behind this? what about error handling and reliability?. Well, most of the existent libraries for different languages deal with all of these issues, say CORBA for the C++ part ( can be used in more languages ), Pyro at Python's side and Java and its RMI library, in which this module is mostly based ( the protocol ).

The model is easy, let's use the following diagram and explain it quickly :

The flow of a Net::RMI application looks like this:
First of all, we need to create our RemoteClass class, that will have all the implementation of the methods that are going to be called remotely, but how are we supposed to do this in Perl? Well, we're going to use one of the Perl's darker features, named subroutine attributes, like this:

package RemoteClass;
sub foo : remote {
   # here goes the implementation...
   # and other cool stuff
}
1;

We have our implementation class ready, now what? Now, we need to play with Net::RMI::Server class, how? easy again, we just need to create a Server class that will inherit all the functionality from Net::RMI::Server, and inside it create the implementation class objects in order to register them into the prmiregistry. Erm....., how? using one of the methods in Net::RMI::Registry for registering objects. We have all our objects registered, now, we need to fire up the server calling the start() method and start waiting for requests.

That's all about the Server part, what about the registry? we said before that we needed to register objects into a registry, what does that mean? the prmiregistry is a process that we need to run in order to map objects to their host/port and interface information (like a nameserver), so the client will be able to fetch remote objects. The Net::RMI::Registry class provides the interface to talk to the registry process.

Now, in the client side, in order to use remote objects we need to lookup for them, where? from the registry, using the Net::RMI::Registry->lookup() method, passing an URI like this: prmi://host:port/obj_name, if obj_name exists, it will return a Net::RMI::Client object with all the information needed to invoke methods from the implementation class.
What is this Net::RMI::Client object thing? This is a proxy object, that is, provides the interface to the implementation class that will make us think we're invoking those methods locally, but behind the scenes, it has all the machinery necessary to pass information to the server object and to parse the response from it (parameters serialization/marshalling, all the socket stuff, etc).

If everything went alright, we can now invoke any of the methods declared as "remote" in our implementation class, without worrying much about the details.

What about reliability and error handling? Good question, I will leave out those topics for another post.

I hope I can finish the first working version soon, so my examples can be using code instead of tons of empty words, because at the end, we learn a lot by looking at code.

But why JAWS? Why in PHP? Well... I have a good reason, I swear it!. First of all because it was initially wrote from scratch by my good friend Jonathan (ion) Hernández, a mexican web designer and PHP developer, one of the good ones ( and that's hard to say, because saying "good" and "PHP" doesn't match at all, but I haven't been able to convince him to join to the right side ). JAWS is a mexican project, it has a growing and wonderful team composed by some brilliant developers around the world ( I like to praise, I can't help it ). And my final point is.... I liked the project itself, looks cool.

Now... what happened all this time? lots of things, most of them great as far as I remember. I will list some of them in non particular order:

• I finished school, at last! Bachelor in Computer Engineering
• I'm not working for EL INFORMADOR newspaper anymore, I quit on Dec, 2005
• I joined IBM Mexico on Jan, 2006
• I have more time now to work on my personal stuff ( projects, my time, personal activities )
• I started to work in my Net::RMI module as a personal project, which I will be talking about in my next post I think

and those are practically the most interesting events that happened while I was away.

Anyways, it's kind of late and I need to work today, I just wanted to write a bit.