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...)

As a first attempt to write a mobile application, I just tried to build an application that retrieves the latest news from my school's atom feed and displays it in a native way on a smartphone (Keio University, Graduate School of SDM).
Yesterday, I had absolutely no knowledge about mobile development, except "iPhone is using the ugly Objective-C and Android is using the heavy Java".
Today, the application looks like that...

...is written in pure Ruby and is 100% native on iPhone, Android, Windows Mobile and BlackBerry!
How come?! Thanks to a powerful, light, easy and intuitive mobile framework: Rhodes (from Rhomobile).
Let see in this post how to do that.

Introduction

When you face a new issue, the first thing you often do is... to Google it!
Well that's what I did, and it quickly appeared that if I want to build native applications for smartphones, I will have to write the application in different languages using different libraries; one for each OS (for example Objective-C for iOS or Java for Android) unless I use some frameworks that do the ugly conversion to native code for you!

Appcelerator Titanium

And among the frameworks, the most popular one seems to be Appcelerator Titanium.
According to their websites, it allows you to use "web technologies" (JavaScript, Python, Ruby) to develop native applications for iPhone and Android.
Sounds exciting right!

So I installed the free Titanium Plateform, downloaded an example from their website, and tried to run the example.
That's the last thing I did with that software... The software never succeed to connect to the Android SDK and I was stuck on the "loading..." (of the Android SDK) that never ran... (even after moving "adb" to the right folder and setting up the path with all the correct values...)
Then I tried the Sandbox where you can run some code snippets.
I took one of the list, the Python Hello World example and clicked "Launch".
Nothing happened...
I'm sure the problem is me because the soft is pretty popular and many people manage to use it well!
But it did not really persuade me to investigate further in the software...

Rhomobile Rhodes

I gave a try to another one, apparently less popular.
Its name is "Rhodes" from the Rhomobile family.
Unlike Appcelerator Titanium, Rhodes is really "cross-platform". Where Titanium supports only iPhone and Android, Rhodes offers you also Windows Mobile, RIM and Symbian!
However, you won't have choice for programming language: you will have to program in Ruby.
A single Ruby code can be deployed into a native application on all OS supported by Rhomobile.

But is it a drawback to use Ruby? After using it for two days... clearly not!
Rhodes is highly inspired by Rails and takes good ideas from the Rails web framework: Database Abstraction (not as complete as Rails), MVC (Model-View-Controller), auto model generation (similar to Rails scaffolding, also through rake) and many things I still did not see yet.

Let see how I ended up in 2 days with my first application running on my smartphone starting from 0.
First, we need a mobile OS SDK (Development Kit). The easiest to get and available on all platforms (unlike a very close one that you can only use from Macs... ><) is the Android SDK.

You can get the one you want but I'll explain briefly how to set up the Android one here.

Install the Java SDK

To use the Android SDK, you need the Java SDK (as native Android apps are Java apps).
So first if you don't have it, let's install it.
Go to the Java website and download the latest SDK for your system.

Install Android SDK

Go to the Android Developers website and install the SDK. Start the SDK Manager (asked after installed on Windows or under tools/android on Linux) and install the packages you want (probably the SDK for Android 2.3 and the updates).
On the same webpage, download the Android NDK that helps us with "performance-critical native applications". You just need to extract the archive somewhere (probably along with the SDK).

Install Ruby and Rhodes

Then you need to install Ruby, RubyGems, Rake and Rhodes.

On Linux, you just need to install the packages "ruby", "rubygems", then the rake and rhodes gems ("sudo gem install rake rhodes").
On Windows, if you already have Ruby and Rubygems you need to "Start command prompt with Ruby" (search from the windows menu) and "gem install rake rhodes".
If you don't have Ruby, you can install Ruby, RubyGems and Rhodes with a all-in-one installer: Instant Rhodes.

That's all you need to use the Rhodes framework.
Let set it up. Start a command prompt with Ruby and type "rhodes-setup".
Follow the instructions to set up Rhodes.
For example for me:

ruby 1.9.2p136 (2010-12-25) [i386-mingw32]

C:\Users\Thomas>rhodes-setup
We will ask you a few questions below about your dev environment.

JDK path (required) (C:/Program Files/Java/jdk1.6.0_23):
Android SDK path (blank to skip) (): C:\android-sdk-windows
Android NDK path (blank to skip) (C://android-ndk-r5):
Windows Mobile 6 SDK CabWiz (blank to skip) ():
BlackBerry JDE 4.6 (blank to skip) ():
BlackBerry JDE 4.6 MDS (blank to skip) ():
BlackBerry JDE 4.2 (blank to skip) ():
BlackBerry JDE 4.2 MDS (blank to skip) ():

If you want to build with other BlackBerry SDK versions edit: C:/Ruby192/lib/ruby/gems/1.9.1/gems/rhodes-2.2.6/rhobuild.yml

C:\Users\Thomas>

And Rhodes is set up!

Hello World

To make a new application, the only thing we need to do is to extend the rhodes framework.
So first we can generate a simple "hello world" like application with one line.
From the command prompt, enter "rhodes app myapp" (changing "myapp" by whatever you want).

It will create the application template :

[thomas@myhost rhodes]$ rhodes app myapp
Generating with app generator:
     [ADDED]  myapp/rhoconfig.txt
     [ADDED]  myapp/build.yml
     [ADDED]  myapp/app/application.rb
     [ADDED]  myapp/app/index.erb
     [ADDED]  myapp/app/index.bb.erb
     [ADDED]  myapp/app/layout.erb
     [ADDED]  myapp/app/loading.html
     [ADDED]  myapp/Rakefile
     [ADDED]  myapp/app/loading.png
     [ADDED]  myapp/app/helpers
     [ADDED]  myapp/icon
     [ADDED]  myapp/app/Settings
     [ADDED]  myapp/public

Move to that folder (cd myapp) and you can directly try the application by typing "rake run:android"
The first time you run "rake run:android" you will have to choose a virtual device.
Just press enter to let rhodes create a new one and set it up.

Once you've done that, your first application will start in an Android Emulated window.

Building your own application

Hello World is nice, but we want a real application.

As I said in the introduction, we will write a simple Atom feed parser that can display all the entries of an Atom feed in a list and allow the user to click (well, tap!) on an entry title to see its content.
The Atom feed I am taking as example is the following one: http://www.sdm.keio.ac.jp/en/atom.xml

Model

First, we need to create the model of our application.

We will store the entries in a “Feed” model, and each “feed” will have a title, a date, a link, a content and a language.
So we just generate the model automatically with rhodes:

[thomas@myhost myapp]$ rhodes model Feed title,date,link,content,lang
Generating with model generator:
     [ADDED]  app/Feed/index.erb
     [ADDED]  app/Feed/edit.erb
     [ADDED]  app/Feed/new.erb
     [ADDED]  app/Feed/show.erb
     [ADDED]  app/Feed/index.bb.erb
     [ADDED]  app/Feed/edit.bb.erb
     [ADDED]  app/Feed/new.bb.erb
     [ADDED]  app/Feed/show.bb.erb
     [ADDED]  app/Feed/feed_controller.rb
     [ADDED]  app/Feed/feed.rb
     [ADDED]  app/test/feed_spec.rb

It generated automatically some files for you.

It basically allows you to create new feeds, edit them, and delete them from the application.
You can have a look to the generated files to understand how Rhodes works.
In our case, we do not need to be able to add, edit et delete manually the entries so I deleted the “edit” and “new” templates (.erb) and removed the edit/update/create/delete methodes from the controller (feed_controller.erb).

XML

What we want is to populate the database from the entries in the XML file.
So we need a Ruby XML parser. And of course there are plenty of them!
Rhodes supports the popular ReXML and also has its own implementation based on ReXML (but lighter) named RhoXML. Unfortunately RhoXML doesn’t support CDATA and there are CDATA in my feed so we will have to use ReXML.

To add ReXML support, simply add the “rexml” and “set” extensions to the build.yml file at the root of your application:

extensions: ["json", "rexml", "set"]

When we start the application, we want to list all the entries of the feed.
So we want to call the “index” of the “Feed”.

Startup application

To do so, we just change the rhoconfig.txt file (root of the app) as follows:

# Startup page for your application
start_path = '/app/Feed'

def index

And what we want to do when we start the application is to list the feeds, so let’s do so by editing the index method in the feed_controller.rb as follows:

  def index
    @feeds = Feed.find(:all)
    if @feeds.empty? then
      self.update
    else
      render :action => :index, :back => :exit
    end
  end

If we already loaded the feeds, we just display the list.
If there are no feeds, we update them.

def update

You can see the full "update" method at the end of this post.
I just show you the most important part here, the part that loads the elements of the Atom feed into our @feeds variable:

require 'rexml/document'
#@@get_result contains the XML text (as a string)
doc = REXML::Document.new(@@get_result)
REXML::XPath.each(doc,"//feed/entry/") do |e|
  Feed.create(:title => e.elements['title'].text,
              :link => e.elements['link'].attributes['href'],
              :date => e.elements['published'],
              :content => e.elements['content'].texts().at(1),
              :lang => e.elements['content'].attributes['xml:lang'])
end

def refresh

We also want to be able to "refresh" the entries because when we restart the application, if you noticed the beginning of the index method, if there are some entries in the database, we just display them directly.
However the database is not destroyed when we stop the application so the entries will be directly displayed without connecting to the internet.
We can add a simple "refresh" method that empty the database and update the entries from the Atom feed:

def refresh
  Feed.delete_all
  redirect :action => :update
end

Then, when the user tap on a title form the index list, we want to display the content of the feed.
The "show" method has already been implemented for us and we don't need to change it:

def show
  @feed= Feed.find(@params['id'])
  if @feed
    render :action => :show
  else
    redirect :action => :index
  end
end

The Views (index, show)

Finally, we only need to change the automatically generated views to display the information we want!
Let see the two most important views: index and show.

The index.erb has a button on the top to manually refresh the entries and a list of all the entries (showing their title):

  <h1>SDM News</h1>



    Reload the news
  



    <% @feeds.each do |feed| %>

          
            <%= feed.title %>
          
        

    <% end %>
  

Result:

The show.erb shows the title, the date, and the content:

    <h1><%= @feed.title %></h1>




          <%= @feed.title %>
        

          <%= @feed.date %>
        

        <%= @feed.content %>
  

Result:

And... that's it!
I added some controls, the multi-language feature and the final application was done!

Conclusion

In addition to allow you to quickly build mobile applications, Rhodes also supports native powerful APIs of the smartphones.
It is also really cross-platform as you can deploy your application to the 5 top mobile devices (iPhone, Android, Windows Phone, BlackBerry and Symbian).
Ruby is a very user-friendly programming language that is pleasant to use.
The MVC and Database Abstraction layers inherited from Rails make the code easier to maintain.

IDEs that work with Ruby/Rails also work has a charm with Rhodes.

You can find some screenshots of the quickly built application here:

You can download the complete code of the application used as an example in this tutorial here: sdmnews.zip.
From your Android device, you can install the application by clicking on the following APK link: sdmnews.apk
You need to allow unknown sources to install this quickly built application (Settings > Applications > Unknown sources) as I do not publish it to the market (yet?).

If you have any comment or question about mobile software development, feel free to comment this post!

### WARNING: could not find /etc/localtime or /usr/share/zoneinfo/localtime. unable to determine host timezone

It can be fixed simply by copying your timezone localtime file into /etc/localtime.

For example in my case, my timezone is Asia/Tokyo, so I copy the /usr/share/zoneinfo/Asia/Tokyo file into /etc/localtime:

sudo cp /usr/share/zoneinfo/Asia/Tokyo /etc/localtime

And that's it!

PS: In my case, it was preventing me to start the Android Device Emulator from Rhodes (Rhomobile) on ArchLinux i686. Works as a charm after the previous command!

And there is a very promising one that should have lights on it: Ruby on Rails (or simply “RoR”).
Let’s have an overview on RoR in this post.

Introduction

First, if you’re new to Ruby, don’t worry!
Ruby has been made to be pleasant and easy to program with.
I advise you to read the very nice Ruby introduction Ruby in 20 minutes (available in many languages).

In Ruby, the main thing to remind is that everything is object. Even an integer!
So you can have methods and attributes for all your variables (through the classes).

In Rails, we have a MVC architecture, which means we separate the Model, the Controller and the View.
When it goes to web programming, the model can for example define a database table, the view defines what is shown to the visitors (html-based) and the controller is the “glue” between the models and the views.
The obvious advantage of doing so it that your code is not messed up. You don’t have SQL statements messed up with HTML rendering and so on.
It is far easier to maintain than some PHP programming!

But after using Rails for a while, the real reason why I don't want to go back to PHP is the simplicity of Rails to deal with databases through its "ActiveRecord" class.
We can create, use and update a database without entering a single SQL statement!
Rails is mapping Ruby Classes to Database Tables.

Power of Rails through an example

Retrieving a table

So let say I have a ruby class "Product" that belongs to ActiveRecord.
This model is mapped to a table called "products" in the database. And the columns of the table are attributes in the model.
So if I have a table "products", I can get its content with a single instruction exempt of any ugly SQL code:

products = Product.all

That's it! This short code is enough to already appreciate the power of RoR.
With a single line (and it is true that there is nothing else, no definition of Article or whatever before, this can be the first line of a script) we connected to our database and got the content of the table "products".
Because Rails is smart and knows that "Product" refers to the table "products" in the database.
Rails is even smart enough to know that the plural of "category" is not "categorys" but "categories"!
So if we had a table "categories" in our database, to get all the categories it would be:

categories = Category.all

Retrieving only one line of the table

Well, getting all the content of a table is good.
But we can also get the last article of the table "products" easily:

lastProduct = Product.last

And that's it? Yes it is! Why should it be harder though?
Thanks to Rails we don't have to "SELECT * FROM products ORDER BY date DESC LIMIT 1" or something similar .

Accessing the elements of this line

And to access to the content of the last article, we just need to access the attributes.
Let say the table "products" has columns "name" (string), "description" (text) and "price" (int).
We can access these values simply by calling the attributes of the class:

lastProduct.name
lastProduct.description
lastProduct.price

Validation

Validation is also well implemented in Rails and is a strength of this framework.
You can validate forms entered by users very easily.
For example if you want the rate to be between 1 and 5, you just need to add the following code in the Comment model...

validates_inclusion_of :rate, :in => 1..5,
                              :message => "rate has to be between 1 and 5"

...and you will never record a rate which is not between 1 and 5 in the database!
Besides, the visitor who enters by mistake a rate which is not within this range will be warned by the previously specified message.

References to another table

Cool! And what if a column is a reference to another table.
For example let say we can have comments about the product, and the comments of the product are stored in another table called "comments" that has three fields: "product_id" (integer) which is a reference to the product the comment belongs to, "content" (text) which is the comment about the product and a "rate" (int) between 1 and 5 they give to the product.

So the products can have comments and each comment belongs to a product, right?
Well, this relation is very easy to set up with Rails. We need to add one single line in both models (the products model and the comments model).

In the products model, we said a product can have many comments.
Well, Rails talks pretty well English and understands us:

has_many :comments

In the comments model, we said a comment belongs to a product:

belongs_to :products

And that's it! The relation is done!
Let say we want to get all the comments of the first product...
If we were working with PHP/MySQL it would have required a few minutes to write the code for it.
With Ruby, it's a few seconds and it's pretty:

comments = Product.first.comments

And it's done!
As we defined the relation between the comments and the products (adding two lines to the models!), this single line retrieves the comments of the first product.

More complex relation with other tables

This feature is even more powerful when the relation is more complex.
Let say the comments are written by users that are stored in another table "users".
We want to get the name of the user that wrote the last comment on the first product... (yeah, why not? :p)
We assume there is another column "user" in the table "comments" which is a reference to a user in the table "users", and that this table "users" contains, among others, a column "name" with the user name.

firstProduct = Product.first
lastComment = firstProduct.comments.last
userName = lastComment.user.name
# can be done in 1 call:
userName = Product.first.comments.last.user.name

Not even one SQL statement. No "JOIN comments USING..." or similar.
Only attribute calls.

Search and Find in a table

OK but how can we find the user whose name is "Thomas"?
Easy!

thomas = User.where(:name => "Thomas")

No SQL again (but same as "WHERE name = 'Thomas'").

You will actually have to enter a very small SQL statement when you want to search something.
For example let say we want to retrieve all the products whose description contains "something very interesting".
The code is as follows:

searchTerm = "something very interesting"
results = Product.where("description LIKE '%?%'", searchTerm)

The question mark in the LIKE statement is replaced by "searchTerm".
This is almost the only time we need to enter some SQL code, and it is not a full SQL code anyway, just a portion of code

Additional Information

I think you saw that with Rails, you can build complete, usable and maintainable websites in a few minutes (or hours).
The best way to see it by yourself is to follow the Getting Started with Rails Guide.

Why isn't Rails the web framework #1 then??
Because still a very few web hosts provide good Rails hosting for low cost... and most of the web hosts simply do NOT support Rails...
I even myself cannot use Rails as much as I would like to (except on localhost... which is a bit frustrating sometimes!).

This is sad but I hope it will change soon so Rails will get the success it deserves!

I'll write an article about web2py, another framework inspired by Rails which is similar (but not as good as Rails IMHO) but has the advantage of being easier to deploy and accepted by more web hosts.