puntoblogspot

Lisp and the web (probably part 1)

2012-01-28T23:46:00.004Z

I've tried some lisp frameworks with different intensities and approaches, without settling with anyone of those. Just looking around.

As a first approach, I'm going for the minimalist frameworks. Caveman (on top of Clack), and RESTAS.

My first experience is with caveman, as I want something really simple, and known. Not that I've worked with Sinatra/Rack nor Flask/WSGI, but at least, the architecture is more well known that with other fw like weblocks or RESTAS.

With Toni, we've been hacking a bit our way to do a super simple micro app. And we stumbled upon a few WTFs, or undocumented Caveman spots, or just blockers for us due to our lisp newbieness. Luckily, most of them are solved now :)

In GETs, (getf params :id) work, but in post POSTs, the symbols are presented in a different format (getf params :|id|). As davazp pointed, this probably has some problems issues with CL never garbage collecting those interned symbols.
clsql:*default-database*. clsql will use *default-database* database handler if you dont's specify any. This makes using clack's middleware for clsql transparent from caveman apps.
Getting caveman through quicklisp threw some erros during installation. Installing newer version of sbcl just solved it. (http://comments.gmane.org/gmane.lisp.steel-bank.announce/111)

     * new feature: SB-EXT:VALID-TYPE-SPECIFIER-P returns whether a given type
specifier is valid where "valid" basically means "would be accepted as
second argument of TYPEP".

cl-project doesn't create the link in ~/quickload/local-projects on new generated projects . If you create your projects under ~/quickload/local-projects, quicklisp will be able to quickload it, but if you put it somewhere else, you should create a link to your project.

I'm now struggling with form-builder, and widgets (no docs nor examples at all). We'll see how it goes.

before forgetting them

2012-01-28T11:58:00.000Z

A couple of amazing links for the weekend

stylish ruby

2012-01-25T00:45:00.000Z

Here you have a couple of style guides related to ruby, rails, and some tips on functional programming and a few not-so-trivial techniques like currying, TCO, or just using immutable structures.

Apparently, all things explained in all those guides are obvious, or just a matter of taste, but you better read those guides a few times each to make those rules stick in your head, just to be sure :)

First, a guide from bbastov (of emacs prelude fame), that's already in github and forked more than a hundred times, so we could say it's a community ruby style guide.

Second, another bbastov's guide, this time on Rails 3.

And last but not least, slides of a friend of a friend's workshop on Functional Ruby. Really nice, and full of nice tricks that deserve to be read and understood.

That's all for now. Back to hacking

XML < JSON < SEXPS

2012-01-20T18:53:00.007Z

Step by step, I keep getting more and more of what's lisp about.

Not just the syntax (huh?) or the core lib, but idioms, design decisions, and the vision.

One of the mottos of Lisp is the famous 'code is data, and data is code'.

For me, that's not 100% clear yet, but I get more insights every day.

One implication of this is when you look at s-exps and see them as a datastructure, not as code. That's the macro point of view. If you want to know more about macros, I can only recommend you Paul Graham's OnLisp, and Doug Hoyte's Let Over Lambda. I'm now reading through the latter and I find it a perfect companion for OnLisp.

The other direction is 'data is code'. To exemplify this side, here are a couple of links that really get to the point of this (at least one part of the point).

http://irreal.org/blog/?p=398 <= One of a series of posts comparing xml to sexps. Quite long and insightful
http://shinkirou.org/blog/2010/06/s-expressions-the-fat-free-alternative-to-json/ => xml->json->sexps.

Cya

Invincible Perl

2011-12-29T20:20:00.000Z

Have you seen the talk about DoSsing websites just using crafted data on forms (POST)? It's the trending topic of this week.

Well, here you have a couple of links related to this talk and some extra info.

The interesting thing that surprised me (or not so) on that article/talk is that the only language they tested that's not vulnerable to this attack is.... guess what? Perl. Here's the extract of the article:

Julian and Alexander did a great job with checking many programming languages used for web applications for their hash table implementation and hash functions. For all of them they checked, they managed to find a lot of keys mapping to the same output, except for Perl. Perl uses a randomized hash function, i.e. the hash doesn’t only depend on the key, but also on an additional value, that is chosen at startup of the application at random. All other languages also store the query parameters send in an HTTP GET or POST request in an hash table, so that a request with many query parameters all mapping to the same hash value will slowly fill such a hash table, before the first line of code written by the application programmer will be executed. Filling this hash table will usually take several minutes on a decent CPU, so that even a fast web server can be kept busy using a slow connection.

And here you have HN comments

+1 for Perl!

Between offtopic and related here's another nice talk from 28C3 that's having place these days in Berlin.

Git, the stupid content tracker, or not so

2011-12-27T20:18:00.009Z

After roughly a year of using git daily, one has already crossed the "WTF!?" side and now is in the "It's obvious" land.

After getting help from all coworkers I had last year, lots (I mean *LOTS*) of reading, and many moments of "Am I the only one in the world that doesn't get this?", all regular processes go without thinking now, and I know pretty much what is happening under the hood.

Some things are still a bit raw on the edges, but mostly because they aren't used so often (submodules, bisect...), but I digress...

Thing is that using and knowing git gives you extra power, not directly related to versioning code. As Linus said: "git is the stupid content tracker", it manages blobs of bytes.

git grep: Probably faster than grep -ri, and more focused to what you surely want to search. I've already integrated it with emacs, and try to use it more and more, instead of rgrep, or ack.
git ls: great for the kind of find-file-in-project functionality.
git log -Sfoo : Search throughout the history
git log -p : modifications in context
git annex: manage whatever content
using git to deploy: There's capistrano, and puppet, and chef, and... but git can handle it if configured properly. Probably this can end in a mess if you need to trigger many things when deploying. You know, there are hooks and everything, and you cand build your poor-man-capistrano. It's just your choice. But definately for mostly static sites, it's a nice thing to keep in mind.
Not really a git feature, but thanks to magit, or fugitive, you can have a pretty painless integration with your workflow, so it's a win. And you feel safer

Have more tricks? Comment!

It's funny because it's true

2011-12-11T23:46:00.007Z

A couple of hilarious images worth sharing:

Y esto hoy, google ads clavándola...

tramp + shell = win

2011-11-22T23:19:00.004Z

Did you ever notice that tramp is a great piece of elisp? I hope so.

The nice thing I discovered today is that it's highly tighted to the whole system, and if you just m-x shell when you're in a file opened through tramp, it'll open a shell in the remote system.

Super nice.

Creating a simple common lisp application

2011-11-20T13:52:00.010Z

After giving a further look at common lisp (a bit of PAIP, and PCL), I've found a project that can be a nice 1st app for me.

To develop a common lisp app, first you need to set up the environment and choose the toolchain. These have been my decisions. Tips are pretty appreciated.

Requirements

The requirements are the bare minimum for common lisp. I use SBCL myself, and don't know much of the differences between implementations. sbcl works just fine.

Editor

I use emacs 24, with slime, paredit and autocomplete. Use whatever you feel like but notepad. Obviously, emacs is recommended :)

Libs

Use quickload to find and load libraries. It's surprisingly easy and straightforward to use.

Project

quickproject to initialize the project is a nice way to avoid writting bolierplate, and to make sure your project will be loadable through ,load-system.

Tests

I tried a couple of testing packages for common lisp, and decided to go with lisp-unit due to its simplicity and availability in ql repos.

Code repository

The code is being hosted in a private git repo in bitbucket. They give you unlimited public/private (*yes*, private) repos, using git/hg, with issue tracking and all, for free. It seems a nice nice alternative to github. great to host projects in early stage where you don't feel like sharing the code to the world.

That's it for now. There's no public code for the moment... There's nothing to see here :)

change emacs url-browser

2011-11-12T11:11:00.002Z

When you click an url in emacs, it'll open a browser with that url. That's fine.

Problems arise when you have multiple browsers and they fight to be your preferred one. In a coworker's box, it tries to open konqueror (WTF?!).

One way to fix the issue is changing browse-url-browser-function.


(setq browse-url-browser-function 'browse-url-generic
      browse-url-generic-program "chromium-browser")

Not only that, but the nice thing would be that emacs reused a browser if you have one opened (firefox or chrome) and opened a new one (chrome) otherwise.

I've been messing a bit with proced.el to find out how to list external processes programmatically, but had no luck. If I find out how, I 'll modify this post with new info.

If you have related info, please, comment :)

Thanks to Davazp that pointed me to list-system-processes function, I just wrote the code to use an already opened browser to open a given url.

A good quickreference to look for function signature differences between elisp, scheme and cl is here. It helps quite a lot

4 nice bugs

2011-11-08T15:41:00.002Z

One, two, three

Metacircular game of life.W00t!

2011-11-06T20:41:00.004Z

Here are a couple of links on game of life info.

First of all, a game of Life implemented in one line of APL, explained, so you can even try to understand it. Then, a couple of articles on cellular automatas, explaining game of life basics and not-so-basics.

And the really amazing stuff: Metacircular GoL

Introduction to (modern) Perl (course)

2011-10-23T15:36:00.003+01:00

Barcelona Perl Mongers are organizing a 8 hours course on Perl intended for programmers that have no or little experience in Perl. It's not an introductory course to programming.

The course will be on November 5th, at UPC (Barcelona). 25 Euros for the course, and an exclusive T-Shirt.

I'll be there, maybe just listening, or helping answering questions.

More info in: http://barcelonapm.wordpress.com/2011/10/21/curs-dintroduccio-a-perl/

Links about (mostly beautiful) code

2011-10-22T16:05:00.003+01:00

C/C++

Drawing circles in C in and out
Basic regular expression matcher in 30 C lines
From c to c++
C pointer inners by example. (ksplice pointer challenge)

Javascript Patterns

Python

SICP in python

General Bad practices to avoid

What's WRONG with this?

2011-10-22T11:44:00.001+01:00

Can you find it?

I still think Perl

2011-10-14T18:01:00.003+01:00

The other day, a friend asked how to split a string by commas, but only if they aren't inside a tag, say enclosed by '<' and '>'. I tried python, but somehow regexes are so hardwired in my head, that I can't work with languages that do not have regexen so hardwired in their heart.

Here it is. Tiny, but gets the job done. And that's what perl is for. a regex with lookbehind stuffed into split. No problem sir!

steve, the web, and innovation.

2011-10-10T20:55:00.005+01:00

It's been less than a week a genius left us yada yada yada.....

Since last October 5, I've been thinking a lot about Alan Kay and I was waiting to see some references from sites talking about MrJobs to Mr.Kay.

Well, today I've seen it, and this post will be just a kudos to people knowing the real story, that Steve had great qualities, and was visionary in a very bright way, but he didn't invent the future. You know...

But the internetz has gone crazy on this, so I wanted to point out a couple of curiosities I've seen since then.

- First, a HN screenshot I did the 'day of the facts'.
- Then a post talking about Alan Kay, linked from a 'outstanding articles' widget, pairing with Steve.
- Now a great and long post about great things that happened at XEROX PARC, and things Jobs saw there, and how he implemented then in Apple. He didn't invent the mouse, but simplified it (in fact, Xerox didn't invent it either), he didn't invent GUI, but adopted it, and he didn't invent the iPad, but 'implemented' it, in the exact moment there was market for it.

Cya!

Btw, if you wanna know more about Kay and friends, here is another post on this blog with amazing videos, or just check the internetz, or just download pharo/squeak.

Ready, set, Dart!

2011-10-10T09:15:00.004+01:00

Today there's been the first official press info and release of Dart language. A class-based language developed by google.

Features: OOP, class-based, optionally typed, and thought for the web. It seems it'll have a client side debugger. (Hello amber! :p )

Lars Bak has been strongly involved in Dart, and given his smalltalk past life, it's sensible to say that we'll see some familiar things in there.

Today is the first day of AI classes in the standford open course. For the moment, browsing the notes of the first class...

See the flash bar in the top? :)

Emacs 24 is frozen

2011-10-09T23:21:00.003+01:00

Emacs 24 entered the feature freeze state a couple of weeks ago, so it's the moment to install it and start fiddling with its new features (I want to try the editable occur buffer, and some asynchronous goodies for gnus).

There have been a couple of posts in planet emacsen that explain how easy is to install it in debian or ubuntu (natty).

The thing is that I use an older ubuntu version and I had to compile it myself. Not very problematic, but here's the couple of libs that I had to install before being able to compile it. Obviously, you'll need the usual binutils and dev tools. also you'll need these packages.

apt-get install autoconf texinfo libxpm-dev libgif-dev libgtk2.0-dev xserver-xorg-dev xorg-dev libfontconfig-dev libfreetype-dev libxft-dev # probably, not everything is needed, but once you warm up, apt-get is too easy.

Then, just get the code from the repo, and configure install in proper directory:


git clone https://github.com/emacsmirror/emacs.git 
cd emacs
./autogen.sh
./configure --prefix=~/emacs-24
make install

Now you have your emacs in ~/emacs-24/bin/emacs, and hopefully, everything will work from the start. I had to disable a couple of lines in my .emacs file, but just minor things.

Now it's time to try emacs-starter-kit 2.

Is it really that bad? Seems so

2011-10-04T19:39:00.010+01:00

In the last couple of days there's been quite a lot of ranting about overly complex software we have to manage daily. It applies to software we use (super-complex UI and over-featured apps) and software we develop Does it really make sense to deal with so many layers of added complexity to deal with mostly simple (conceptually) problems.

In those texts, they talk about 'old friends' like boost, SDL, Xcode, Objective-C, never-ending-toolchains, and supercomplex interfaces to third party software (APIs, security layers, etc.).

In my opinion, and without having spent as many years as those guys (or commenters at HN) on computers, it's true that the starting barrier to any new environment seems overly complex for the functionality we get. Most of the times, external tools solve deficiences of languages. Being a tool geek myself (probably, I have spent more hours than you trying and configuring window managers and editors), I have the feeling that entering most of new environments is more complex than it should be.

Want to do a rails app? no problem, you just have to handle a few technologies/tools:

ruby, rails, cucumber, rspec, rack, passenger, bundler, rvm, gems, html, js, ajax, css. Then, keeping compatibility with Chrome, firefox, safari, opera and, God forbid, IE.

Not bad, eh?

Well, if you want to write the views in a more confortable way, you can use haml, sass, compass, coffescript, that will compile to their ancestors, and will make you a happier person.

You see? (I hope you get the sarcasm)

Every now and then I think about Dan Ingalls quote:

"An operating system is a collection of things that don't fit into a language. There shouldn't be one"

And drool when thinking about smalltalk.

Bihain de uindou

2011-09-27T23:51:00.004+01:00

Demasiadas veces mirando por su ventana y quedándome en blanco. veo

que algo se mueve ahé dentro, y veo la ventana mirándome, y la veo a

ella mirandome a través de la ventana. A veces, incluso me veo a mi a

través de ella a través de la ventana.

Y aún no sé qué decir (me y le). Y te.

Señalar con el dedo y ver el nombre en verde.

Clicar. Cerrar. Clicar. Cerrar. Y repetir.

Amber language (former jtalk), digging deeper

2011-09-17T13:40:00.010+01:00

Lots of changes have happened in jtalk world since last week.

Jtalk is now Amber. The project has changed its name when the 0.9 release happened. That means that the repo is now different, and the website too.
JQuery bindings have been removed from the system. Now we can access javascript objects directly, and use asJQuery in the same way, so there's no drawback, only the way to deal with jquery is more smalltalkish. Counter new appendToJQuery: 'body' asJQuery works perfectly, so no problem.

Creating functions
If you want to know a bit more on amber, you have to keep in mind that it's a smalltalk, so you can explore everything in your IDE. Let's try to find out a bit more on how the compilation from smalltalk to js works. This will allow us to debug our in a lower level than usual, and find glitches in our codes, or detect where our closure is missing the variables (when interfacing with js, sometimes it's useful to see the whole js code, and make conclusions on js).

Let's create a new class Foo with a method that gets a block (callback) and executes it. Now, to find out how it's compiled, we'll make amber print the compiled source of the method:

(Foo methodDictionary at: 'get:') fn compiledSource "print it".

If we print it, the result will be the js source of the method

You can try variations like returning explicit values, try to pass instVars to the closure, and see what is the translation to js. This helps sometimes to find out your way.

Can I inspect?
Inspector is there, but for the moment, it's in very early stage.

Debugger

Debugger is also there, also in early development. You can see the stacktrace, and inspect the methods, but not changing values and so.

NodeJS

We can use amber for the server side, running the generated javascript on node.js. Due to the hability of Amber to interoperate with plain js, we can use a shitload of libraries from amber. Here follow a couple of examples of amber on node.js

Server

Nicolas Petton wrote a fileserver meant to be used in the node.js side. This allows us to commit changes to our files transparently without the need of webdav,python(see last post), or any external server. It's Amber all way down.

The usage is fairly easy. Just cd to the root amber directory and run ./bin/server, that will run ./server/FileServer* things.

IRCBot
Trying the node.js part of amber, we can try to build a small program, and as no programming language is complete unless it has a IRC bot in it, let's solve this issue:) Btw, I hacked a couple of emacs functions to deal with st files a bit better.

can your editor^W OS do this?

2011-09-11T22:44:00.003+01:00

Here is an emacs feature that it's hard to believe until you see it working.

m-x butterfly

Unbelievable, no?

Well, let's link this amazing functionality to the gesturing strokes-mode.

m-x strokes-mode
m-x strokes-global-set-stroke

Then, click in the buffer that appeared, and draw(drag) a circle with your mouse. when you end, press the right button.

now emacs will ask you for a command. Now it's the butterfly turn. write 'butterfly'.

Ok, now you have configured and amazing mouse gesture that will flip bits on your hard drive only by reproducing the figure (circle) you just did before.

in any buffer, press shift and draw a circle dragging the second mouse button (mouse wheel probably).

ENJOY!

PS: I've changed the shortcut from the second button to first, and now I can use my tablet to manage emacs. And here's another great thing of the ubiquity of emacs: You can use it to manage things related to irc,jabber,mail,text editing, playlist managing and even pdf reading. neat.

emacs and smalltalk, a bit closer

2011-09-09T01:09:00.003+01:00

Today I've been hacking around with jtalk. Implementing something for the node.js backend means that probably you'll be using your editor of choice.

I've downloaded paolo bonzini's smalltalk-mode.el

I've hacked some shortcuts to navigate through classes using emacs narrowing feature.

Here's the hack:

HN Frenzy

2011-09-08T18:28:00.006+01:00

HackerNews is not in its greatest moments lately, but today, lots of diferent great articles/links appeared. It's a bit overflow of info in just one moment, you open a handful of links and you face.

Probably the greatest hello world on linux kernel module

A funny study on most pressed keys on different languages.I'm thinking if that's possible to include it in jtalk.
http://www.forthos.org/
Another great tutorial on git explaining things in a very simple way. The more I know about git, the better I rate git tutorials. I'm probably suffering the "I don't understand until it's obvious" syndrome

if this then that. API comunication between most famous intertubez sites. IT could be named THE INTERNETZ DBUS

Not in HN but a tiny example of how cool is the project that's driving some of smalltalkers to sleep 4 hours per night.Jtalk. Credits on that go to Bromagosa

Routing tutorials in rails 2.X

2011-09-05T00:37:00.004+01:00

For me, one of the most confusing things in Rails is routing. The DSL, all those automagic methods, abuse of method_missing (it's starting to feel usual), and RESTful conventions, mixed with namespacing,

I've found three detailed tutorials (well, series of tutorials) that seem to explain all what's needed to get into the routing thing. Here are the links to

under-the-hood-rails-routing-dsl
under-the-hood-route-recognition-in-rails
under-the-hood-route-generation-in-rails

A couple of articles on extending routing system
monkey-patching-rails-extending-routes-1
monkey-patching-rails-extending-routes-2

Here's the starting point of a super-detailed explanation and hands on tutorial on rails 2.X routing.

beginners-tutorial-routing-in-rails-20-with-rest-part-1-of-n

There are 6 parts in this last tutorial.

Btw, both blogs seem good sources of information. Good explanation on different topics, always quite detailed, and well written. For example, here's a series of posts on AJAX (from the bottom up).

Bye!

Jtalk tutorial. (Valid until the end of this week)

2011-09-04T14:44:00.024+01:00

TL;DR
write this in a workspace, select, and click 'DoIt'. Instant reward.
Counter new appendToJQuery: 'body' asJQuery

You know Smalltalk, it is an object oriented programming language developed at Xerox PARC during the 70's by Alan Kay, Dan Ingalls and other brillant guys. It is known that Kay, and probably other members of the team, was born from the leg of Zeus. Jtalk is an implementation of Smalltalk that runs on top of JavaScript, developed by Nicolas Petton. It allows the use of Smalltalk for client side applications. Even more, Jtalk allows you to use the famous IDE from the Smalltalk world directly in your browser. It compiles to JavaScript, and follows Pharo, a fork of the Squeak Smalltalk implementation.

The canonical "Hello World" looks like this:

You create a subclass of Widget, and you implement the #renderOn: method. Jtalk will pass an HtmlCanvas instance that we call html in our code. This object provides some "brushes" allowing to "paint" into the html canvas by message passing. We created a div element by sending the div message to html. The div element has it's class and id attributes defined, and it contains a h1 element. Everything is performed by passing messages to the html object. Those familiar with the Seaside web framework will recognize the html canvas. After the HelloWorld class is
defined, you can see it in the browser by appending an instance to the page's body using JQuery:

HelloWorld new appendToJQuery: 'body' asJQuery

A JQuery object is created by passing the #asJQuery message to the string object 'body'. Then we pass the #append message to the JQuery object, with an instance of HelloWorld as argument. You can evaluate this expression in the Workspace and see it in action.

Another way to do the same is going to JQuery class, and send the #body message.

Where is the Counter?
If you know Seaside you'll want to look at the Counter example. I will reproduce the example from the Jtalk website, which you can find also with the IDE's class browser. It is a good example because it shows how you can write stateful applications in Samalltalk, by simply using its object system as you would do in any application:

As in Seaside, the button definition is beautiful. Since the object itself holds the state of the application, you simply bind a Smalltlak code block to the onclick event, and Jtalk will take it from there.

Interacting with the DOM with JQuery and JS evaluation

As you can see, there is JQuery support provided by the JQuery class. We just used it for appending a piece of html to the body element of our page. There is support for a good part of the JQuery api, as you can see by browsing the methods implemented in the JQuery class. You can do DOM insertion, css manipulation, event handling, etc. If something you like is not implemented, you can evaluate JS code by enclosing it with the "<" and ">" characters. A wrapper for ajax is also available:

Here we create an Ajax object and then we send some messages to it. As you can see, we use Samlltalk blocks as callbacks, this blocks are compiled to JavaScript anonymous functions for execution. There are other messages availables in an Ajax object, like #onCompleteDo. Dictionary like syntax is provided for passing additional settings to the Ajax object:

As test, I wrote a small HTTP service interfacing a CouchDb instance. I did it in Python using the small but cool Flask framework:

Please consider it almost pseudo code. You can note its very simple stuff. We serve the Jtalk DE at "/", and we provide access to the database in "/get/<doc_id>". Now, we could build a small wrapper for accessing this service:

We provide a single method called get:onSuccess: allowing the client code to request a document and executing a callback block on the resulting data. Smalltalk blocks are constructed using brackets, and they are like anonymous functions. Temporary named arguments are declared with the :argName, and after the bar you can write any Smalltalk statement. Our onSuccessDo callback takes the data received form the Ajax request as argument. This data comes in JSON format, so we
use an instance of the Smalltalk object to translate this to a Jtalk object, and then we pass that to the block provided by the client code, which we called "aBlock".

An experiment using Rasta.js for data persistence

Rasta.js is a very simple key/value storage service. It provides a REST API and a client library:

<script src="http://rastajs.errorjs.com/rasta.min.js" type="text/javascript">

We can use this for looking at how can we delegate execution to a JavaScript object and also for providing some data persistence to a static website.

That was easy. The Rasta class has one instance variable, called "rasta". Instance attributes are private in Smalltalk, you have to implement methods if you want to access them from the outside. But in this case, our rasta attribute is for internal use, we don't need the stinky accessors. The Rasta.js API provides two simple JS functions:

Rasta.get('age', function(val){
/* val == '100' */
})

Rasta.set('age','100', function(){
/*      */
})

Since they use an upper cased name, and in Smalltalk those are reserved for classes, we have to use a special trick. Jtalk will get confused if you try to evaluate "Rasta" directly. This not happens with lower case JS names, which are available directly in the Jtalk IDE (you can try
console log: 'fooBar' for an example in the Workspace.) So, we will use our "rasta" instance attribute for storing the JS object, we use the <jsobject> notation for getting a sort of proxy object which will delegate messages in the JS one, and we can access it under the "rasta"
name in our messages. Now we can use the Rasta.js KISS service for our data storage:

database := Rasta new.
database get: 'aKey' onSuccess: [ :data | 'div#container' asJQuery append: data ].

Ok, usualy you will want to format the data. We can wrap this into a Widget subclass and implement a #renderOn: method. At this point we can put all these features together in our mind: you get a nice programming environment which promotes good code practices like layers and concerns separation, clean and readable syntax, testing facilities, and who knows
what, with an IDE accessible directly from the browser.

On code persistence

I will just say it. If you press "F5" (or "r" if you are a hacker) you will lose your code. The IDE features a "Commit category" button, which sends a PUT request with the compiled ST in the body. But as Jtalk is focused in client side coding, it is your responsability to handle the
request and save the code into the "js/" folder, next to the Jtalk library. I will show you the "almost pseudo code" thing again, with Flask and Python:

Note that I used the secure_filename from werkzeug to sanitize the data, since I use it to build the path. You don't want to allow write to your .zshrc or similar.

Concluding

Jtalk can help you to write heavy client side applications by taking advantage of the ancient wisdom from the Smalltalk world. It still has some sharp edges but it is there for you to try it. Allows you to write stateful client code easily, and to port known and tested patterns to
the web browser, for great justice. And there is a plus. Jtalk is part of a legendary story, the Smalltalk one. After all, I have told you, these guys came from the leg of a god.

A moving target

In the couple of days that Rodrigo Bistolfi and me have been experimenting with Jtalk and writing this article (In fact he wrote most of the article), a bunch of things changed already, or are going to change shortly. For example, Capitalized Javascript objects are parsed now without problems in Jtalk. On the JQuery side, Nicolas Petton recently said that JQuery binding is going to disappear from jtalk bundle. It seems we'll be able to fetch DOM nodes directly with jtalk. So better be up to date with the jtalk git repo, because jtalk is moving fast.

Btw, there's a lot more related to Jtalk. Goran Krampe wrote jtalkc, that compiles jtalk code to js able to run in node.js. I haven't digged on that yet, but seems it also opens a shitload of possibilities... :)

Cya!

more git workflows. Getting closer to sanity

2011-09-01T00:41:00.003+01:00

Toady, a new article of git workflows appeared in HN. The nice thing of it is that at my workplace, we use exactly the same workflow. I just post it here for future reference

And now that we're at it, I link another git workflow related post that talks about merge --squash. A nice thing to make your history cleaner

Btw, I recently discovered a couple of interesting git man pages: gittutorial and gitworkflows. Interesting information there too.

ESUG in: 2011 on: Edinburgh

2011-08-23T16:38:00.011+01:00

ESUG 2011 is over, and I'm back from my holidays, with a couple of interesting bits about the smalltalk world, and lots of energy.

Here are the talks that impressed me most:

- Martin McClure explained Maglev smalltalk to ruby ffi. It seems maglev is more than a simple smalltalk vm. In fact it runs ruby code and smalltalk code seamlessly (at least, that's what I understood). Unfortunately, it only exist in 64-bit shape, so I couldn't try it myself. The core of the presentation though was the nice FFI that VMWare guys (former GemStoners) prepared to run Ruby code from Smalltalk.

As most of you know, Ruby is heavily influenced by smalltalk. In fact, so much that Martin and friends were able to make one object for both worlds. So String class is the same for ruby and smalltalk. Objects are the same, but the names are different, so SmallInteger for smalltalk, is fixnum for Ruby. 'super' pointer is also different, enabling to build variations in hierarchies and supporting singleton classes for ruby.

Lots of nice tricks that enable us to use ruby objects as smalltalk ones.

- Bifrost. Jorge Ressia is implementing great improvements in the reflexivity side of Pharo. Being able to treat data as code is one of the aims of bifrost. Not losing the link on logs and where a log entry comes from, or being able to hook on variable usage when debugging... Thanks to Bernat I was able to try it in my own pharo image. (Bifrost is only the framework, you have to install the programs separately)

- Jtalk. I think this was the killer talk of this ESUG. Goran Krampe and Nicolas Petton presented their (mostly Nico's) smalltalk implementation in js. Running smalltalk in browser is not only being able to write smalltalkish syntax. It means you have a full stack smalltalk in your browser. Many firebug features will come for free in Jtalk. Goran showed some experiments he's doing with node.js and jtalk compiler to js. Yes, you're able to write smalltalk for the server side. Probably I'll post more about jtalk, so keep tunned.

There were a lot of other interesting presentations, like Gerardo and Javier live garbage collection tweaks(writing garbage collectors in smalltalk and rebinding garbage collector on your live system), redline (smalltalk in your jvm) and Coral (pharo for those who can type).

It's great stuff all way down!

Cellular automatas and me

2011-08-21T23:06:00.005+01:00

2 weeks ago I started to read Philosophy and simulation by Manuel DeLanda (thanks eskerda).

About one month ago I watched jdelgado's talk at Campus Party talking about science in science fiction, and he talks a bit about cellular automata too:

So I started to experiment a bit with cellular automatas myself, and implemented a Conway game of life in smalltalk. At first I wanted to write a very flexible (1d,2d,...nd) cellular automata engine, but once I had the 2d Game of life implemented, I realized that doing 1d things is easier if you do it with strings, or just lists (lisp lists, for example).

Well, so I implemented a 1d cellular automata in common lisp (nice exercise) and tried some interesting rules for the majority problem jdelgado mentions in his talk.

At first I thought majority problem had a defined proper solution, but searching on the internetz, it seems it's not trivial at all, and I couldn't find anything that takes me further than rule 184, that splits the list in a group of 0's and 1's.

If you want the implementation of the smalltalk GoL, ask for it (it's not that easy to paste smalltalk code on the web, you know...), or just download any already existent implementations on squeaksource, like Bernat's one.

git push -f to master and you're a dead man

2011-08-16T18:01:00.003+01:00

Just came back from the half of my holidays, and came with a quite long TODO list.

One item of the list was a wrapper for git that avoids pushing -f the master branch.

At my new $job (yes, I changed again, you'll be noticed properly when I have more time to write), we use a minimal version of git-flow and we run tests on remote (personal) branches.

That means that sometimes, you have to git push -f to your personal remote branch, and possibly delete history. There's no problem if you do it in your personal branch, but as dumbans we err, and myself, being new to all this git fancy stuff, I was a bit worried about it.

I've come with a solution that should work fairly well and transparently. A wrapper for git that nops dangerous commands.

It's perl, and here it is.

Despite being destructive, I like the equals method, kind of lispy, but using shift as a car/cdr solution.

To make the wrapper work, rename it to 'git', make it executable, and put it somewhere in your path, before /usr/bin/git executable.

Back to the future. Xerox PARC innovations.

2011-08-09T00:30:00.001+01:00

From time to time. I spend an afternoon doing some monographic research of a great Computer Scientist, or simply people I've seen some day in TED, and would like to know more about him/her.

Sometimes it's Joe Armstrong, sometimes it's Guy Steele, but Alan Kay and friends take these afternoons more often than others.

Here are 3 Conferences by Alan Kay and one from Dan Ingalls. Those two men (and their collegues at Xerox PARC) have done probably more for our field than any other single group in the 70 years of history of CS (or call it tinkering, or computer tekne)

Alan Kay at TED talk, sharing his ideas about ideas. 2007

If you liked it (you SHOULD like it), here you can see a longer talk about Alan's last work (STEPS)

http://www.tele-task.de/de/archive/lecture/overview/5819/

Here's Dan Ingalls talking about his work at PARC Place. Great stuff too.

http://www.infoq.com/presentations/Forty-Years-of-Fun-with-Computers

And another Kay's talk about great innovations of the 60's and 70's. In XXI century, we haven't exploited many of these ideas yet.

http://video.google.com/videoplay?docid=-533537336174204822

If you know of other related talks, please, put links in comments.

open rails files from console to $EDITOR

2011-07-16T10:54:00.001+01:00

You're in the console, run rake test, and appear a bunch of file paths cluttered with line numbers, colons, and no spaces between them. Well, lest turn the no-space-between them thing in a WIN for us.

Errors and failures show in different formats when running tests (not a very *intelligent* thing if you ask me, but...). Well, a simple regex and we have 'pe' , powered-emacslient, path-edit, or whatever. In my shell, double click any of the two versions and 'pe ', and you're sitting again on your editor. placed in the correct line.

.. app/models/bar.rb:88:in ..
.. [test/unit/foo_test.rb:9]: ..

'e' is the original emacsclient script I use for other files. Unifying both scripts in one is left as exercise to the reader.

I want to spend an afternoon hacking a urxvt plugin to fetch for strings ressembling paths, and be able to open them using just keyboard, but that's a thing for another day.

Sending links when you cannot send files.

2011-07-14T18:11:00.005+01:00

I've been reviewing my ~/bin directory and felt like sharing some of the little scripts there.

Today, here's a little Perl script that helps me when having to give a file (screenshot or something) to someone @work. Most people do it by mail, or using jabber protocol. Unfortunately, emacs-jabber does not allow sending nor receiving files, and opening mail client and attaching files is waaay to slow and boring.

The way I work with this situation is having a simple http server in my computer, and moving the file there. then, I paste the link to my coworker, and he/she just has to click it and download.

The http server lives inside emacs. Oh yeah, that's irrelevant. But I had to say it.

Well, here's a script I wrote in 2 minutes.

Hashing the name is to avoid name guessing. I think I got this idea from a Mark Fowler's post that was doing something like this with dropbox.

Snapshots motherf*cker, do you speak it?

2011-07-06T21:34:00.004+01:00

Today, I'll just snap a recipe for a use case that starts to crop up when evolving from a total git beginner to not-so-noob-git-user. git reset

Here's the diagram:

Ok, now screw it.

The main problem when thinking about how git works is thinking in the wrong way. You've been told hundreds of times that git works differently from EVERY other versioning system around, and you keep forgetting these concepts every now and then.

The diagram before is a diagram of where git moves your changes when you do a given reset command. git reset --soft foo moves the changes from commit 'foo' till HEAD to the index.

YOU'RE THINKING IT WRONG.

Remeber that you've been told that git records only snapshots? Well, think about it. When you want to reset your repo to the past, if you have a clean working directory and index. HEAD,index and wd are all in the same state. That means that All trees contain the same. THE SAME. If you are thinking that your wd has some files, that the index is empty (Delta is null) and same (or kind of) for the repo, you're thinking it WRONG again.

Now, if you go and look git help reset, and this MJD's post about git reset.

Then it's kind of easy to understand what it does, and in which state will leave your repo, index and ass.

(take the italics notes as if you just reseted the most recent commit, if you reset to older ones, all changes are accumulated)

git reset --soft just updates your HEAD. Changes are in the stage, ready to be commited without that nice 'fdsajflkdsajflkasdf' commit message. You're in the moment before you commited.

git reset --mixed updates your HEAD and your index accordingly. That means that probably, if you're reseting to past commits all changes from the target commit till now will be only in your wd. You're in the moment before you added files.

git reset --hard updates everything. You're in the moment after you commited the commit (O RLY?) so you lost everything you did after the commit.

Btw, Take all this post with a grain of salt. I just had an 'AHA!' moment I had to share. Probably it's not *very* technically accurate. I haven't even tried what happens on detached heads and other bizarre situations... yeah, I'm a sucker.

man git-reset contains lots of tables and info, but IMHO, naming the states of files A B C D lead to harder understanding that if they'd have been D C B A.

And now, a doubt for the lazyweb:
git reset hard does not allow you to recover your state. gitk --all does not show anything from HEAD on. but git reflog does show it. And I'd swear gitk --all worked 2 days ago....

Addendum: Here's a great article on git reset that appeared a week after my finding. Really well explained, with graphics, tables and everything.

El trabajo del futuro

2011-07-03T15:48:00.007+01:00

Via RaulGB, veo que hay empresas tan avanzadas a su tiempo, que vienen del futuro, como la rubia de la lejia, o Levi Strauss con un Delorean, o H.G.Wells.

Me guardo la oferta, espero 3 años, me pillo una time machine, que seguro que estaran inventadas por entonces, y vuelvo a por el curro.

Esperad mi llamada el martes que viene. De vuestro tiempo.

Resize window in emacs

2011-07-02T15:17:00.002+01:00

I use emacs as much as I can. That's not really news, is it?

One of my use cases for emacs is chatting with friends. I use erc for IRC, and emacs-jabber for everything else.

One thing that annoys me a bit is that when my screen is split in two and want to shrink a bit one of the two windows.

There's c-x - (shrink-window-if-larger-than-buffer) but it's only useful for a handful of situations (IMHO)

Here is a little function I wrote to shrink a window to selected region. I find it useful to narrow windows to functions, paragraphs, or just narrowing a chat window to just 5 or 10 lines.

Select a region, and run it. Then c-l to recenter accordingly.

I mainly use it as a more visual narrow-to region.

Have fun

read-only weekend

2011-06-27T00:37:00.003+01:00

Pretty nice weekend:

Thursday night, a 'Gifted' concert with many of our friends attending.
Great St.Joan party.

From Friday to Sunday I didn't program anything but read a couple of
books. Yes, two. It's true both were quite easy reads and not very long.

One of them is OReilly's 'The productive programmer'. I found the
book a really easy read, but maybe it's beacause I already knew most
of the tricks. In fact I already knew I'd already know most of the
tricks. The second part of the book, though was a bit more abstract,
and I could make some use of the info there.

Points I found most interesting:

- Make a living doc. (From commit logs to wiki, for example)

- Learn to FOCUS. (I'll search for csikszentmihalyi's books)

- Composed Method and SLAP.

The other book I skimmed is more a long article than a book: Git Magic, by Ben Lynn.

It's a pretty nice source of info on git. Really concise and to the
point. Mostly beginner, but also contains some advanced tricks (with
the use cases explained), and a chapter on the git low-level stuff
(remember git from the bottom up?)

Don't quit emacs by accident

2011-06-22T22:41:00.005+01:00

Today I read a blogpost by en emacser blogger (tsengf) about quitting emacs accidentally.

He writes a function to avoid closing emacs by accident when there's an opened file that belongs to any of your projects.

My approach is somewhat different:

Usually, when I have emacs opened, I have some processes running within it. That makes emacs warn me when I press c-x c-c by accident, and asks for confirmation (the same way as if I had unsaved buffers)

Anyway, sometimes my muscle memory screws everything, and presses 'y' without asking my conscious mind.

Here are a couple of solutions that work to some extend.

The first one is the radical one. Just do not shut up emacs. Yes, as strange as it seems, I rarely have to close emacs while my computer is on.


global-unset-key c-x c-c

Then you have to exit emacs with the name of the whole command save-buffers-kill-terminal

As a not-so-radical solution, my bet is for desktop-save to save every session in your home directory.


(defun desktop-save-main ()
  (desktop-save "~/"))
(add-hook 'kill-emacs-hook 'desktop-save-main)

Then, if you want to recover the state of the previous session, you have to eval (desktop-read) or (desktop-read "~/") if you aren't on your home dir.

If you had sql sessions, erc sessions, or any other comint buffer... well... you lost them.

PS: If you happen to know how to make this blog/post appear on the emacsen planet, please comment, or mail me, or twitt it to some emacs aggregator.... or just twitt the post FEED ME MOAR RSS's!

sleepsort for the lulz

2011-06-16T22:09:00.004+01:00

Today I discovered a programmers' BBS on 4chan (It hit HN's front page).
There was a post talking about a sorting algorithm that the author called it 'sleepsort'
I couldn't believe I didn't thought of it before. In fact in a past post talking about Parallel::Iterator, I played with timers too.... I was sooo close :)

Lots of lols reading the full thread, with comments, optimizations, translations to other languages and puns there.

For example:

- complexity of the algo: O(highest_value_in_input)

- 40: Someone email this to Knuth.
- 41: >>40. Knuth doesn't do email anymore

Have fun.

vim.orthogonality > emacs.orthogonality

2011-06-14T18:47:00.001+01:00

I already mentioned this same thing in other posts, but well, today I stumbled upon another example of it.

Vim is like a unix commanline, lots of little commands you can combine one to each other. It has the cognitive style of linux command line

bufdo,argadd,argdo... These are the 'pipes' of vim. multiplicity enablers that add functionality,commands and power in an exponential way.

When writing ReST docs to take notes at university, I used Vim, and I got used to underline titles with an add-hoc sequence I made up (yank line,paste,visual line, replace, char) . Vim doesn't need a specific command for it, because it's immediate, and like most vim combos, it's like talking to it in a funny slang.

On the other corner, emacs: as part of emacs-goodies (ubuntu package with a bundle of emacs plugins) There's under.el. A plugin that exports 'underhat-region'. A function that underlines a region with caret characters. The bad thing of underhat-region is that it's not parametrizable, but that's not the point. The fscking point is that in emacs you end up stumbling upon functionalities that are already there as commands, but probably sunken among zillions of other commands.

I'm more a vim-style guy myself, but couldn't resist emacs+vimpulse combination. I think I'm sold.

PAIP, special edition

2011-06-07T19:37:00.004+01:00

I recently bought a copy of PAIP in dead tree format (as usual, a used one). When I received it, I was a little worried about the state of the book (it was expensive enough to be worried about it). I opened the package, glanced it and seemed pretty good. Nearly unused.

But when I opened it... OMG! The fist page contains a note from Peter Norvig!

FUCK YEAH!

js can be fun(ctional) too. A new hope

2011-06-06T22:59:00.005+01:00

Reviewing my latest gists, I re-discovered one in which I copied a js snippet that implemented foldr, one of those great higher order functions. As a proof of concept, I implemented some of the functions on 'Why functional programming matters' paper. In fact, I reimplemented nearly all builtins.scm (from my Half Assed Scheme implementation)

I recently took a quick look at coffeescript, and it seems very promising. Unfortunately, I didn't even try it (just the online interpreter). Maybe when I try rails 3.1

Undo layouts in emacs

2011-05-25T13:49:00.003+01:00

Once you're used to being able to undo and redo window layouts in your windowmanager (hello ratpoison!), You feel the need to have this same feature everywhere.


;;; winner-mode
(winner-mode 1)
(global-set-key (kbd "C-x 4 u") 'winner-undo)
(global-set-key (kbd "C-x 4 r") 'winner-redo)

Slime configuration for common lisp

2011-05-24T22:20:00.002+01:00

I recently bought a dead tree copy of Norvig's Book PAIP, and plan to dig harder on common lisp environment.

To set up a correct environment, there's emacs,slime and an implementation of common lisp. sbcl is my choice, for no big reason. It's just one of the free implementations.

Slime configurations are endless, but here's a decent one that mostly works for me.

Ah, there's a surprise in the book. I'll show you in a future post :)

Smalltalk tutorial on IRC

2011-05-23T18:00:00.001+01:00

Last week at #emacs-es on Freenode I did a very-short-and-introductory-hands-on-workshop on smalltalk. Just in case you know spanish, here's the log, with names removed to protect the guilty.

Ratpoison bindings without prefix key

2011-05-17T18:30:00.001+01:00

My window manager of choice is ratpoison. It's a really minimalist tiling wm heavily inspired by gnu screen. As such, it has a prefix key (c-t by default) and most of the bindings mimic screen ones.

At work, I recently discovered that my boss uses ratpoison too (my project manager uses xmonad, great team, isn't it). He uses ratpoison with a different configuration scheme, banishing prefix key, and using definekey at toplevel for every command.

I'm not sure whether I like this configuration or not, but I'm going to try this for a few days, and see if it works ok or what. I've written some lines to enable toplevel bindings using the super key.

Avoiding c-t as a prefix key has its advantages, but now, 'super' key chords are all clobbered by ratpoison. We'll see how it works out.

Smoke Driven Development

2011-05-17T18:14:00.002+01:00

He pensado que podríamos usar git
Con un poco de scrum y si aprendo TDD lo tenemos hecho en dos semanas
Un par de branches, un par de slots
Dos cartas porahi, un coaching porallá
Y despues, fiesta de final de proyecto, cardhú, putas y farlopa. Pago yo.

-- Alguno que yo me sé --

latex code listings in org-mode

2011-05-10T18:03:00.002+01:00

I already talked about inserting code listings in latex some time ago. At @work
(in a ruby meaning, not a perl one), I try to write as much as I can
in org, and then export it to html, or pdf.

org-mode is fully capable of assisting you when writing code listings,
and it will export them with fancy syntax highlighting. When exporting
to html, it uses htmlize (emacs-goodies if you're in ubuntu). But when
exporting to LaTeX, things are not so straightforward. Of course,
there's extensive documentation, but sometimes, you just don't want to
read through hundreds of details. You just want something that
'WorksForMe (c)'.

(setq org-export-latex-listings t)
(add-to-list 'org-export-latex-packages-alist '("" "listings"))
(add-to-list 'org-export-latex-packages-alist '("" "color"))

I don't know if it's enough or there's another configuration related
to this sunken in my .emacs (now 609 lines long), but you know... It
WorksForMe.

Technologically impaired office

2011-05-06T10:10:00.008+01:00

Ok, I've already spent too much time trying to write a doc in openoffice to acknowledge that most of general user-friendly apps are for total technologically impaired ducks. It's not that there are no shortcuts for everything, its much more simple than that.

Every single function has a button for it. You want to indent a paragraph, ok, there's a button for it, outdent, another button... The fscking problem is I'm not in the mood of looking through all the buttons of all toolbars until I find it. And guess what? Selecting a paragraph and pressing tab, just blows you paragaph away and adds a tab.

My Technologically impaired solution.
foreach @line {press(tab,↓,←)}

Popups are the root of all evil. Well, openoffice will nag you when the cursor is on a table, a numeration, or god knows what.

Nested enumerations with styles, another shitstorm.... Copypastable formatting, font, background highlight and all the unwanted persistency of a place-and-format. You will get signs from the past red bold letters that lived in the place you're editing 3 centuries ago.

For this and much more, I declare myself technologically impaired.

Perl, paths, local::lib and why I got stuck for a week

2011-04-26T17:16:00.010+01:00

When writting ratfinder2, I started testing it in console, and when the main structure kind of worked (the plugin system is for Yet Another Post(tm) ), I wrote the gui stuff, and plugged alltogether. Everything worked ok when run from console. but if the program is executed directly through a ratpoison binding, the script didn't work.

After some debugging time, and nothing seeming to make sense, trying && failing while(1..Inf);... the solution is here.

The thing is that when executing the perl script directly, .zshrc doesn't get executed, so the path isn't added. Be able to run the script we can use 'use lib "/home/rgrau/perl5/lib/perl5";', or otherwise call the script with the -I flag setting the appropiate path.

I suppose if you bind an icon on gnome/kde/windows to a perl program, you should be aware of that, and bind the icon to the appropiate command.

so now, my ratpoisonrc line is like


bind j exec perl -I/home/kidd/perl5/lib/perl5 ~/bin/rat-finder.pl
bind C-j exec perl -I/home/kidd/perl5/lib/perl5 ~/bin/rat-finder.pl

I know it seems obvious now, that you should tell your perl where the modules are, but once you forget about local::lib.... It can't be unforgotten :). The opposite of TH I S

Open2 for dummies

2011-04-19T23:08:00.005+01:00

Some days ago I started rewriting ratfinder, and I'm trying to make it cleaner, smarter, more extensible, and (why not) have more fun programming it.

The language of choice is still Perl5, because I'd like to keep in touch with the language, and keep learning new tools and libs for it. Ruby is ok, but honestly, if we're not talking about god's purity (those two old languages), Perl is my favourite bitch.

The first design decision was to make it extensible via a plugin system, where you provide a couple of methods, consume a role (Moose, yeah), and ratfinder2 will do 'the right thing'(tm).

I'll talk about the plugin system in another post, but today, I had a simpler problem (at least at first sight).

One of the multiple ways to spawn new processes in perl, is using the super-duper-overpowered-open primitive, with a pipe attached into the name of the process. I still remember One of Casiano's example on it. Quite mindblowing when you first see it.

But what happens when you want not only INput OR OUTput pipes but INput AND OUTput pipes for a process?

Hey, it's Perl, you know man, TIMTOWTDI. IPC::Run, Capture::Tiny, IPC::Cmd.... but the standard way is, for the moment, IPC::Open2.

It's usage may be trivial for you, but for me, the doc is a bit behind the times, as it uses GLOBS for handles, and the examples didn't clarify much for me.

The key concept for me is knowing that the whole thing works when your write pipe is closed (at least it seems so), so if you can't make your host process close it, you should close it by yourself.

Here's the part of relevant code in my Dmenu.pm

As usual, everything is public, undocumented, buggy, and it's on github.

What you can't see CAN hurt you (or, at least, annoy you)

2011-04-04T16:26:00.004+01:00

Most of the times, and programming in sane (cough, cough)
programming languages, things like whitespaces, tabs and newlines
won't do you much harm. they work as separators for tokens (unless
in a string).

But that doesn't mean that you can't get trapped into some gotchas
related to whitespaces or newlines. One example everyone has dealt
is lineFeed vs carryReturns vs CRLF.

There's a funny article from fxn on O'Reilly site talking about
the secrets and gotchas of newlines.

As a long time vim user, and nearly a year of using emacs (with
different intesities), I care a lot about my editor features, and
one feature that's really useful is the 'select paragraph'. Both
emacs and vim can do this out of the box, but there are some
problems when you aren't careful enough and leave apparently blank
lines that are full of spaces, tabs or any invisible characters.

In vim, you can delete all trailing whitespaces with a simple
regex. Of course, you can create a command to do it for you, or even
map some keybinding to execute %s/\s\+$// , but I'm ok with typing 10 chars for it.

In emacs, of course there's a command for deleting trailing whitespaces, and, guess what?
it's called delete-trailing-whitespaces :) .

If you want emacs to show trailing whitespaces, there's a buffer-local variable called
show-trailing-whitespace that you can set to true. Here's the official emacs doc

Emacs has a command called 'whitespace-cleanup' that bundles some sane (configurable) rules to clean most annoyances related to whitespaces.

Modern Perl Toolchain, dip your toe

2011-04-01T20:58:00.002+01:00

Yesterday, we had another Bcn PerlMongers meeting, and AlexM showed us some nifty tools he's using in a project he's into.

Basically these are what in the perlsphere is called Modern Perl Toolchain.

Forget about cpan asking tons of questions, forget about only one
location for modules.

With the help of:

cpanm

App::Perlbrew

Dist::Zilla

And some plugins for dzilla, you get isolated perl instalations, with
their own modules (@INC), and a trully easy maintenance of
Boilerplate. In fact, it's as easy as it can get, because, you don't
have to do any dedicated maintenance for them.

I had tried some of the old ways to package apps, and so, and when I
saw the power of these 3 modules (I had already used cpanm, but..), I
felt we got an autoshaving yak.

Here are the slides that AlexM kindly uploaded today.

During the talk, some modules arouse to the conversation, and I
took a look at some of them:

lib::xi

similar to Casiano's Remote::Use, but probably easier in its usage. a big win.

Devel::REPL

Carp::REPL

That's the killer one for me. It hooks on die signal, and spawns a
REPL and you have then access to the whole environment. Great great great.

If you want to set 'breakpoints' you can hook warns instead of just exceptions.

And another cool feature is that you use it just enabling it from the commandline

perl -MCarp::REPL

Managing the unmanageable with git

2011-03-22T19:35:00.000Z

After 2 months using git regularly, there are a couple of things that I'd like to comment here, just for further adding on other posts.

Mostly, for me there's a first blocker that is understanding how the global thing works. To solve this, I can recommend git from the bottom up. a great introduction to git written quite differently from most other docs that want to explain the same. Understanding the low level stuff helps you getting intuition, and IMHO it's essential to get this kind of intuition when using such holistic systems.

Most tutorials give you the essential syntactic information that you can get from man (btw, man git-whatever will give you lots of info), but for me, knowing the workflow and how-to think gittish (or thinkgit if you prefer) is what bothered me most of the time.

You probably have heard about nvie's git workflow. I haven't tried it yet, and at work we use a simpler workflow based on a remote master branch, two local branches (master,working) and quite centralized flow.

Not being a git power user (I'd say I'm just scratching the surface) I'm going to write a couple of posts that are what I'd have needed when I started with it seriously.

Checkout - what happens when you checkout
Clean - oops, I think I messed something
Stash - Smashing the stash for fun and profit
Rebase - commit -am 'fdsda'
Bisect - It's always been that way NOT!

If you have suggestions or something to add, I hope you will comment. Remember, I'm learning as I write these posts, so you can and MUST collaborate!

Perl Higher Order Functions

2011-03-07T21:16:00.005Z

I've been chit-chatting with a friend who's learning Perl5, and has written some little apps for his own needs. While reviewing his code (not that I'm a programming guru, but I help with what I can), I talked about Higher order functions, and we ended writting some throwaway code to explain the idea.

To clarify the concepts, I wrote some trivial scheme functions-as-data munging in scheme, and translated them to Perl.

What surprised me, was the "wow!" comments about concepts that aren't perl unique features, but general higher order procedures. Certainly, Java and C++ are 'a bit' behind Perl, Ruby, or Lisp, but it's fun to remember how mind blowing are these concepts to newcomers. I discover mind-blowing concepts quite frequently too.

We had a good afternoon, reviewing code, Quines, concurrency, talking about GEB (The book I'd take to a desert island along with SICP)...

Here's part of the code we've written (as a reminder). Nothing useful, but tiny proof of concept of HOP. Ah, btw, I recommened him to read chromatic's Modern Perl book. I recomend it to all of you in the Perlsphere. Great book.

Window navigation on Emacs

2011-03-06T23:06:00.008Z

Last week I was talking about some emacs features with a coworker (while talking about General User Interfaces, pros and cons of WIMP), and ended with the doubt whether there is a way for easier window navigation on Emacs, or c-x o is the only way to go.

I talked about one of the greatest aid to frame/window navigation of screen and ratpoison, that is window numbering, and being able to switch to random windows instead of just sequentially.

Well, today I spent some time thinking about possible solutions, and searching for already implemented modes.

Guess what? There are a couple of ways already implemented (in default emacs, or as an extra downloadable package).

Windmove comes bundled with emacs since 21-dot-something, and in fact is what vimpulse uses for the c-w [hjkl] emulation.

(windmove-default-keybindings) ; enable shift-arrow

Expanding the concept further, there's also FrameMove, that integrates seamlessly with windmove. Here's a little extra info about it.

I found a couple of more esoteric plugins to navigate windows, but haven't tried them.
http://blog.lathi.net/articles/2007/11/07/jumping-to-specific-windows-in-emacs explains how to jump to windows by title. I suppose like ido-mode or anything-buffers.

There's also https://github.com/dimitri/switch-window , that seems to bring ratpoison's numbering of frames to emacs' windows. Nice idea. Here follows a screenshot of switch-window from it's homepage.

Programmer problem solving sequence

2011-02-28T14:42:00.007Z

2010 developer’s problem solving sequence:

Google
Coworkers
StackOverflow
RTFM
Think

It's funny because it's true.

Via HN -> JCook -> Philippe Leybaert

run interactive applications inside emacs

2011-02-21T22:12:00.008Z

While implementing a more decent repl for HAScheme, I stumbled upon a nifty emacs feature: comint.

To run an interactive shell, get history for free, and completion (at least hippie-expand if you teach your emacs to use it), you just have to use make-comint.


(defun run-has ()
 (interactive)
 (make-comint "has" "/path/to/hascheme/script/lis.pl" nil "/path/to/hascheme/script/builtins.scm"))

the last parameter is the argv, you can fill it with whatever you want. In my case, the scheme file with some builtins.

On the hascheme side, I've been experimenting with tail call optimitzation, an improved repl with multiline support and with some cool debugging features. You'll know shortly about them if you follow this little blog of mine.

Well, and here's a screenshot of the comint buffer on hascheme. note the completion thing on the minibuffer.

(let ((there be)) lisp)

2011-02-08T19:55:00.006Z

I keep having lots of fun with hascheme. In the last couple of
days, I implemented quite a few things. Mostly they are syntax
sugar for things you could already do in HAS, or useful procedures
needed for my basic interpreter testing.

Perl side
- (define (fun args) body) is now accepted as an alternative way
  to declare procedures.
- (let) implemented. These bindings for local vars are just sintactic sugar for
  what you'd write in perl:
  sub { my $a=shift; … }->(initial_val)

Scheme side
Reread the 'Why functional programming matters' paper, and implemented:
- make-counter, foldr
- append, sum-list, length, map . All are specific cases of the previous

Reading chapter 4 of our MIT beloved book, I saw the next step, making a lazy
interpreter from this Half Assed one.

Ah, the repo

Put more vim into your emacs

2011-02-07T18:43:00.000Z

I'm a vim editing model fan, but emacs is slowly crawling into my
life. emacs had viper (vi emulator) for ages, but it falls short if
you're a vim power user. Vi is not Vim.

For some time there's been vimpulse package that tried to narrow the
difference, adding Visual mode, and some other goodies. Recently,
vimpulse got reactivated, and now, we get text objects, and many
other features from our beloved text editor.

You can even use map, imap, vmap and the like;

the first thing I tried was mapping jk to esc, but the tip in the
vimpulse wiki didn't work. I managed to make it work with this line
in my .emacs file.

(vimpulse-imap "jk" 'viper-exit-insert-state)

Now, there's no need to reach the far escape key.

QuasiQuine

2011-02-04T18:20:00.002Z

Little updates to Hascheme, I finally implemented cons, car, cdr,
and list as primitives, After implementing the prove that you can
have datastructures in a language without no more ground than
lambdas, I went for a bit more of efficiency (not that hascheme is
going to be in production ever, but you know…)

Another motivation to implement lists as primitives is that this
way, I can get a kind of homoiconicity. If conses are implemented
in the implemented language (scheme), a list will never be similar
to code, because Perl never sees the datastructure as something it
can deal with.

And what's the ultimate motivation for having all this stuff
working? fun.

I used a very common lisp quine to test that code and data are
implemented internally the same way. That gave a good testbed for
quote too. Unfortunately, using Perl Data::Dump* modules, I can't
tune how lists are printed, and the final nil gets printed too.

Well, here's the proof that Half Assed Scheme can do Half Assed
Quines.

Next step, testing that closures work. (I'm afraid they don't work quite well)

(cadr has)

2011-01-25T22:29:00.007Z

I've been hacking on HAS a bit more, to push forward its functionality.
Mostly what's been achieved by now:

Perl side
- (repl) primitive implemented. it acts as a debugger in some way,
  because it gives you the environment in the state of the moment
  when you executed it. I couldn't implement it in scheme itself
  because I have no eval available from scheme.
- Read plain files. As I started implementing some functionality
  in scheme, A scheme file must be loaded at start. just enter the
  file name as a parameter. Last sexp should be (repl) to have
  your repl available.
- Comments. ';' is the comment marker
- = operator
- nil. transformed to 0.
- list. yeah. As HAScheme can't understand variable length
  arguments, I implemented it to make it more confortable to build
  lists. It's built on an ugly hack. More on that later.

Scheme side
- cons, car, cdr. Implemented basic structures. Implemented as
  lambdas. as in SICP, somewhere in chapter 2 IIRC. Simple though
  impressive IMHO (and inefficient, but…)
- print_list. conses down a list and prints each element in a
  line

I run it using builtins.scm as the first parameter, and then, repl is
yours, with lists and conses available for you.

Now the not-so-beautiful parts

If I want lists, I just have to nest conses, but who doesn't want a
litte luxury?.

To implement list, I've thought 3 possible solutions (haven't read

about how to implement them correctly, just brainstorming):

Variable actual arguments. If I could implement the dot (.) syntax
for variable number of arguments, I could implement list as a
simple scheme function. Problem is that I need lists to stash
the resting parameters (hascheme lists, not Perl ), and I haven't thought how to bootstrap.

Write a new primitive (on the perl side) that builds the correct
cons structures, on the perl side. Mind you, that list is VERY
coupled to cons implementation. And quite fuzzy on the perl side
too.

Substitute list for the appropiate number of conses (as a string),
and let the already written parser do the job. That's the one I implemented.

Probably, I'll start from the scratch building another scheme interpreter, following BillHails book. Or at least, I'll go as far as my motivation and brain allow me.

That's all for now. Here's my other post about Hascheme, and the github repo.

Byez.

I can has HAS (Half Assed Scheme)

2011-01-23T18:31:00.005Z

If you've been reading along these bloglines, you already know I'm on
my way to learn lisp, and given that a typical exercise on the lispers
path is writing a scheme interpreter, I decided to try to impement a
scheme interpreter in perl. I had a great guidance of Peter Norvig's lispy tutorial, and more thoughtful explanations from Bill Hails' book.

I can't say I wrote it as quick as I thought I would, and it could
definately be clearer (OOP in such small projects is clearly
overengineering), but in the end, it works, and given the fact that I
hadn't been programming perl at work for 2 months, it's been a good exercice.

The relevant code is in 4 files,

script/lis.pl (REPL and primitives),

lib/hascheme/Reader.pm (Parsing)

lib/hascheme/Env.pm (environment, a tree structure built on hashes)

lib/hascheme/Evaluator.pm (special operators are treated here, and overall evaluation)

Anyway, here you are, the code is in a github repo. For now, It's
called half assed scheme, or hascheme, or HAS.

generate Moose classes from CLI

2011-01-06T02:20:00.005Z

It seems I've been a bit out of Perl lately (last 2 or 3 weeks), but that's not completely true.

I have a couple of projects in mind (one bigger than the other, but both interesting nonetheless), but I have not been in my best moods to program... difficulties to focus. At work, I do exactly 0% perl :(, so I have to push myself to use it...

In one of my projects I'm using OOP intensively (maybe overengineering?, we'll see), and I always tend to forget how to correctly set up a bare Moose class.

So here's what I've written:

Just a simple script that generates scaffolds for Moose classes and gives a couple of hints on attributes' properties. A good friend of the script template I did some time ago

I've tried to make it work the most DWIM-Y way, so you call it like "genclass.pl lib/My/App/Entity" , and generates My::App::Entity class in the appropiate path and with appropiate namespace.

SeeYapp! ;p

If you want a thing done well ....

2011-01-04T07:50:00.007Z

...and continuously, and consistent way, let the computer do it for you.

gem install ZenTest
gem install autotest-rails
gem install redgreen

If you're on MAC:

gem install autotest-fsevent
echo "require 'autotest/fsevent'\nrequire 'redgreen'" >> ~/.autotest

If you're on GNU/Linux

gem install autotest-inotify
echo "require 'autotest/inotiny'\nrequire 'redgreen'" >> ~/.autotest

just run 'autotest' from your project root directory, and it will run the relevant tests on your modified files.

git, now it's your time!

2011-01-02T18:38:00.003Z

At work, we're using git as our VCS. I am still on the process of fully understanding it.

Well, digging a bit on git workflows, I found a couple of posts that helped me to understand git a bit more.

Git hack and ship scripts

nvie git branching model

And now, pit a project I recently saw on github, that integrates git commits with task and ticketing systems. Everything, in Text Driven Development, you know :)

The best 'The best X of 2010' of 2010

2011-01-02T13:32:00.000Z

Here you have a bunch of rankings about best * (whatever) of 2010.

fogus' best things of 2010

switched.com best-technology-writing-of-2010/

review comparing most successful oodb of 2010
Top ten algorithm preprints of 2010

great papers from 2010, and before :)

14 R posts, with statistics and datamining stuff inside

Bye, and see you in next posts.

PLOP Loops Over PLOP

2010-12-20T15:42:00.005Z

Quines, like JAPHS, are great hobbies for us, little riddle-solvers.
Here are the 3 most amazing quines I found lately.

third order quine . And here's a SO post discussing a bit about it

ruby rotating earth quine

The new kid on the block. Judge yourself.

For those who didn't bother to google or wikisearch, here's a quine guide

And here, a lisp quine that shows the greatness of simplicity.


((lambda (x) (list x (list 'quote x))) 
 '(lambda (x) (list x (list 'quote x))))

PS: This post is under 'mis cosas' (personal) tag, because there's much more than programming involved in the mind process to understand these things. So yes, quines are a cool concept even IRL.

Text Driven Development

2010-12-18T12:32:00.006Z

As I already posted, I got a new job in Barcelona, doing mostly apps in Rails (particularly ubiquo, cms)

Luckily, the company is pro-gnu, so I can use linux with all my usual configs. Using ratpoison in a double screen is an awesome experience.

For the moment I lived between the two worlds (gnome vs ratpoison) because I'm continuously asking things to more experienced people, and they usually want to use the mouse when they are on my computer. And I haven't configured everything yet.

Outlines

Last week, I was assigned a project and was given a 100+ pages document with the functional analysis of the project. First thing to do was reading it and making good outlines of it to create a mental model of the program.

I decided to use emacs org-mode to do the outlinings, and probably the TODOs and Schedules. IT's pretty neat, and doing everything with text files gives me a kind of relief, that everything is under control. In fact, that's one of the things that gets on my nerves about pharo. Being able to use your well known tools in a synergic way is great (IMHO)

UML

After that, I created an UML class diagram.
"We use argouml" someone said. Well, argouml has improved amazingly since the last time I tried it, but honestly, for me it doesn't cut. It has some kind of code generator (for java) and some design-critics, that seem cool enough to use it, but given that the web development constrains you to use minimal oop features, I could not listen to the design-lint.

After finishing the damn UML, I looked for other tools that could do pretty UML diagrams from ascii. And they do exist. Great! I'll try to use them the next time. I think plantuml is a fairly good option and, guess what? you can integrate it in emacs.

Slides

On the other side, on wednesday, I did a talk at smalltalk.cat about pharo regexes. The slides where presented in a terminal, in plain ASCII, using a small app borrowed from fxn. Btw, the talk went pretty well. Very informal and kind of simple for people versed in regexes (smalltalk regexes do not have any special unique feature but the opposite, a bit simple IMO), but I think maybe 30% of the people didn't know about regexes and used them just copypasting, so I extended my talk to touch some more theoric side, and in the end, I think everyone learned something.

Btw, if you feel like implementing a regex engine for smalltalk, you can get ideas from this paper. A good read IMHO

HAHA! You're not regular anymore!1

2010-12-02T19:53:00.007Z

Via HN I saw praprog released another magazine, this one fully dedicated to ruby (What a coincidence! :) )

I skimmmed all the articles but paying more attention to a couple of them:

One of them talk about new features of Ruby 1.9.2. It seems ruby is getting faster and faster on every release (a good thing since speed is one of the major 'problems' I had read about ruby).

Another place where it has improved is on the regex side. Now ruby regexes allow named captures (feature added to perl in 5.10 IIRC), and recursive regexes (The not-so-regular regexes are here) there are some flags like /x /g and /k, that let you reference captures more easily than plain old \1, \2 ...

All in all, quite cool stuff that makes me feel a bit more at (perl) home.

Unfortunately, I couldn't practice with rails yet. I did some progress on ruby koans though. A busy week in Tenerife.

I'm a LOL programmer (wannabie)

2010-11-20T22:46:00.002Z

In my new job, it seems I'll be writing ruby (on rails).

I've been trying the language in my spare time, and it seems a fairly good compromise between Perl and Smalltalk.

Except a couple of features or idioms I saw, everything else was quite intuitive or easy to understand (at least coming from Perl/Smalltalk).

+ Sigils do exist, but denote scope oposed to type.
+ __DATA__
+ '=' can be part of a method name. And there's some magic involved there. def method=(attr) can be used as an assignment (sintactically) as parens are optional.
+ Integer class can be expanded or subclassed.

Here are the codes I wrote to grasp the language. These are the usual examples I write in every language I try to learn:

- a program to center paragraphs.
- guessing number
- Network with hosts that pass messages one to the other.

Here is a link that I found useful about ruby patterns and idioms.
http://scriptlandia.blogspot.com/2009/02/design-patterns-in-ruby.html

Last but not least

2010-11-15T21:00:00.009Z

I'm leaving my current $work, and changing to another one. Being the first one I'm starting not as an university student but a 'professional' one feels strange, and I'm somewhat thrilled. Will I be good enough for the job? I hope so :)

These last days I'm reviewing some of my old code with the guy who will inherit my codes. A cool programmer, with lots of knowledge I wouldn't expect from an average young programmer (it's actually a bit older than me but, you know... not everyone reads 'refactoring', code complete, and GoF just for fun :) ). We've had good times. Transfering info would be quite more difficult without such a good learner. In little less than a week, he also explained me some ins and outs about some agile methodologies, or good programming practices (some cool refactorings, Log4X modules, etc...). We both learned quite a lot from each other.

Some of the neat advices that I liked.

- use Logging modules. They pay off. And they are quite easy to set up (opposed to what I thought)
- refactor any piece of code that is repeated more than 1 time (if it's easy to do). calling a simple join(',' , @array) three times in the same function can be refactored into a meaningful name sub. You get the name explaining what your code does, and if you want to change ',' to ':', only one change does it.
- Codes that you write separated by 2 newlines, like paragraphs, and start with a comment that explains what that snippet does, are screaming for a new function. You can use the first words of the comment as a hint for the function name.
- Take a look at AOP, it's cool. a really cool thing.

I'm in ur shell, watching your repos

2010-11-04T11:12:00.004Z

I'm using more and more a little script that Cornelius called cpans.sh (for cpan search)

It's dead simple, but great anyway, and, it lets me use ratfinder to browse cpan modules. And to give credit where the credit is due, I'll just embed his gist.

Simple idea, neatly used. curl, file tests, zgrep and some bash bits.

Courier new WTF (or, monospaced is not enough)

2010-10-18T12:09:00.006+01:00

Via reddit , I found this pearl:

From wikipedia:
Courier New is used extensively in programming. For example, online forums, such as phpBB, SMF, and vBulletin, will use Courier New for <code> blocks; on Microsoft Windows it is a default monospaced font for a variety of applications, such as Notepad, Visual Studio (although the Consolas font family is provided as an alternative

Seriously, if you have to write code, go and get a font that doesn't suck. Monospaced is not enough.

ubigraph: an interactive 3D graph creator

2010-10-15T08:24:00.012+01:00

A few days ago I read a funny post on HN. A guy was presenting some clojure code that used ubigraphto produce 3d navigable graphs.

To make ubigraph portable and interoperable with many languages, they present the app as an independent window (embedable, I hope) with its own process that acts as a XML-RPC server, so if you don't have an specific API for your language, you can use plain XML-RPC calls.

I've written a simple fibonacci function with a callback that draws the flow of the calculations.
Here's the code, and a (static) image of the graph.

To See how memoizing works, I've modified the code a bit using Memoize and a normalizer function and now we see how the number of steps is O(n).

ESUG 2010: It's awesomeness all way down

2010-09-19T21:16:00.005+01:00

ESUG 2010 was held at Barcelona (well, technically, Cornellà). For people that don't know what's ESUG, it's one of the most important smalltalk events worldwide.

A week full of talks, great fun, hours of hacking and chatting with other smalltalkers.

The weekend before the conference, citilab was open to all smalltalkers who wanted to participate in the SmalltalkCamp. Two days of coding and meeting with other smalltalkers. I started rereading the seaside book and got some help from Bernat. It was fun to see the creators of what I was trying to understand (seaside) walking and coding around. Another nice curiosity was when someone entered the SmalltalkCamp with an OOPSLA t-shirt. It was like: "wow, important people around!" :)

Monday, at 9:00 the conference started officially, but by then, I had already met some great smalltalkers. Here is the schedule of the whole esug.

90% of the talks where amazing, I mean, good contents, with an accurate dose of humour, and talks given by people with nice speech skills.

Xtreams (Martin Kobetic), Design decisions behing Patagonia(Hernán Wilkinson), All Esteban Lorenzano's talks (mars and reef), Helvetia (Lukas Renggli), Stephane Ducasse's talks, Richie and ..... too many good ones to remember the name of all.

Citilab made a great job organizing it all, and we, the local group had very little to do (thanks to volunteers too). Myself I just had to help some people with maps, subways and take some smalltalkers to 'visit' Barcelona. :)

I bought a special edition of the seaside book and got it signed by Ducasse and Renggli. WOW!

Well, it's been a short and late post, but I can't write a post with all cool things I learned there, so it's more a "I've survived" post than a "hey, look what they showed us".

Soon, citilab will make the recordings of ALL the talks available on the web. I think they'll be hosted in cincom's servers. I'll post about that when it effectively happens.

I met many people and had lots of fun talking not only about smalltak but technology in general, and life, universe and everything. Mostly argentinians but not only them. Gabriel, Gabriela, Hernán Wilkinson, Leandro, Richie, Javi, Nico, Ricardo, Esteban Lorenzano,... Great people.

Capture the flag with Moose

2010-09-07T11:42:00.016+01:00

In today's post, I'll show some ways to get program options via flags (--flags) I discovered recently.

CPAN is crowded with Getopt::* modules, but I'm going to explore the Moose universe.

Moose

At $work, we often have write commandline apps that end with lots of parameters and flags, and 'shift @ARGV' is not an elegant nor flexible solution. I've been using GetOpt::Long for years, but now, using Moose, I discovered an extension Called MooseX::Getopt.

MooseX::Getopt

This Moose eXtension allows you to fill attributes of an object directly from commandline.

We just have to use MooseX::Getopt in our Class, and change the creation of the object from Foo->new to Foo->new_with_options.

Tada!

Now, our program can get all Foo's attributes through the commandline. Note that if you try an invalid flag, it will output the accepted ones.

- But wait, I do not want to allow users initialize all attrs.

Ok, then we should hide the attr under a name beginning with underscore, and set the accessor to our desired name. MooseX::Getopt will understand you don't want it to be accessible through command line options.

MooseX::SimpleConfig

The summum of DWIM is you can also exploit the same introspection capabilities to enable configuration files to setup the execution of the files. And it costs you just one line.

with 'MooseX::SimpleConfig';

The code above will activate an extra flag (--configfile) where you can indicate where to reach the configuration file.

There are more goodies you can add on top of these modules, but for now, I think it's enough for me. :)

From these findings, you can see, Moose is not only a great OOP platform for perl but a higher level base for perl hackers to put stuff on.

Thanks Perl community.

Parallel::Iterator. Independent tasks are independent

2010-09-03T08:09:00.004+01:00

OH HAI!

Today's module is Andy Armstrong Parallel::Iterator. I discovered it through Dagolden's blog, and tried it by myself that same day.

The idea is simple. You may have many slow tasks to do that don't have dependencies between each other. A typical example is fetching for webs using lwp, but I can think of lots of processes doing similar things, for exmple, ssh-ing some command to many different servers.

So it's like an autothreading map. Well sort of.

As tasks are not guaranteed to end in order, and you probably want to know which source procuded each result, the function you'll apply to each element will have to take not one but two parameters, the first being just an index that you can throw away. At least it seems so. I'm not sure I understand it fully, but for the moment that's what I gathered.

The module provides two sets of functions, iterate, and iterate_as_(array|hash), iterate returning tuples ($index, $result), and the others returning the wanted structure.

But what puzzles me is that I cannot easily migrate a normal map to this parallel::iterator because functions sent to map have to accept an extra parameter (just to throw it away?). Two days ago I read another post related to it but it didn't comment anything about that 'strange' use of it.

So I hacked a higher order function that mimics map signature but uses parallel::iterator. I'm probably missing something because it's strange the author didn't provide something like that in the module. Anyway, here it is:

I'm using the iterate_as_array because I want to mimic map signature, so the array to iterate can't be lazy built. That's another feature of Parallel-Iterator : not only the evaluation of the method can be lazy but also the generation of the list.

Ideas? Suggestions? Insults? Go on and comment :)

Using AUTOLOAD to build html code

2010-08-25T09:40:00.004+01:00

Last week I found a new blog about Io. It's been a long time since I used Io, but maybe this blog will make me look at Io Language again.

In his last post, Dennis Ferron comments on _why's web server yown written in Io. One thing he comments is the slot 'forward'.

As he says, forward is a kind of catch that gets called when a message has been sent to an object and that object didn't have a selector with that name. _why exploits this feature to write an html builder based on that.

What he doesn't mention (I think he's leaving this for another post) is about lazyness. The way _why wrote forward method.

If you define a method without arguments but you call it with some, you can still access them, but with the difference that they won't be evaluated by default. That's called lazyness, and allows you to define the evaluation order of things.

So in the code


html(
  title("O HAI")
  strong("KTHXBYE")
)

forward will trap html message before title or strong.

In Perl, there's a 'lightning rod' function too, called AUTOLOAD. You can do pretty much the same, but the difference is that perl will ALWAYS evaluate parameters sent to a function before calling it, so the same code would trigger AUTOLOAD on the 'title' call, then 'strong', and last, 'html' and you have to fill the string from the inner tag to the most generic one.

Here's a gist code that emulates Yown Builder.io in Perl 5.

Good luck Dennis with your new blog!

--
raig

Memoizer in common lisp

2010-08-16T15:19:00.008+01:00

Last weekend I finished a fast-read of Ansi Common Lisp. I didn't do the exercices but I did pay attention to code examples (those are what make me really understand things).

Overall I find it pretty good, but a bit simple provided you already know something related to the lisp world.

After finishing it, I tried a couple of tricks in lisp, and was surprised how easy it was to come with working codes of a memoized function. Once you have a memoized function, why not convert it to a memoizer function?

Here it is. (If you're reading it on google reader you won't be able to see it, better read blogposts from the original site)


(setf memofib (memoizer #'fib))
(funcall memofib 10)

And you have now a faster fib than before.

Question: how should I change it to make a generic memoizer that memoizes not only unary functions.
In perl I'd have to just pass @_, I suppose changing arg to '&rest arg' and change funcall to apply would do the trick... I have to try it. Later.

More readings: Scheme R5RS.
I read the part I hadn't read before. I have to say even the scheme spec is minimalist, well written, and didactic. Following the language philosophy even at docs level. :)

And a bit more: A paper on Scheme macros. I think I get them, but I don't see much use for them. I suppose I'm still an average blub programmer.

Sharing interests with others

2010-08-12T21:35:00.005+01:00

Here's another of those shitty trackback posts that add nothing to the original post:

I've read a blog entry that explains what I think about sharing interests with others better than I could ever have written.

I found it in HN, so it talks about sharing prorgamming interests with your partner.

Another funny post of the same kind, in a Bug report format. Hilarious too.

Rakudo * is next door

2010-07-27T10:00:00.003+01:00

Yes.
Rakudo *, the first official distribution of stable (yet incomplete) perl6 interpreter rakudo. Devs haven't focused on optimizations but features, and it's quite useful as it is IMHO. It brings lots of the crazy Perl 6 features announced in the synopsis like hyperoperators, metaoperators, lazyness, junctions, introspectable OOP, and regex and grammars as first class citizens in the language. That last thing means you can plug a new parser for your program in lexical scope. Welcome DSL world. Early adopters, language geeks, perl hackers, you have no excuse now not to try rakudo :) .

Myself I haven't toyed enough with Perl 6 to do anything useful, but I have done quite a few conceptual tests, and, although I'm still baby-talking Perl 6, it's quite nice to hang around at #perl6 and see perl6 heroes stressing rakudo's features till the unthought limits.

More good news: Audrey Tang appeared a few days ago on #perl6 (I think thanks to masak's post), and started hacking on niecza (sorear's perl6 implementation focused on compiler and interpreter optimization techniques).

I tried to solve one of moritz's perl6 Challenge, implementing Str.trans (á la p5 tr// ) in perl6. Mine, is the (really incomplete babyperly) submitted on a gist pastie. I didn't win the rakudo T-shirt.

More on Perl6. A couple of perl6 related posts reached HN and reddit top page and stayed more than 1 day there. buzz buzz buzz buzz :)

And last but not least, Barcelona Perl Mongers are living a celebration, on July 29th of July, the R* Day (and being the last thursday of the month, which is the usual meeting day) will join at UPC Campus Nord, and Alex Muntada will give a Perl6 introductory talk. Of course, you're all invited. Unfortunately, I won't be able to be there as I'll be in Malta. O HAI Holidays!

Happy 1st anniversary

2010-07-27T09:52:00.004+01:00

Back to the future?

2010-07-13T00:17:00.006+01:00

9:00
Llego al currele, y mientras estoy haciendo mi navegacion de
reconocimiento, encuentro porahí un link interesante: Google’s
Do-It-Yourself App Creation Software. Alguna frikada de google
labs... ya verás. Total, que empiezo el articulo y leo que el
proyecto esta liderado por un tal "Harold Abelson". H.Abelson en
google? (pues se ve que se ha pillao un sabático del MIT). Bueno, el
proyecto va encaminado a que todo el mundo pueda ser programador de
sus miniaplicaciones.

17:00
Recibo un mail en una maillist Que pone "se nos acabóo el trabajo".
Coño! Esto es scratch!!!
Reflexión: Los Schemers chupando de smalltalk? Bueno, puede ser,
entre comunidades pioneras... pero en google, hacen algo en
scheme/smalltalk? Bueno, de hecho, scratch tambien sale del MIT, creo.

17:30
Llego a la pagina oficial del proyecto y efectivamente al final de la pagina.
(...) Open Blocks visual programming is closely related to the Scratch
programming language, a project of the MIT Media Laboratory's Lifelong
Kindergarten Group.

The compiler that translates the visual blocks language for
implementation on Android uses the Kawa Language Framework and Kawa's
dialect of the Scheme programming language, developed by Per Bothner
and distributed as part of the Gnu Operating System by the Free
Software Foundation. (...)

18:00
Me pregunto si contestar al mail de la maillist contando de donde
viene todo esto, quien es Abelson, y entro en otra
batalla épica? Respondo con un : "joer, estos de google son la ostia,
estas cosas, solo las pueden inventar ellos...", me callo?.

En fin... Esta claro que poco a poco van alcanzándonos, pero la
verdad es que me encanta estar en este mundillo (pionero después de
casi 30 años), y estas aproximaciones que hacen 'los grandes' le dan a
uno la confirmación de la sospecha: "yeah, voy un paso por delante,
que se jodan" :D

Wasn't there a command to do XYZ?...

2010-07-12T09:14:00.005+01:00

At $work, many times I'm asked about ways to optimize little annoying processes of other people (I'm a kind of office enabler).

There's a typical dialog of some $coworker, and $self.

- Hey Rai, I've got a little question for you.
- Ok, go on.
- Wasn't there a linux command to put lines of two files in one file, one line after the other? Like a columnwise join.
- M... yeah... I think so. Was it 'join'? Nah, man doesn't seem to say anything about it... Well, you can use Perl, you know, the swiss knife.
- Yeah, but I don't think a script is needed, For now, I'm doing it with excel, you can copypaste each file in different columns, and then save as CSV, then you just have to remove the commas, using vim.
- ¬_¬ .... Gimme 30 secs.

echo 'a' >a
echo 'a' >>a
echo 'a' >>a
echo 'b' >b
echo 'b' >>b
echo 'b' >>b
perl -e 'open $a,shift;open $b,shift; while(chomp($_=<$a>)){print $_, scalar(<$b>)}' a b

output:
ab
ab
ab

Redirect STDOUT to file in Perl 5

2010-06-30T12:53:00.008+01:00

Every now and then, I need to write little scripts (or not so little) that output *lots* of lines of text. Those lines belong to a single file, so my common idiom is printing the output to STDOUT, and tell the user to redirect the output to a file if he wants it toasted into a file.

But there's a more elegant way to do it that doesn't rely on shells, and works more consistently. In fact TIMTOWTDI.

One way is fill the code with:


if ($outputInFile) { print $file "foo";}
else{print "foo"}

/me shivers ...

I found a way to do it quite elegantly redirecting a file handler where I'll be printing to STDOUT, using Typeglobs. I'm not too confident managing typeglobs, but it seems to work :)

I asked at #barcelona.pm and alexm (O HAI! president) told me I could think it the other way around, and overwrite STDOUT to an opened filehandle in case I needed the redirection. I didn't know I could handle STDOUT like any other fh. It's nice to know it.

I think Casiano taught me (back in university times) another way to do it (maybe it was using tee, or some IO::Handle funky stuff).

Is there any cpan module that does that kind of Stdout vs file output? I haven't found it, but it MUST be there. Or maybe the code to do it is so small it doesn't make sense writing a module for that

Algo pasa...

2010-06-23T00:40:00.000+01:00

Cuando tu bandeja de entrada esta llena del mismo nombre.

Kill Buffers Illustrated (emacs)

2010-06-21T12:50:00.010+01:00

A side effect of using emacs intensively is that you end with lots (I mean *LOTS*) of open buffers scattered on your emacs.

This is not necessarily a problem (provided you use ido/iswitchb/icicles modes), but it kind of gets on my nerves having 30+ buffers opened knowing that I don't need them anymore. Most of them are temporary buffers like dired-mode ones, or perldoc ones. Like most things in emacs world, someone has already thought of it and there is already a function to do what you want.

For example, scattered dired-mode buffers.


(defun kill-all-dired-buffers()
 "Kill all dired buffers."
 (interactive)
 (save-excursion
   (let((count 0))
     (dolist(buffer (buffer-list))
       (set-buffer buffer)
       (when (equal major-mode 'dired-mode)
         (setq count (1+ count))
         (kill-buffer buffer)))
     (message "Killed %i dired buffer(s)." count ))))

And you're done.

great, isn't it?

What if you want to purge some buffers, that have no name in common, nor mode? You can kill them one at a time with kill-buffer (c-x k) but if you want to do it faster, you can use Buffer List buffer.

c-x c-b will open a buffer with a list of all buffers. That's not a normal (Fundamental) buffer, but a 'Buffer Menu' buffer. If you press 'd', the buffer that has the point (cursor) will be marked for deletion. Once you have the list of buffers to kill, just press 'x', and buffers will be killed.

If you press 'x', 3 erc buffers will be killed. Mnd you, once a buffer has been killed, it cannot be unkilled. :)

That's all for now.

I ♡ TITS (TIAS)

2010-06-11T09:37:00.015+01:00

There's a (sadly too common) practice consisting of asking about something before having tried anything related to it. I mean, if you're working on nuclear fision, better ask first, but if you're trying a software library, or want to know which advantage gives you using this db vs that other one, just TIAS (or its NSFW version TITS The link is SFW, don't worry). This will give you a fairly good overview of what does this language/lib/anything can do for you, and how easy/difficult is FOR YOU to use it.

erlang
haskell
redis
mongodb
clojure
scheme
python (or this if you have MS Silverlight)

Btw, combo pun for the ones that came to the last Festa FIB '10. A pun on a pun on a pun on "I love ..." T-shirts .

Talk talk talk

2010-06-10T10:53:00.007+01:00

A new conference was born 3 months ago. It's called Emerging languages, and it will take place this summer. It'll be full of language designers, talks about innovative programming languages, and *lots* of enlightening ideas (I'm sure). There will be talks about lots of langs all by the language designers. Myself, I'm particularly interested in Io, Ioke , Newspeak, Factor and Clojure.

The bad thing is that it's going to be held in OSCON 2010, so It's a bit far from me... Let's hope there will be recorded talks after summer.

It seems this summer I'm not going to YAPC::EU neither, so I'll have to take my conference dose from somewhere else.

Luckily, there are lots of good talks already recorded .

Erlang and haskell

scheme talks

Google Io sessions

And lots of good papers to read:
ClassicCompScienceTexts

Any other suggestions are very welcome.

You can stay at $HOME, Perl :)

2010-05-12T09:38:00.012+01:00

Evolution is the way to keep up with times, and lots of things are happening in the perlsphere lately:

Perl 5.12 went stable on April 2010, with lots of fixes, and a few new features. See the deltas.
Rakudo is making progress at a good rate, with new contributors, and it's getting faster and more complete every day. Parrot guys are doing a great job there too.
cpanminus seems to be the next big thing of the language, and it's a perfect companion of local::lib and even perlbrew.

Cpanminus is miyagawa's (quite successful) attempt to simplify CPAN.pm, in a DWMI-Y way. by default, it follows dependecies, uses your prefered path to install modules (it knows about local::lib) , and will just install and get out of your way. It's better for perl newbies (and pseudo-newbies like me) and speeds up the installation of the whole environment.

local::lib is one of the wizard mst's magic spells to enable local repositories of libs per project. That means you can attach cpan libs to your apps, and then control the exact version you ship with each app.

the complete install process of the environment is the following:


mkdir ~/myperltmp
cd ~/myperltmp
wget cpanmin.us
chmod +x cpanm
wget http://search.cpan.org/CPAN/authors/id/M/MS/MSTROUT/local-lib-1.006000.tar.gz
tar zxvf  local-lib-1.006000.tar.gz
cd local-lib-1.006000
perl Makefile.PL --bootstrap
make test && make install
echo 'eval $(perl -I$HOME/perl5/lib/perl5 -Mlocal::lib)' >>~/.bashrc

And now you're ready to go.
./cpanm DBIx::Class
./cpanm Moose

And with 0 questions, you'll have DBIx::Class and Moose in your ~/perl5 directory.

If you added the last line to your .bashrc, then everything should work. You can use local::lib "~otherpath"; to have multiple scenarios to try your modules/apps on. Next thing to try is perlbrew, but that's for another day.

Mainly I extracted the info from here and here (and perldocs, of course)

Before leaving, let me leave you with a great talk by mst. Full of info, and full of lolz, and nearly no swearing (Wow! surprise!)

Comparing functions. How similar are we?

2010-05-05T12:13:00.009+01:00

Sometimes I have two functions, maybe in different subclasses, and I would like to do a diff on them, because they look very similar but not the same. Most of the times, they are come from a past copypaste, so variables have the same names.

What I want to know then is what has really changed, or if they changed at all.

#in file foo/bar.pm
sub normalize {
my ($self) = shift;
$self->attr($self->attr / $self->total);
}

#in file foo/baz.pm
sub normalize {
my ($self) = shift;
$self->attr($self->attr / $self->total +1);
}

Emacs comes to rescue!

We'll use two great emacs features, narrow and ediff.

narrow lets us hide uninteresting parts of a given buffer. It's usage is pretty simple: Mark a region, m-x narrow-to-region (or c-x n n). There's also a shorctut, and there are predefined narrowings, like narrow-to-defun... you know, emacs butterflies.

Once you narrowed two buffers to the interesting regions, you can use ediff (m-x ediff-buffers) and select the two buffers you want to narrow.

To widen the narrowed buffers, you can 'm-x widen' (or c-x n w) to see the complete buffers again.

Tip for ratpoison users (or any other tiling wm user): (setq ediff-window-setup-function 'ediff-setup-windows-plain) in your .emacs will tell emacs to open the ediff window in a different window, but not opening a new frame. (window and frame have inverse meanings in emacs world than in the rest of the world)

theese would be the steps:

open bar.pm
go to normalize function.
c-m-h (mark-defun)
c-x n n
open baz.pm
(steps 2-4)
m-x ediff-buffers
select both buffers (emacs will suggest them already)
check diffs
q (quit ediff-mode)
c-x n w (widen)
go to the other file, and widen again.
You're done

Endnote: Although being a big fan of vim myself and having used it for 5 years, these features available in emacs by default, are not (at least easily) doable in vim. emacs, the kitchen sink, and m-x butterflies DO have their uses :)

Fiuchar is nau

2010-04-30T18:23:00.007+01:00

Es acojonante interactuar con el mundo. Unas veces ganas, otras no, pero interactuas. Y eso mola, no me jodas.

Lo que recientemente me sucede, y me doy cuenta, es que el futuro esta íntimamente relacionado con el presente, y aunque eso parezca una trivialidad, no siempre soy consciente de ello.

En la historia que no sale en los libros, la del día a día, la mía, y seguramente la tuya, uno mismo es el prota de su película, y si no esperas nada más de ella que ir pasandolo bien minuto a minuto, pues no importa mucho a donde te lleve el proximo capítulo. Carpe Diem.

Pero no hace falta tener previsiones a años vista para ver que tus pasos no son gratis. Cada movimiento es un turno, y eso ya no vuelve. Y la jugada que empiezas ahora, te condiciona tu siguiente turno. Y pasar no entra en las reglas del juego. Llamémos a este epsilon de tiempo, "el proximo turno".

Una entrevista de trabajo mal llevada, te cierra puertas a currar, a dejar el curro, o a cambiar de ciudad.

Un policía que casi te pilla, te podía haber jodido tu expediente, o tu carnet. Y tu estabas jugando en el juego. Un borracho que por la calle te pega un puñetazo porque ha ganado su equipo, te deja, a parte de en el suelo, te deja pensando en que cojones haces viviendo un día a día, que no te lleva a ningun lado, porque simplemente apuntas a media altura, apuntas a mañana. al proximo turno, pero solo con llegar ya te basta.

Un paso mal dado, te puede dejar cojo, y no poder irte de viaje, aunque ya hayas pagado tu billete. Pero esto no es como Dallas, donde te puedes inventar que la muerte de JR era un sueño. Los turnos pasan, y cada jugada es una opción de encarrilar, o cagarla.

Este próximo turno (futuro immediato) se crea a partir de esta gran bola de mierda que es el presente, y que va ladera abajo, llevandose por delante todo lo que pilla. Y es tan grande y gorda, que uno no la puede parar conscientemente. Digamos que es una version del S.XXI del concepto del "train of knowledge"(al final) y Quality que conocí en Pirsig, paralelismo del tren, pero remasterizada, actualizada, y con 7 segundos inéditos. Los del puñetazo.

DOCS or GTFO

2010-04-30T12:29:00.011+01:00

Ok, you hate documenting. But it's part of the deal.

As you may know, there are tools that generate browseable documentation provided you document your code in a proper way.

Perl is no exception, and you can convert POD documentation to html, formatted plain text, LaTeX, etc...

To ensure you documented (at least, put the boilerplate) every non private function in your code, there's a module called Pod::Coverage that checks for undocumented functions, parsing your code, parsing your pod, and doing the match, and the diff.

Once that we're at it, we can bundle the check as a test for our application, and, in fact, there's Test::Pod::Coverage, that is exactly what we're looking for.

Ok, let's write a minimal module (BankAccount will do), using the right tools for each job.

module-starter --module=BankAccount --author="Raimon Grau" --email=raimonster@gmail.com --builder="Module::Install"

This will generate all the boilerplate and the directory scaffold needed, and it will include (at least if you have both packages installed).

This code will fail the pod coverage test, because the method withdraw is not documented.

Well, we have a new tool in our toolbox, that makes sure at least every method has its associated POD documentation. The module won't force you to document subs starting with underscore (thank god for DWIM). There's also other modules that build on this, like the one RJBS explains here.

Iterator::Simple, as simple as it gets

2010-04-26T10:53:00.008+01:00

We're all feeling spring is coming again. That's not new though, so you could have guessed that after winter, spring was about to come.. ¬¬

We could build a circular list to retrieve a list of consecutive seasons, but as I discovered
Iterator::Simple, Here follows a stupid example of its usage.

We can also wrap an iterator, "á la" stream (I'm reading the stream chapter in SICP, and nowadays, I can only think in streams :p ), delaying the evaluation of the wrapping until the given elements are needed using imap. We also have ifilter, igrep, and so.

Here's a code that wraps (or decorates, in python slang IIRC) our iterator modifying the string returned, and it limits the iterator to 6 seasons.

Versioning in squeak/pharo using Monticello

2010-04-14T20:01:00.005+01:00

Lately I've been working on a simple website I'm doing in smalltalk. It's not a complex thing, but it's someway new being my first serious website I've done.

To build it I'm using pier and seaside. And it's mostly fantastic. But sometimes, all of the sudden, some unknown error occurs and my image freezes. And my last codes are lost. No way to recover it even using the recovery tool.

So I remembered something Mr. Ducasse said in the course he did in UPC. The idea is you could throw away your image every day, and start with a fresh new one, EVERY DAY.

One option is fileOuts and fileIns, and in fact, it's simple, reliable and it just works (tm), but you cannot store different versions, and if you did the manual filename juggling, the versions would not have any relationship between them.

Then, here comes monticello. A kind of apt-get + launchpad. It's a package browser and installer (no dependency tracking AFAIK), where repos can be lots of different places, from local directories, to squeaksource remotes, or ftp, or ....

The trick is opening a create a new package (+package button) with the name of the category you want to save. Then, it will appear in the left panel of monticello browser. After that, create a new repository (+Repository button) and add a directory where you want to save it. Then just press the save button.

When you open a new image and want to load the package, open monticello browser, open the repository (+Repository again), click it, and browse. There you'll be able to load the package, and once it's loaded, it will appear in the left panel of the main Monticello Browser.
In the second screenshot you see top left, the different repository types. on the right, the main Monticello screen with the two panels. My advise is to play a bit with it, selecting and unselecting items to get the feeling of it.

Btw, there's a new project related to source maintaining and versioning called Metacello that seems to be the next iteration of monticello, or "monticello done right", adding full support for package managing, being aware of versions and so. I'm just guessing as I'm a newbie in both projects and I just skimmed the docs, so please, correct me if I'm wrong.

MP3 fail

2010-04-12T12:56:00.008+01:00

Me compré un mp3 y ha ido conmigo a todas partes. Y con él comparto momentos en los que él pone la banda sonora a mis accions, y a las situaciones en las que me veo envuelto.

Es capaz de potenciar una situación, o apartarme del mundo. Un perfecto aliado. Hasta he ido a discotecas a escuchar mi mp3 (HAI TENERIFE). Y a pasear a las 5AM. Me ha hecho conocer gente, y ha dormido en casas ajenas, siempre como una extension mía, como un embajador.

Lo habrán escuchado unas 100 personas distintas.

Me lo compré el 12 de Abril de 2008, lo cargué de música, y no la cambié jamás. A medida que lo escuchaba más y más, me recordaba a cada una de estas 100 personas. Pues el 10 de abril de 2010 dejó de funcionar. Kaput. 2 años menos 2 dias. Con las mismas 2 Gigas.

La pregunta es: Debo llenar mi nuevo mp3 con la misma música?

Portishead, Fat Boy Slim, Michel Camilo, Pearl Jam, Mama ladilla, Janis Joplin, Rare Earth, Ten years after, Zuco 103.

Ya veremos si os vuelvo a ver en mi bolsillo...o os cambio por Mika ;).

Si cambio, una que cae seguro va a ser move to the city.

Parece un cutre-post (y seguramente lo es), pero mi compi de viajes se merece una mencion. ¿no?

First step to Zurich

2010-04-01T11:09:00.007+01:00

Many of you know that I've been skimming job-hunting sites. I'm not to change unless I find a cool job.

Well, after talking to a good friend and wise advisor, he told me to go hunting myself. Real good jobs have to be seeked in a smart way.

So I did, and I send a few CVs to cool companies where I would really love to work. And one of those, is (yeah, you guessed) Big Bro^WGoogle.

The surprising thing is that they answered me, and told me They'll contact me further, explaining the process of the interviews and so. I don't know if I'll be able to talk further about it, so...

I'm extremely excited, but today, being the April 1st, I thought for a moment, it could be an April Fools' Day joke. I hope not...but you never know... Google acts in mysterious ways :)

A journey of a thousand miles begins with a single step.
Lao-tzu