Since then, I also tried several frameworks, such as Appcelerator Titanium Mobile but was especially satisfied by a relatively recent one, using only web technologies: Sencha Touch 2.0.
My main concern about Titanium Mobile is that the generated application was not behaving the same on Android and iOS (and was not working on iOS).
After writing code and testing on Android, I was very frustrated that it didn't work out-of-the-box on iPhone.
I didn't really have time to investigate the problem, but it gave me a bad image of the product.
That's how I ended up trying Sencha Touch 2.

A quick summary of the strengths and weakness of Sencha Touch 2.

Strengths:

• Rapid testing (inside the browser)
• Good User Interface API
• MVC Design Pattern
• Provides a GUI for quick mockup (Sencha Architect)
• Pure HTML5/CSS3

Weaknesses:

• New, working fine on Mac (from what I heard/read), but unstable on Windows/Linux*
• Is limited by the cross-domain security that prevents from fetching data from other domains that do not?explicitly?allow it if ran in the browser (not packaged as an application)
• Needs to be integrated into another framework such as PhoneGap (Cordova) to be packaged as a real?application*
• Tiny visual difference between the desktop browser rendering and the smartphone browser rendering (text is not coloured in one of the pages)

*The Sencha command-line is supposed to provide packaging, but doesn't work well on Linux so I had to integrate the app inside a PhoneGap project to deploy as a real?application.

It took me about 8 working hours (a geek weekend) to build a simple application from scratch.
For testing, I created a small application that allows you to add transactions to the easy online money management service Buxfer, which provides a JSON API (Sencha Touch 2 can easily handle data coming from JSON/JSONP objects).

The application is very basic: 3 tabs (Home, Add and Logout).
On the Home tab, I list the accounts and the last transactions.
On the Add tab I allow to add a transaction (an expense or an income).
And the Logout tab will log the user out.

The application works very well on the desktop browser, and it's really fast to test our program:

However, there are a few differences on the real?application on the smartphone:
- There are no colours on the accounts balance listing (should be green if positive, red if negative)
- It's hard to make the checkboxes on the Add tab activate (touch)

I recorded a video of the real?app running on my phone, not really good quality but gives an idea of the rendering:

As we can see, it's still very nice, and I'm sure the little problems will be fixed soon.

You can find the source code of that application on BitBucket: Buxfer Mobile

Next time, I'll try another promising mobile framework: jQuery Mobile.

The requirements of the program are the following:
- login to an external website I am not the owner through POST requests and store the session
- fetch several pages on that website (logged in, multithreaded)
- provide a login window, a window with a table (grid) to display the data fetched
- provide the possibility to open the webpage we have logged in, being logged in

Additionally, it would be great if we could have:
- easy packaging and distribution
- multi-platform (Win/Linux/Mac)
- rapid development

I tried Visual Studio 2010 C# edition and created a WPF Application.
Unfortunately, I found out afterwards that WPF is not supported by Mono, the free implementation of .NET for Linux/Mac.
So unfortunately, the "multi-plateform" point was not achieved.
However, all the other points have been reached, and in less than a day, from scratch, my first C# application was up and running:

What it does:
- Login to http://www.kingsofchaos.com (an old online MMORPG game not really popular anymore).
- Gives choice to scan a given number of battlefield pages from a given page.
- Show the results and allow to sort by columns.
- Open the stat page of a given player by double clicking on the row.

Download: KoC_Toolbox.zip

Let see in this post how we achieved that, and what are my first-thoughts about C# programming.

Behind the scenes, we first have a simple HTTP POST request.
We also want to save the user login/password so he/she doesn't have to enter it every time he/she starts the application.

C# provides a very simple Settings.Default feature to hold application configuration:

That we can use like below:

        public LoginWindow()
        {
            InitializeComponent();
            if (Settings.Default.KoCUsername.Length>0)
            {
                usernameTextBox.Text = Settings.Default.KoCUsername;
            }
            if (Settings.Default.KoCPassword.Length > 0)
            {
                passwordBox.Password = Settings.Default.KoCPassword;
            }
        }

For easy HTTP requests (POST/GET), I found a very good base snippet by Kersny that I re-use in my application:
https://gist.github.com/865296

I added the XMLHttpRequest feature to the class for my own needs, by took that base.
Now we can easily handle the web requests.

Example to login:

        public bool Login(string username, string password)
        {
            var postData = String.Format("usrname={0}&peeword={1}", username, password);
            var result = _req.HttpPost(GetUrl("login.php"), postData, true, GetUrl());
            return IsLoggedIn(result);
        }

Visual Studio, as we can expect from Microsoft, integrates very well C# and WPF.
It's very easy to find and attach UI events to actions:
We can graphically draw our window, and also edit its XAML code:

And add methods to events, such as a Click event on the Scan button:

The next step is to fetch many pages (from 1 to 100) asynchronously and quickly (so using multi-threads).
There are many ways to do that in C#.
First, I tried the Thread class, but it has some issues with WPF windows that are not in the same thread.
So I moved to the WPF Dispatcher, which is nice for quick UI modifications, so I use the Dispatcher to update the labels and other UI elements.
For heavy tasks, such as loading and parsing hundred of pages, a combination of Threads/Dispatcher can be used, or a so-called Parallel class that handles parallel programming.

More information about Parallel: http://msdn.microsoft.com/en-us/library/dd460703.aspx

However, I was not satisfied by the performance of Parallel, which is muuuuch slower than my C/C++ multithread version of the tool (the main one).
So I searched online for an alternative and found the Task class, which seems a good option.
Indeed, the performance is better (I don't have figures to support my words though....) but still much slower than its C/C++ equivalent I wrote a few years ago.

But it's really easy to write (contrary to my C++ version....), for example:

            for (var p = startPage; p < startPage + numberOfPages; p += 1)
            {
                var page = p;
                var t = Task.Factory.StartNew(() =>
                {
                    List enemies = _koc.GetBattleFieldPageEnemies(page);
                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        ((KoCUserDataContext)DataContext).AddEnemies(enemies);
                        progressBar1.Value += 1;
                    }));
                });
                tasks.Add(t);
            }

Finally, we want to open a web browser window when we double click on the row.
We need to pass the cookies to the web browser, and I had to find a workaround using a DLL to do that.
It's not ideal, but it's working:

        public void Navigate(string url, CookieContainer cookies)
        {
            var uri = new Uri(url);
            foreach(Cookie cookie in cookies.GetCookies(uri))
            {
                InternetSetCookie(url, cookie.Name, cookie.Value);
            }
            FieldInfo fieldInfo = webBrowser1.GetType().GetField("_axIWebBrowser2", BindingFlags.Instance | BindingFlags.NonPublic);

            if (fieldInfo!=null)
            {
                dynamic activexObject = fieldInfo.GetValue(webBrowser1);
                activexObject.Silent = true;
            }

            webBrowser1.Navigate(url);
        }

And... that's it!
Our application was done in a few hours, from zero C# knowledge (but programming skills of course).

Besides, packaging and distributing the application is really easy.
There is a "Publish Wizard" in Visual Studio that allows to deploy the application to a FTP server.
I just had to provide my FTP access, and Visual Studio automatically depoyed the application!

The deploy URL is: www.koc-fr.com/koc_toolbox/install.html
Unfortunately, the EXE is not signed with a valid certificate so Google consider it as malicious and warn the user:

Besides, it seems not to work with Internet Explorer... I need a special web server to handle it (with Front Page Server if I understood well).
Anyway, the setup.exe file is working, and if you ignore the warning and install it, it just works!
It will download the required libraries automatically if you don't have them already.

Moreover, it has a built-in update manager so I can publish new versions in one click and it will be automatically be detected when the client launch the application so they will be asked if they want to update the application.

That's a real delight, but available only on Windows (because I chose WPF as the UI framework).
Java also has very easy packaging, but that's even easier than that.
And compared to Python/Ruby, that's way easier.

I created an archive of the setup.exe file if you want to install the tool (you need a Kings of Chaos account though): KoC_Toolbox.zip

Finally, the complete source code of the program is available publicly, because open-source rocks:
https://bitbucket.org/ThomasDalla/koc_toolbox/src

Feel free to contribute to the code, but please note that I do not plan to maintain the tool, it was just for programming purpose.

The following piece of code grabs the image from the clipboard and directly prompts you where to save the file.
Depending on the filename you choose, it will automatically apply the correct compression (bmp/png/jpeg...) thanks to the Python Image Library (PIL).

In addition to the libraries bundled with Python you only need to install PIL, either from PIL or from PILLOW.

I personally chose pillow:

$ pypm install pillow
The following packages will be installed into "%APPDATA%\Python" (2.7):
 pillow-1.7.6
Hit: [pypm-free.activestate.com] pillow 1.7.6
Installing pillow-1.7.6
Fixing script %APPDATA%\Python\Scripts\pilconvert.py
Fixing script %APPDATA%\Python\Scripts\pildriver.py
Fixing script %APPDATA%\Python\Scripts\pilfile.py
Fixing script %APPDATA%\Python\Scripts\pilprint.py

You are now ready to run the script:

import os
from PIL import ImageGrab # from PIL or PILLOW
from Tkinter import Tk
from tkFileDialog import asksaveasfile
import tkMessageBox
import subprocess

if __name__=='__main__':

    # hide the Tk window
    root = Tk()
    root.withdraw()

    # grab the image from the clipboard
    myimage = ImageGrab.grabclipboard()

    # quit if it's not an image
    if myimage is None:
        msg = "The clipboard does not contain an image."
        tkMessageBox.showwarning("Error", msg)
        exit()

    # choose where to save the file
    fout = asksaveasfile(mode='w', defaultextension=".png")

    # quit if the user canceled saving the file
    if fout is None:
        exit()

    # finally, save the file (extension will dictate the compression)
    try:
        output = fout.name
        myimage.save(output)
    except Exception, e:
        msg = "Error: %s" % e
        tkMessageBox.showerror("Error", msg)
    else:
        filePath = os.path.abspath(output)
        #tkMessageBox.showinfo("Saved", filePath)
        subprocess.Popen(r'explorer /select,"'+filePath+'"')

To use it, simply hit the "Print Scrn" key and run the script.
Running the script is not that faster than starting Paint so you could create a shortcut to the desktop and create a Shortcut Key to the shortcut.

For example to set a shortcut to "Ctrl + Alt + P":

Now simply hit "Print Scrn", "Ctrl + Alt + P" and choose where to save the screenshot, that's it!

For example if your VM IP address is 192.168.31.128 (in NAT mode):

You should run the server by calling (you can change the port):

python manage.py runserver 192.168.31.128:8000

Now you need to connect to the website specifying the IP address like that: http://192.168.31.128:8000.

Both from the VM:

And the Host:

The server running on Linux is much faster than the one running on Windows

Let see two different ways of doing so.

1. py2exe

Pros

• Easy

• Support multiple binaries

Cons

• Might miss some dependencies

Download

Py2Exe Website
There are binaries for both win32 and win64.

Basic setup

basic_setup.py

from distutils.core import setup
import py2exe

setup(
    windows = ['pysideApp1.py','pysideApp2.py'],
    options = {
        "py2exe" : {
            "includes" : ['sys', 'tempfile', 'zipfile', 'mmap', 'encodings',
                          'json', 'hashlib', 'datetime', 'struct',
                          'os', 'time', 'random', 'math', 'xmlrpclib', 'Crypto']
        }
    }
)

Compile

$ python basic_setup.py py2exe

That's it!
Look in your "dist" folder and you should have your application

2. PyInstaller

Pros

• Seems to detect the required libraries much better

Cons

• Last stable version (1.5.1 as today) does not support multiple binaries
• Need a little more config

Download

PyInstaller Website
No need to install, just extract somewhere.

PySide setup

pyside.spec

import os

a = Analysis(
    [os.path.join(HOMEPATH,'support\\_mountzlib.py')
        , os.path.join(HOMEPATH,'support\\useUnicode.py')
        , os.path.normpath(os.path.join(currentDir, 'main.py'))
        , os.path.normpath(os.path.join(currentDir, 'importantLib.py'))
        # add the files you want PyInstaller to analyse the "import" statements
        # to detect the libraries to include
    ],
     pathex=['C:\\Python27\\pyinstaller-1.5.1']
)
pyz = PYZ(a.pure)
exe = EXE(pyz,
          a.scripts,
          exclude_binaries=1,
          name=os.path.join('build\\pyi.win32\\build_output', 'your_application.exe'),
          debug=False,
          strip=False,
          upx=True,
          console=False )
coll = COLLECT( exe,
               a.binaries,
               a.zipfiles,
               a.datas,
               strip=False,
               upx=True,
               name=os.path.join('dist', 'dist_output'))

Compile

Move to your pyinstaller.py location and run:
$ python pyinstaller.py "C:\path\to\pyside.spec"

That's it!
Look in your "dist_output" folder and you should have your application

Postface

Both methods work fine.
The output folder with PyInstaller is a little bigger (~10MB, whereas the one with py2exe is ~8MB).
However, it seems to include more libraries, even though I didn't manually specified any specific library, I just gave the 2 main py files of my program, so maybe more reliable.

But some of you might be having troubles to install the nonfree google chrome web browser.
To install it, just follow the following steps:

1. Download the deb package on http://www.google.com/chrome
2. Open a command prompt and try to install it: sudo dpkg -i google-chrome-stable_current_amd64.deb

You will have the following normal errors:
Selecting previously deselected package google-chrome-stable.
(Reading database ... 127754 files and directories currently installed.)
Unpacking google-chrome-stable (from .../google-chrome-stable_current_amd64.deb) ...
dpkg: dependency problems prevent configuration of google-chrome-stable:
google-chrome-stable depends on libnspr4-0d (>= 4.7.3-0ubuntu1~); however:
Package libnspr4-0d is not installed.
google-chrome-stable depends on libxss1; however:
Package libxss1 is not installed.
google-chrome-stable depends on libcurl3; however:
Package libcurl3 is not installed.
dpkg: error processing google-chrome-stable (--install):
dependency problems - leaving unconfigured
Processing triggers for gnome-menus ...
Processing triggers for desktop-file-utils ...
Processing triggers for bamfdaemon ...
Rebuilding /usr/share/applications/bamf.index...
Processing triggers for man-db ...
Errors were encountered while processing:
google-chrome-stable

3. Now just type the following command: sudo apt-get install -f

And Google Chrome will install!

In addition to start the application only once, we can send the arguments of the later calls of your program to the first (and only remaining) instance.

The following video summarizes the features:

The idea is to use the QLocalServer / QLocalSocket classes to perform the check and communication between the instances.

First, we create a socket and try to connect to the server, registered with the application name.

        self.m_socket = QLocalSocket()
        self.m_socket.connected.connect(self.connectToExistingApp)
        self.m_socket.error.connect(self.startApplication)
        self.m_socket.connectToServer(self.applicationName(), QIODevice.WriteOnly)

If the connection works, it means a server has already been registered, so the application has already been started and we try to connect to that existing application.
If we the new call has been made with arguments, we send them to the already running application (the first one only in this example, adapt to your needs for all).
If the new call has been made without any arguments, we notice the user that the program is already running and we quit.

    def connectToExistingApp(self):
        if len(sys.argv)>1 and sys.argv[1] is not None:
            self.m_socket.write(sys.argv[1])
            self.m_socket.bytesWritten.connect(self.quit)
        else:
            QMessageBox.warning(None, self.tr("Already running"), self.tr("The program is already running."))
            # Quit application in 250 ms
            QTimer.singleShot(250, self.quit)

If the connection fails, then it means this is the first instance of the application so we start the application and register a server listening to future applications.

    def startApplication(self):
        self.m_server = QLocalServer()
        if self.m_server.listen(self.applicationName()):
            self.m_server.newConnection.connect(self.getNewConnection)
            self.mainWindow.show()
        else:
            QMessageBox.critical(None, self.tr("Error"), self.tr("Error listening the socket."))

You can retrieve the complete source code at Gitorious: qSingleApplication.py

Now it's time to challenge QtRuby (and Ruby in general) with PyQt/PySide (and Python in general).

Due to some reasons, I had to write the same program in both languages.
Thanks to that, I better understood myself the pros and cons of both languages and will try to share my thoughts with you.

A very brief summary would be: Ruby is the winner for programming pleasure and private applications while Python is the winner when it gets serious.
For more information, read the whole post!

Background

I wanted to write a new GUI program, basically uploading pictures to Twitpic (the real goal is beyond that but let's make it easy).
Being a Ruby fan, I started to write my code in Ruby 1.9 with the "qtbindings" gems.
For my application, I also needed other gems like the "zip/zipfilesystem", "digest/md5" or "json".
As always with Ruby, everything went fine and after about 16 hours I had my application working.

Came the moment to send the program to beta testers.
To make it simple for them, as not all of them are familiar with programming, I wanted to bundle the program in an executable with all the required DLLs, as I used to do in C++ with Qt.

Lucky me, there is something called “RubyScript2Exe” (or “AllInOneRuby”) that can do it for you!
Unlucky me, it’s not working at all! It always raises a fatal error, even with the simplest QtRuby script…
A “can’t modify frozen string (RunTimeError)” that many people seem to have and no fix available yet…

Well, there is another one called OCRA (One-Click Ruby Application Builder) that looks more serious.
It works with basic QtRuby scripts, but unfortunately not when we require some dependencies, like “zip/zipfilesystem”. It posted on their Google Groups and hopefully a solution will be found, but so far… nothing!

That’s good to be able to quickly write programs that do their job, but it’s very frustrating when you cannot distribute them to others!
For beta testers, I could tell them to install Ruby 1.9, the required gems, Qt 4.7, and send them directly the source code, but it’s not convenient at all for them, especially if they don’t really have time to waste…

Another solution was to switch to Ruby 1.8 instead of Ruby 1.9 that I was using and hope that it works.
However, I am simply unable to run my code under Ruby 1.8 as the qtbindings are not recognized by Ruby 1.8 (even if of course I install the gem… :s).
I posted the problem on stack overflow, and, hopefully I will be able to edit this post and write that I managed to make it work on Ruby 1.8, and, with even a lot of luck, to bundle the QtRuby package with Ruby 1.8!
But for now, trying to bundle my QtRuby application just fails enormously…

So I decided to re-write the program in Python, as Python and Ruby are often compared; Python being more accepted among professionals.

Switching to Python

In Python, there are two different Qt4 bindings: PyQt4 and PySide.
They are very similar, except the licence.
PySide being supported by Nokia (which now owns Qt), I chose PySide.

Before anything else, I first tried to compile a very basic PySide program into a binary (an .exe for Windows).
There is a tool called py2exe so I tried that one and… it works very well! (Unlike RubyScript2Exe…)
I added some “import” and made some basic calls and… py2exe just worked well.

Accepted! I was ready to write my program again, but in Python!
The good thing is that I already had the “brain” of my program and new how to do it.
I just had to change the syntax from Ruby to Python, which was done quite smoothly.

It took me again about 16 hours to re-write it and add some extra features and error control.

The result is looking just exactly the same:

The only differences are because I did not copy exactly the position and size of all the elements…

But the code is very different so let see the differences between Ruby and Python!

Similarities between Python and Ruby

First let’s talk about the similarities.

Indentation

A lot of people talk about the “whitespaces” in Python, that force you to indent your code otherwise Python does not understand it… Honestly, it is so transparent that you just forget it after a while!
I mean, when you write code in C++ or Java or whatever, you indent your code (or your IDE does it for you). It is just so natural that there is just nothing to say about it.
My Ruby code had an indentation of 4 whitespaces, and my Python code too.
I didn’t feel any difference between the two languages as for the indentation…

Object Programming

Ruby is 100% object programming, Python… is?
It seems that recent Python is also fully object oriented and I did not feel any problem with “int” or “str” that are well handled in both languages.

Libraries

For the needs of my project, both languages had the required libraries, built-in or through easy to install libraries or gems.
It is said that Python has more libraries, and I am sure it is true, but Ruby is very likely to have enough libraries to meet your needs.

Differences between Python and Ruby

Pleasure of programming

The first difference is very subjective.
I enjoy much more writing some Ruby code than Python code.
First of all, I hate the ":" in Python… I just find it too ugly (ok, very subjective…).

I also don’t like the fact that you always need to add the parentheses to the method calls to really call the method. This is also very subjective again and many people won’t agree and say it’s better to differentiate the method call and reference, but I prefer a clean code without parentheses like in Ruby (you still can add the parentheses in Ruby if you want though…).

Then, the keyword self in Python: you just have it everywhere!
All the method calls first argument are always “self”, and you always repeat “self” when you call a local class instance variable… Among 391 lines of code, I have 286 times the word “self” (more than one “self” in some lines of course), that’s too many!
I definitely prefer the @var in Ruby that some Pythonists laugh at.

Finally, the Python __init__, __str__ and other underscored methods/functions…
What the…! No, seriously, someone has to to something for that!
OK, the __str__ function that can change any object (anything?) into a string is very useful.
But please find another name…
For example __init__ and __del__ are respectively called initialize and define_finalizer in Ruby.
It’s less ugly, isn’t it?

To conclude, it’s just nicer to read and write some Ruby code than Python code (for me!).

The Blocks Power of Ruby

Here we are. The Ruby Blocks ( { } ).
They are just so convenient that once you code with it, you’re addicted!
It is possible to achieve such features in Python too, but it’s definitely better implemented in Ruby where it’s very very easy to use.

Let’s take a concrete example of a Qt signal connection.
In Python you have to pass a function as parameter of the call, even if you only have one action to do when the signal is received.

In Python, you need to define the receiving slot separately (note the “…”):

        saveSettingsButton = QtGui.QPushButton('Save Settings')
        saveSettingsButton.clicked.connect(self.saveSettings)
        ...
    @QtCore.Slot()
    def saveSettings(self):
        self.settings.setValue('author',self.author())
        QtGui.QMessageBox.information(self, 'Settings', 'Settings saved!') 

In Ruby, you can just use the blocks to write the action on-click right after:

    # Save settings
    saveSettingsButton = Qt::PushButton.new(tr('Save settings'))
    saveSettingsButton.connect(SIGNAL :clicked) {
        @settings.setValue("author", Qt::Variant.new(@author))
        Qt::MessageBox.new(Qt::MessageBox::Information, 'Settings', 'Settings saved!').exec
    }

When you will perform the action only once, or for very short actions, it is definitely better to write it directly after the connection inside the blocks, like in Ruby.

It is easier to read and maintain.

For actions to perform that can be use somewhere else in the code by another object, of course it is better to separate it, and Ruby can also do that. But for very short call, this Ruby shortcut using blocks is very convenient!

Definition of the slots/signals

In Python, you need to add a @QtCore.Slot(type1, type2,…) before the functions that you want to declare as a slot, like the previous "saveSettings(self)" method.

In Ruby, you can just add one line at the top of your class listing all the slots, like you would do in Qt/C++: slots :saveSettings, :mySlot2, :mySlot3

Same for the signals with the keyword "signals", whereas in Python you need to declare the signals at the top of your class, outside __init__

Python:

class myClass(QtCore.QObject):
    errorSignal         = QtCore.Signal(str)
    infoSignal          = QtCore.Signal(str)
    def __init__(self):
        ...
    @QtCore.Slot()
    def saveSettings(self):
        ...
    

Ruby:

class myClass < Qt::Object
  slots :saveSettings
  signals :errorSignal, :infoSignal

And finally, you can just have no slot at all in Ruby if you add your code when a signal is received inside blocks, like shown in the previous code example!

Easiness of distribution

Yes, both of them are multi-platform, and it is possible to run the same code on Windows, Linux and Mac.

However, not all the clients want to install Ruby or Python and the required libraries to run the program.

So you need to bundle the application for them, and Python is far better on this point!

I have talked about it in more details in the background introduction as it was the reason why I wrote the same program in both languages.

Refer to the first part for more details.

Performance

I was surprised reading on Internet that Ruby was performing better than Python.

I don’t know if it’s my computer or not, but for me PySide is performing far better than QtRuby…

The PySide GUI is almost immediately displayed when the program is started whereas the QtRuby GUI takes about 10 seconds to display!

The difference is even bigger when I run the debugger… Python debugger runs very smoothly whereas Ruby debugger is very slow, so slow I can’t use it… (and I used the ruby “fastdebug” :s)

My computer is not recent (an almost 3 years old AMD X2 laptop that rediscovered life when it met an SSD) so I tried on a Quad Core running Windows XP and of course the difference was smaller…

But on old machines, I beleive the PySide GUI is starting faster than the QtRuby one (and the performance of the program once launched is similar).

Conclusion

In this article, I have shown the pros and cons of Ruby and Python on my concrete example, with my subjective point of view.

Yes, I prefer Ruby as a language itself and as I already said, I enjoy much more programming in Ruby than Python.

However, in the real world, for real projects and real clients that want a bundled application that just runs smoothly, I’m afraid Python is better.

It is even far better that after justifying Ruby during all this post, I will continue further development of this program in Python… Because yes, the easiness of distribution is a crucial point in the real world and the differences between Ruby and Python are more about self-pleasure than language features.

I hope Ruby will soon become easier to bundle so I can switch back to my lovely functional blocks!

Mickey 3D was in Japan when he wrote this song...?

Listen entirely to appreciate
(in French though...)