OK, I am giving up the Jadoo project. It could have been a very interesting project. But if I don’t give up now, it will stay in my mind and prevent me from starting new projects or continuing more important projects. But it’s a temporary giving up: who knows how much time I’ll have in 2 or 3 months.

For those interested in Jadoo, here is the short story: everything started with a post on Alexandre Dulaunoy’s blog, then I tried a first version and finally I wrote a small update. Files are still here: jadwrite.py and jadpub.py.

I think the two main drawbacks with Jadoo are that I need to update files manually (a Python script could have done the job) and that I cannot post from any computer (I need Python, a text editor and all the previous posts -at least the last 10 ones- in order to update the blog). These are some points to think about before a possible come back.

Here are some news about the Jadoo blog engine …

• I updated the CSS file (2ko) and corrected some mistakes; now, all HTML/CSS tags are correctly used.
• I updated the main script in order to link to Technocrati for all tags
• I also updated the footer (= the side bar in the published page); it now includes the Technocrati search box
• I added the blogroll. It’s not showing links in random order like many other blog engines. But do we need that feature?

Some tasks still need to be done:

• Recover all my previous posts and add them here (it will be in PHP since everything is still in the DB on this website)
• To show previous posts, I am still wondering how it could be done. I want it to be fast and simple for the engine (no DB, remember?). And I want it to be simple and easy to navigate for the reader.
• Correct the RSS file (1ko) by adding the content in it and see why it doesn’t seem to work in most RSS feeds readers
• Think about how people can send comments. For the moment, readers can’t send comments. It’s a feature, not a bug. And it’s also like that in some other blog engines (like oddmuse but it uses "comment pages"). The vast majority of blog engines do include a comment tool. Do  I  you need it?

Although I didn’t do an in-depth (Merise/UML) analysis of what a blog engine should do and how it should do it (programmatically), I can say a blog is a really easy to write, at least its most common tasks like publishing posts. Nearly everything else is static text added (could be dynamically updated with PHP if you want) and a CSS style sheet. That’s why Jadoo can even work with non-PHP hosting plans. And you have a backup of all your posts, you don’t need to worry about dumping a database, etc. 🙂

Any further comment and/or advice are welcome (by e-mail).

Following my previous post where I retrieved EXIF tags from photos posted on Flickr, here is the next step: my script now stores data in a database.

There is a lot of free wrappers for databases in Python. Although I first thought of using pysqlite (because I am already using SQLite in another project), I decided to use Gadfly, a real SQL relational database system entirely written in Python. It does not need a separate server, it complies with the Python DBAPI (allowing easy changes of DB system) and it’s free.

Using Gadfly is very easy and their tutorial is very comprehensible. Put toghether, here is an example of the creation of a database, the addition of some data and their retrieval (testGadfly.py):

#!/usr/bin/python
# test for Gadfly
import os
import gadfly
import time

DBdir = 'testDB'
DBname = 'testDB'

if os.path.exists(DBdir):
    print 'Database already exists. I will just open it'
    connection = gadfly.gadfly(DBname, DBdir)
    cursor = connection.cursor()
else:
    print 'Database not present. I will create it'
    os.mkdir(DBdir)
    connection = gadfly.gadfly()
    connection.startup(DBname, DBdir)
    cursor = connection.cursor()
    cursor.execute("CREATE TABLE camera (t FLOAT, make VARCHAR, model VARCHAR)")

print 'Add some items'
t = float(time.time())
cmake = 'Nikon'
cmodel = 'D400'
cmd = "INSERT into camera (t, make, model) VALUES\
    ('" + str(t) + "','" + cmake + "','" + cmodel + "')"
cursor.execute(cmd)

print 'Retrieve all items'
cursor.execute("SELECT * FROM camera")
for x in cursor.fetchall():
    print x

connection.commit()
print 'Done!'

Regarding the initial project, the script became too long to be pasted in this post but you can download it here: flickrCameraQuantifier2.py (5ko). To run it, you should have installed the wrapper for EXIF and Flickr and the Gadfly DB system. In the beginning of the script, you can define the number of iterations (sets of queries) you want in total (variable niterations), the sleep duration between queries (variable sleepduration) and the number of photos to get for each query (variable nphotostoget). Everything will then be stored in a Gadfly database (default name: cameraDB). If you want to read what is stored, here is a very basic script: flickrCQ2Reader.py.

For example, I’ve just asked 125 queries (with 5s between each query). I’ve got 88 photos (70.4% of queries) with 27 photos without EXIF tags (30.68% of all the photos). Among all the camera makers, Canon has 27%, Fuji has 11%, Nikon has 18% and Sony has 21% of all the photos with EXIF tags at that moment. This is approximately what Flagrant disregard found. I don’t have time anymore but one could improve the data retrieval script in order to automate the statistics and their presentation …

Edit on October 9th, 2006: added the links to the missing scripts