After a recent report by Mobile Crunch that the mobile location-based game Booyah has outgrown Foursquares and Gowalla reaching 1 million mobile users, combined with recent reports on the future of the Web at top conferences on the subject, and affirmed by recent trends in VC’s investing strategies in the IT sector, I have become convinced that the future of the Web is in mobile apps and not Web-based applications, sometimes referred to as “software as a service”.

In the last decade, we have witnessed a revolution in Web app design both in terms of the user experience and the richness of functionality. Arguable, the most successful and revolutionary Web app for consumers has been Gmail, and more recently Google Apps. Facebook is another great example of a Web app, with more social focus. All is good, and more Web apps are coming, but then what?

While the laptop is becoming a replacement to the desktop for many, smart phones such as iPhone and Blackberry are becoming a replacement for laptops. The new trend in mobile consumer usage, set by Apple’s iPhone and followed by RIM’s Blackberry and Google’s Android, is to access services and information through apps instead of mobile-friendly websites. Is your website optimized for mobile access? Big deal – new mobile browser can render most websites in a usable fashion. But who cares? If you don’t have an app to access your site then it’s simply boring. I believe boring is not the main reason though. It all boils down to the look and feel. Mobile apps provide a consistent look and feel with the rest of the mobile interface, a lot more so that a Web page does.

Based on these trends, I believe that the value of “software as a service” as being the future of desktop apps for consumers will slowly (or quickly?) diminish; while mobile apps will increase in sophistication and become the norm for accessing your email, social networks, documents, spreadsheets, organizer, etc.

Some may argue that the desktop, or the laptop, will still be ahead in software due to the limited screen size that mobile devices affords. Apple has negated that claim last month with the release of its iPad. QED.

As of today, the following plugins are active on this site:

1. Akismet: A popular anti-spam plugin the screens and blocks spammy comments
2. All in One SEO Pack: it gives a great flexibility in editing meta tags for individual posts and pages, but I use it most of it’s out-of-the-box good templates for default meta-tag values.
3. bib2html: With some in-house mods, this plugin powers the the publications page from a BibTeX file. Very convenient.
4. Exec-PHP: I use this plugin to execute PHP code on the popular posts page.
5. FeedBurner FeedSmith: provides RSS feed serving through FeedBurner.
6. File Icons: the idea behind this plugin is neat, it automatically ads meaningful icons to links based on the extension of the destination file. I’m not too happy with it though. I feel it’s a bit clumsy at times. See it in action on the publications page.
7. Google Analyticator: simple Google Analytics integration
8. Google XML Sitemaps: very useful plugin that automatically generates a site map every time a new post is added. Highly configurable too.
9. WordPress Popular Posts: a new addition to the site. It power the popular posts widget in the right column as well as the popular posts page. The popularity can be based on page views or comments.
10. WP-ContactForm: I use a modified version of this plugin to power the contact page.
11. WP-SpamFree: Another plugin to reduce comment spam. It shows the comment form through JavaScript, reducing automated comments.

By now, it should be clear to everyone that the future of the Web is mobile devices, social networking, and linked data. Although this realization did not come to me until I attended the World Wide Web Conference (WWW2009) in Madrid, Spain, at the end of April. Several keynote speakers, tutorials/workshops, and dedicated tracks and sessions emphasized this fact. I’ll say a few word on each of the three pillars:

Mobile Web

As Sir Tim Burners-Lee said in his keynote presentation: “more people will have their first encounter with the Web through a mobile device than a laptop.” The World Wide Web Consortium (W3C) has task forces and standards to promote and standardize the mobile Web. They’ve been doing it for years, but only now that people are listening seriously because it is already happening.

What this means to the Web community is that Web sites should have a mobile version that conforms to standards and guidelines and works well on mobile devices.

Social Networking

It is a given that social networks are taking over the Web. But that’s not what “the future of the Web is social networking” means. Social networking on the Web refers to enabling the end users to interact with each other on your Web site. Without this interaction, your site will fail to deliver the expected value by the growing savvy Web population.

Linked Data

The Semantic Web is dubbed as Web 3.0. Many believe that a widespread of the Semantic Web is at least a decade away. Linked Data, on the hand, is already a reality. Linked data consists of the now-feasible subset of the Semantic Web. At the very basic level, it is RDF + URI: a common data representation format and standard for addressing and linking data items. The academic community emphasizes the important of Linked Open Data – making your proprietary databases accessible on the Web in the Linked Data format. This movement is new but strong. Many tools are being developed to facilitate the transition to Linked Data for the masses.

Summary

In short, as a Web site owner, if you want to survive on the Web for the years to come, you better ensure that your site is accessible from mobile devices, that you facilitate social interaction among your users, and that your data is open and linked, and linkable.

Thanks to Christopher Gutteridge for this wonderful tool to search and browse the WWW2009 proceedings.

I’ve been trying to upgrade to the latest WordPress (version 2.7.1) for a while without success. Every time I initiate the upgrade, whether through WordPress’ built-in automatic upgrade feature or using the automatic upgrade plugin, the process stalls when it reaches the step of downloading the latest zip file. After checking the the compatibility matrix I discovered that my hosting provider, 1and1, runs PHP4 by default, which incompatible with the upgrade script. This problem can be easily fixed by forcing PHP5. This can be achieved by adding the following line to your .htaccess file:

AddType x-mapp-php5 .php

The django official tutorial consists of 4 parts, unnecessarily long, mixes commands with text, and omit some important details. Here is an attempt at providing a more complete and more condensed version of the tutorial.

1. Install Django. The latest tutorial uses a newer version of Django that is not backward compatible. Therefore, it is best to install Django from svn:

   svn co http://code.djangoproject.com/svn/django/trunk/ django-trunk
   cd django-trunk
   sudo python setup.py install

2. Create a Project. Create a new project under the current directory called mysite:

   django-admin.py startproject mysite

3. Configure Database. For this example, we will use an sqlite3 database.

   mkdir db
   chmod a+rwx db
   chmod g+s db

   The Web server needs access and write permission. The g+s ensures that group ownership of created files in db remains the same that of db. Edit mysite/settings.py as follows:

   DATABASE_ENGINE = 'sqlite3'
   DATABASE_NAME = '/path/to/mysite/db/mysite.db'

   Create the database and the tables:

   python manage.py syncdb

4. Create a Polls Application. From the mysite directory, run the command:

   python manage.py startapp polls

5. Create the Polls Data Model. Edit the file mysite/polls/models.py as follows:

   from django.db import models
   
   class Poll(models.Model):
       question = models.CharField(max_length=200)
       pub_date = models.DateTimeField('date published')
       def __unicode__(self):
           return self.question
   
   class Choice(models.Model):
       poll = models.ForeignKey(Poll)
       choice = models.CharField(max_length=200)
       votes = models.IntegerField()
       def __unicode__(self):
           return self.choice

   And synchronize the database:

   python manage.py syncdb

6. Enable the Admin Interface Enable the admin application in mysite/settings.py:

   INSTALLED_APPS = (
       ....
       "django.contrib.admin",
       ....

   Then enable the admin URLs in mysite/urls.py:

   from django.conf.urls.defaults import *
   from django.contrib import admin
   admin.autodiscover()
   urlpatterns = patterns('',
       (r'^admin/', include(admin.site.urls)),
   )

   And synchronize the database:

   python manage.py syncdb

   Note that at this point we only enabled the admin URL. The home page will no longer work until we add another pattern to match it.

7. Test the admin Interface. Either configure your Web server according to the docs, or use the development built-in server from the mysite direcotry:

   python manage.py runserver 0.0.0.0:8080

   Visit the admin interface from a Web browser at:

   http://127.0.0.1:8080/admin

8. Enable admin in Polls. Create a file mysite/polls/admin.py with:

   from mysite.polls.models import Poll
   from django.contrib import admin
   
   admin.site.register(Poll)

   You should now see the Polls in the admin interface.

   Note: don’t forget to restart the Web server every time you make changes to your python code.

9. Customize the Polls Admin. Edit mysite/polls/admin.py to be:

   from mysite.polls.models import Poll
   from mysite.polls.models import Choice
   from django.contrib import admin
   
   class ChoiceInline(admin.TabularInline):
       model = Choice
       extra = 3
   
   class PollAdmin(admin.ModelAdmin):
       fieldsets = [
           (None,               {'fields': ['question']}),
           ('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
       ]
       inlines = [ChoiceInline]
       list_display = ('question', 'pub_date', 'was_published_today')
       list_filter = ['pub_date']
       search_fields = ['question']
       date_hierarchy = 'pub_date'
   
   admin.site.register(Poll, PollAdmin)

   Each line adds a new functionality to the admin interface, and the functions are independent of each other. Most should self-evident. Feel free to experiment.

   To customize the how the “was_published_today” header is displayed, change mysite/polls/model.py to:

       def was_published_today(self):
               return self.pub_date.date() == datetime.date.today()
       was_published_today.short_description = 'Published today?'

10. Setup URLs. Create the polls urls in mysite/polls/urls.py:

    from django.conf.urls.defaults import *
    
    urlpatterns = patterns('mysite.polls.views',
        (r'^$', 'index'),
        (r'^(?P<poll_id>\d+)/$', 'detail'),
        (r'^(?P<poll_id>\d+)/results/$', 'results'),
        (r'^(?P<poll_id>\d+)/vote/$', 'vote'),
    )

    Add polls to the site urls in mysite/urls.py by including the pattern:

        (r'^polls/', include('mysite.polls.urls')),

11. Setup a Templates Directory.Create a directory mysite/templates. Update mysite/setting.py to use this direcotyr:

    TEMPLATE_DIRS = (
        '/path/to/mysite/templates',
    )

12. Create the Index View and Templates. Create a file mysite/polls/views.py:

    from django.shortcuts import render_to_response, get_object_or_404
    from mysite.polls.models import Poll
    
    def index(request):
        latest_poll_list = Poll.objects.all().order_by('-pub_date')[:5]
        return render_to_response('polls/index.html', {'latest_poll_list': latest_poll_list})

    And the index template mysite/templates/polls/index.html:

    {% if latest_poll_list %}
        <ul>
        {% for poll in latest_poll_list %}
            <li>{{ poll.question }}</li>
        {% endfor %}
        </ul>
    {% else %}
        <p>No polls are available.</p>
    {% endif %}

13. Create the Detail View and Template. Add to mysite/polls/views.py:

    def detail(request, poll_id):
        p = get_object_or_404(Poll, pk=poll_id)
        return render_to_response('polls/detail.html', {'poll': p})

    And create the template mysite/templates/detail.html:

    <h1>{{ poll.question }}</h1>
    
    {% if error_message %}<p><strong>{{ error_message }}</strong></p>{% endif %}
    
    <form action="/polls/{{ poll.id }}/vote/" method="post">
    {% for choice in poll.choice_set.all %}
        <input type="radio" name="choice" id="choice{{ forloop.counter }}" value="{{ choice.id }}" />
        <label for="choice{{ forloop.counter }}">{{ choice.choice }}</label><br />
    {% endfor %}
    <input type="submit" value="Vote" />
    </form>

14. Create the Vote Handler. Edit mysite/polls/views.py to include:

    from django.shortcuts import get_object_or_404, render_to_response
    from django.http import HttpResponseRedirect
    from django.core.urlresolvers import reverse
    from mysite.polls.models import Choice, Poll
    # ...
    def vote(request, poll_id):
        p = get_object_or_404(Poll, pk=poll_id)
        try:
            selected_choice = p.choice_set.get(pk=request.POST['choice'])
        except (KeyError, Choice.DoesNotExist):
            # Redisplay the poll voting form.
            return render_to_response('polls/detail.html', {
                'poll': p,
                'error_message': "You didn't select a choice.",
            })
        else:
            selected_choice.votes += 1
            selected_choice.save()
            # Always return an HttpResponseRedirect after successfully dealing
            # with POST data. This prevents data from being posted twice if a
            # user hits the Back button.
            return HttpResponseRedirect(reverse('mysite.polls.views.results', args=(p.id,)))

15. Create the Results View and Template. Edit mysite/polls/views.py to include the results view:

    def results(request, poll_id):
        p = get_object_or_404(Poll, pk=poll_id)
        return render_to_response('polls/results.html', {'poll': p})

    Create a results templates file mysite/templates/polls/results.html with:

    <h1>{{ poll.question }}</h1>
    
    <ul>
    {% for choice in poll.choice_set.all %}
        <li>{{ choice.choice }} -- {{ choice.votes }} vote{{ choice.votes|pluralize }}</li>
    {% endfor %}
    </ul>

Et Voilà! These steps cover most of the 4-part tutorial, excluding templating the admin area and using the generic views. For completeness, I include a sample apache config file that uses virtual hosts so you can go through this tutorial with apache.

<VirtualHost *>
    ServerAdmin webmaster@localhost
    ServerName django-tutorial.osrd.org
    DocumentRoot /path/to/django-projects/mysite

    <Directory /path/to/django-projects/mysite >
        Options Indexes FollowSymLinks MultiViews
        AllowOverride None
        Order allow,deny
        allow from all
    </Directory>

    ErrorLog /var/log/apache2/error.log

    # Possible values include: debug, info, notice, warn, error, crit,
    # alert, emerg.
    LogLevel warn

    CustomLog /var/log/apache2/access.log combined
    ServerSignature On

<LocationMatch "/mysite/*">
    SetHandler mod_python
    PythonHandler django.core.handlers.modpython
    SetEnv DJANGO_SETTINGS_MODULE mysite.settings
    PythonOption django.root /mysite
    PythonDebug On
    PythonPath "['/path/to/django-projects'] + sys.path"
</LocationMatch>

<Location "/media">
    SetHandler None
</Location>

<LocationMatch "\.(jpg|gif|png)$">
    SetHandler None
</LocationMatch>

</VirtualHost>

If you find any omissions or inaccuracies, please report them privately or in the comments and I’ll update the tutorial accordingly.

This article is in-progress.

I am compiling a list of notable sites (i.e., sites with consistent traffic, traffic growth, or sites that people talk about elsewhere) that are focused on aggregating content from other sites, primarily through RSS feeds.

• addictomatic.com
• alltop.com
• esciencenews.com
• headlinesfeed.com
• hypem.com
• originalsignal.com
• popurls.com
• protopage.com

If you know others, please submit them throught the contact form or in the comments below. I will review each submission and add it to the list if appropriate.

Today I became a happier WordPress user because I managed to upgrade to WordPress 2.5.1 with a surprisingly easy process, as well as migrating to the latest K2 release. The short story: install the WordPress Automatic upgrade plugin, run it, correct failed actions, upgrade the K2, migrate footer from the previous K2, et voilà! I am very impressed with the new admin interface of WordPress. It took a few minutes to understand where is what, but WOW! Neat, organized, and pleasant.

When first tried to upgrade my WordPress installation, I wasn’t really sure how I would go about it. According to the WordPress upgrade guide, the process consists of five simple steps:

1. Backup Current Installation. Sounds pretty simple, but backing up from a hosted server, although not complicated, is not that simple either. You need to backup all your files and you need to backup all the database tables. God forbid you have more than just the WordPress installation using the same database. Trying to go through all the tables and deciding which belong to WP and which belong to other applications is unpleasant at best.
2. Deactivate Plugins. No complaints here. Fairly simple.
3. Download Latest WordPress. Granted, there is nothing simpler to do, save for scratching your head.
4. Replace WordPress Files. I have a few custom plugins, custom themes, and some other modes. How do you replace only what needs to be replaced but not the other files? The naive way is to do it one file at a time. You can try doing it in a batch as in copy-and-pray. Actually that won’t work because you need to be careful not replace your wp-config.php file. Further, you need to copy the contents of the wp-content folder from your previous installation, but not the entire folder. This step is what kept me from upgrading earlier – too many things could go wrong. After replacing all the files, you need to visit the upgrade page so the database schema can be changed to the new one.
5. Reactivate Plugins. You have to reactivate your plugins one at a time. There are no “plugin profiles” in WordPress, which would’ve allowed you to enable and disable plugins in groups.

In a an article mentioned in a recent Search Engine Guide newsletter, I read about this super useful almost working plugin called WordPress Automatic upgrade. It does what it says. I chose the semi-automatic method where I clicked “next” after every step to make sure all went smoothly. And it did, except for the last step. The plugin failed to re-enable the previously active plugins. A small incovenience compared to all the other things that went right: created backup, disabled plugins, downloaded latest WordPress, replaced all the right files and kept what should be kept.

Unfortunately, the copy of the K2 theme that I had was incompatible with WordPress 2.5. Particularly, the panel manager of K2 didn’t show up in the admin section. After a bit of poking around, I downloaded K2 candidate release 6 which worked like a charm after some minor tweaks. In the process, I learned a bit more about actions, created a new plugin to customize my K2 TAA theme, and made use of K2′s action hooks to add a custom footer. My next K2 upgrade – fingers crossed – will not require changing any of the K2 code.

The code of my K2 TAA Theme plugin is reproduce below. Feel free to use it as a basis for build your own customizations for K2 and other WordPress actions.


/**
* Plugin Name: K2 TAA Theme
* Plugin URI: http://tony.abou-assaleh.net
* Description: Support functions for the K2 TAA Theme
* Author: Tony Abou-Assaleh
* Author URI: http://tony.abou-assaleh.net
* Version: 1.0
*/
function k2_taa_footer () {
?>
<p>
Copyright © 1997-2008 Tony Abou-Assaleh, Halifax, Nova Scotia, Canada.<br />
Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.
</p>
<?php
} // k2_taa_footer
// Action calls for all functions
add_action('template_footer','k2_taa_footer');
?>

I was previously using a set of home-brewed PHP scripts to manage my site that I wrote a few years ago. Back then, WordPress was still buggy, hard to use and configure, and the styles weren’t as flexible.

My primitive scripts did the job well initially, when all I wanted was a few static pages. But now that I want to update my site more frequently, I looked for some simple content management system. I really considered only 2 alternatives: Drupal and WordPress. I know my way around Drupal pretty well so it was the first candidate CMS. However I had heard about the wide spread of WordPress, it’s popularity among bloggers, and the awards it had won. Needless to say, WordPress was my choice in the end. Here is why.

• Theming K2 to a simplistic and functional look was easier than theming Drupal.
• This is a single-user blog, I don’t need all the complexity of permissions in Drupal.
• I had a really bad experience with Drupal’s WYSIWYG editors, but WordPress’ editor seems to work more reliably.
• I wanted simple categories and none of the taxonomy headaches
• WordPress didn’t require configuration to work, only customization. Drupal would’ve required both.

I’ve been fairly happy with my WordPess setup that I plan to convert some of my primitive Drupal sites into WordPress.

The site has been redesigned in WordPress and the content is currently transitioning into this new look.

Feedback is welcome through the contact page or view comments.