Taylan Pince - Blog Posts

Movie Genie on Sale

2009-08-29T03:05:39-05:00

To celebrate its 10,000th download, Movie Genie will be on sale until Monday, August 31st. Get it 50% off if you haven’t yet!

Visit the bookmark »

Movie Genie and Big Picture Updated

2009-07-23T09:34:24-05:00

Updates for Movie Genie and Big Picture have been approved by Apple yesterday evening. While Big Picture only got a small bug fix release, Movie Genie 1.2.2 adds a number of new features that people have been waiting for:

Episode listings for TV series
Award details, categorized by year
Quotes
User Reviews
Full Synopsis
Certifications
Parental Guides
Extended cast & crew data
Improved navigation interface
Optimized performance
Alphabetical sorting for favorites
Improved connection reliability

I am very excited about these new abilities of the app. For more info, head on over to Hippo Foundry.

Django, Push Notifications, and Prowl

2009-07-17T13:41:18-05:00

One issue that I have had with this blog for a while has been the lack of notifications when a new, legitimate comment is posted under one of my articles. I don’t get many comments, but when I do, I would like to be able to respond right away. I don’t like email notifications, so when Prowl was announced this week, I was excited about the possibility of sending push notifications to my iPhone whenever a new comment was posted. It turned out to be much easier than I anticipated, thanks to Jacob Burch’s Prowlpy module and Django’s signals framework.

To setup push notifications for anything, you need to get these done first:

Register for an account at the Prowl site, then go to iTunes Store and buy Prowl for your iPhone/iPod Touch
After setting up your device, login to your account at the Prowl web site, click on Settings, and generate an API key
Download and install Prowlpy and httplib2. I opted for simply putting Prowlpy somewhere on my PYTHONPATH, and installing httplib2 through aptitude:
```
sudo apt-get install python-httplib2
```

Now that you are ready, simply create a signals.py file under whichever Django application you would like to use to send push notifications for, and use something similar to this for sending out messages to the Prowl API:

    from django.conf import settings
    from django.contrib.sites.models import Site
 
    from prowl.prowlpy import Prowl
 

    def comment_notification(sender, instance, **kwargs):
        """
        Connects to the Prowl API to send a push notification
        """
        if not instance.pk:
            prowl_api = Prowl(settings.PROWL_API_KEY)
            site = Site.objects.get_current()
 
            if prowl_api.verify_key():
                try:
                    prowl_api.post(
                        application="taylanpince.com",
                        event="New Comment",
                        description="A new comment has been published under blog post: %(title)s\r\n%(link)s" % {
                            "title": instance.post.title,
                            "link": "http://%(domain)s%(path)s" % {
                                "domain": site.domain,
                                "path": instance.post.get_absolute_url(),
                            }
                        }
                    )
                except Exception:
                    pass

Obviously, you also need to put your Prowl API key that you got from your account page earlier inside your settings.py file:

    PROWL_API_KEY = 'YOUR_API_KEY'

Finally, you have to link this signal to a model. In your models.py file, you can have the model call this method as a pre_save signal:

    from django.db.models.signals import pre_save
    
    from blog.signals import comment_notification
 
    
    class Comment(models.Model):
      ...
 
    pre_save.connect(comment_notification, Comment)

You could, of course, call this signal post_save as well. That’s up to you. In my case, I also do some spam filtering through the Akismet API, so it makes more sense to handle all of that in a pre_save signal and only send out a notification if a comment passes that check. I suggest you do something similar - it wouldn’t be fun to get push notifications for spam.

Finally, I had to fork the Prawlpy script and make some minor modifications to make sure the content is encoded properly. Unless you comment out the following lines in Prowlpy, you will get urlencoded strings in your notification:

    # URL-encode and string-ify keywords. Better type/content testing is needed here
    application = urllib.quote(str(application))
    event = urllib.quote(str(event))
    description = urllib.quote(str(description))
    priority = urllib.quote(str(priority))

And that’s it, now I will always be on top of the comments posted here!

App Store Review Frustrations

2009-07-17T09:48:51-05:00

Two days ago, Movie Genie’s main server, which provides all search results for the application, went down for about six hours, making it pretty much unusable to anyone. This was a dumb mistake on my part, since the issue was very easy to resolve, but I should have had the necessary precautions in place to warn me of the server downtime. I do have those running now, but it’s too late, and within those six hours, Movie Genie’s average rating went down from a full 5 stars to 2 or 3 in most countries.

This is, obviously, frustrating for me. I can’t blame the users who wrote those reviews. It’s human nature to not praise someone when they do a good job, but blame them the moment they fail. Movie Genie was downloaded by almost 3,000 people before this happened, and I had a total of thirty reviews from around the world, all of them ranging between 3 to 5 stars. While the servers were down, I got around fifteen 1-star reviews. It doesn’t matter that the app is working properly now, sale figures were down 50% yesterday. I don’t expect them to go up anytime soon.

My real frustration, though, is with Apple and the iTunes Store reviews. Customer satisfaction has been the most important thing for me since I started selling on the store, exactly a month ago. I replied to every email within an hour, tried to solve every issue, give everyone who cared to contact me the amount of time and interest they deserved. Unfortunately, with these reviews, I have no way of contacting my frustrated customers. I wish I could just send them an email and say: “Please, just try the app one more time”. But they are just nicknames on the iTunes Store with no contact information, and they probably will never launch the app again.

Even if they did, the process for modifying or deleting a review is so convoluted that they would never bother to take those unfair reviews back. I had a client who gave me a 1-star review contact me later. I convinced him that the problem was resolved, and he apologized for his unfair assessment. He told me that he emailed Apple so they can take down his review. I told him that Apple would never take his review down for him, that he had to do it himself, and gave him a step by step guide on how he can. He never responded back, and his review is still there.

So, there you have it. I am just frustrated, and I am not going to look at the Store rankings or reviews for a while. I’ll just keep my head down, focus on building new apps.

Big Picture now available on the App Store

2009-07-15T14:37:32-05:00

This is just a quick note to announce that my second iPhone app, Big Picture, has just been approved by Apple. This is a simple but elegant client for boston.com’s The Big Picture blog. To learn more about the app, follow the link.

Visit the bookmark »

Oggifier: A Simple GUI Wrapper for ffmpeg2theora

2009-07-03T19:07:43-05:00

With the release of Firefox 3.5 earlier this week, the discussion around HTML5 and its native support for video and audio tags suddenly gained speed. One of the major issues around these new features is the lack of proper video codecs that can be used. Apple’s Safari supports H.264, but Firefox and other open source browsers can’t, due to licensing problems. Their adopted open source format, OGG, seems like the way to go, but it’s not that easy to generate, especially if you are on a Mac.

Yesterday, John Gruber from Daring Fireball published a lengthy post about possible solutions for OGG conversion on Mac, and his suggestion was to use Jan Gerber’s excellent ffmpeg2theora. I thought I would spend some time and build a simple GUI wrapper for this tool so it would be more easily adopted by Mac users. Today I am releasing an early beta version of Oggifier, a simple GUI wrapper around ffmpeg2theora.

Apart from a clean and simple user interface, Oggifier provides two additional features that might be useful to people:

It comes bundled with the latest version of ffmpeg2theora, so you don’t have to deal with installing it (even though Jan Gerber’s package installer is perfect, dragging and dropping an app that handles everything for you is easier)
Oggifier supports automated updates through Andy Matuschak’s Sparkle framework, which means that you will receive future updates to both Oggifier and the ffmpeg2theora automatically

You can get Oggifier 0.3.0 here. Please let me know what you think in the comments. I am planning to add support for advanced ffmpeg2theora options within the next few weeks.

Update: I just published version 0.3.0 that adds a simple preferences pane with support for automated conversion and optionally quitting after the process is complete.

Movie Genie is now available on the App Store!

2009-06-16T10:08:53-05:00

This is just a quick post to let everyone know that Apple has finally approved Movie Genie yesterday night and it is now available on the iTunes Store. Contrary to what I expected, the approval process was painless, and Apple did a very good job of reviewing the app for possible defects.

I hope that people will enjoy this first app, I am very excited to be building on this platform. If you have any suggestions or comments, feel free to email me or leave your thoughts here.

Movie Genie is Ready for Beta Testing

2009-05-13T15:44:00-05:00

I haven’t been blogging much lately, but I do have a good excuse this time. Last month, I decided to finally start learning Objective-C and getting into iPhone & Mac development. Being a Mac user for 18 years now, developing on the platform has been one of my dreams.

Today, I am happy to announce my first iPhone app, Movie Genie - a mobile IMDb client. It’s open for beta testing at this point, and I welcome everyone interested in trying it out and giving feedback.

Visit the bookmark »

Easier Translations with django-rosetta

2009-04-08T11:27:39-05:00

I just found out about this Django application called django-rosetta that uses the Google AJAX Language API to suggest translations for translatable strings in your project. Even more interesting is the admin-like interface it creates to enter translations directly from a browser - and it doesn’t need any database tables, everything is directly written to translation files. I didn’t try it out yet, but if it works as advertised, it could become one of my default applications.

Visit the bookmark »

Django Toronto Meetups

2009-04-02T22:57:22-05:00

Tonight was the latest in a series of get togethers among Django developers in the Toronto area. We have been doing these for the past few months, since October 2008, and even though our numbers haven’t grown much, I am pretty sure there are other Djangonauts in Toronto who would be interested. We are planning to do monthly scheduled meetings with proper presentations at the Linux Caffe first Wednesday of every month. So join the mailing list and let’s start organizing!

Visit the bookmark »

Schema Migrations with South

2009-04-02T11:26:03-05:00

For the past few months, I have been trying out the different schema migration tools for Django. At first, the obvious choice seemed like django-evolution. It was the oldest and the most mature project, and after watching the schema evolution panel from DjangoCon 2008, it was also the one that made most sense in terms of architecture. After working with django-evolution in a few projects though, I found that it did not work well in practice. I have recently been testing South, and it seems like the better choice.

I had a few big issues with django-evolution:

Inability to go backwards or forwards, or to be able to skip migrations (or mutations as it calls them)
Inability to use custom fields that require additional parameters
Lack of integration with syncdb (if someone in the team accidentally does a syncdb, it fails)

I love how clever evolution can be when guessing the modifications to a model, but I don’t think what’s needed from a migration tool is cleverness. I needed a tool that gave me the freedom to do whatever I wanted, while making my job easier by managing all the changes.

I have been playing around with South for the past week, and it seems like it offers pretty much everything I need, plus a bit more. My only grief with it is the lack of documentation. I think they should stop focusing on adding any more features to the project and write a solid documentation with tutorials instead.

One of the best features of South is that it doesn’t need to be on a project from the very beginning, it works on a per-app level, and can be attached to an app at any given time. You simply generate an initial migration by calling the startmigration command. Let’s say we have an app named blog:

./manage.py startmigration blog --initial

This will create a migrations directory inside the application, and the next time you call syncdb, South will prevent Django from synchronizing this application, since it is now marked as an app managed by South. In order to apply the migration, you will have to call migrate. If this is a new app that’s not in the database yet, we can simply do this:

./manage.py migrate

If this is an old app that was already synchronized by using syncdb, then we have to mark this migration as “applied” without actually applying it:

./manage.py migrate blog --fake

Let’s say we added a new model under the blog app called Article, we can once again call startmigration to generate it for us:

./manage.py startmigration blog add_article_model --model Article

What if we forgot to add the slug field to the model we just created? Let’s generate the migration for adding that field:

./manage.py startmigration blog add_article_slug --add-field Article.slug

We could also modify the default migration generated by South to populate that slug field. Here is a quick example:

from django.db import models
from django.template.defaultfilters import slugify
from django.utils.translation import ugettext_lazy as _
 
from south.db import db
 
from blog.models import *
 

class Migration:
    
    def forwards(self):
        db.add_column('blog_article', 'slug', models.SlugField(_("Slug"), max_length=255, default=""))
        
        articles = Article.objects.all()
        
        for article in articles:
            article.slug = slugify(article.title)
            article.save()
 
    def backwards(self):
        db.delete_index('blog_article', 'slug')
        db.delete_column('blog_article', 'slug')

There are a few interesting bits here. First of all, we make sure the slugify method is imported so we can generate the slugs, but we also import the lazy translation method, ugettext_lazy because it’s being imported with a custom name.

In the forwards method, we make sure that the slug field has a default value, otherwise PostgreSQL will complain about a NOT NULL field being created without values. After creating the column in the database, we loop through all articles and generate slugs for them.

In the backwards method, there is an additional call to delete_index. This is required to remove the index on the slug field, South does not add this automatically.

Now we can migrate:

./manage.py migrate blog 0003

And that’s it! So far, I really like the freedom and ease of use South is giving me.

Django and mod_wsgi

2009-04-01T09:10:44-05:00

Finally, Django’s recommended deployment method switched from mod_python to mod_wsgi. Updated docs are now online.

Visit the bookmark »

Periodic Table of Typefaces

2009-03-30T09:39:17-05:00

I love this - a list of popular typefaces grouped categorically in a periodic table format!

Visit the bookmark »

sorl.thumbnail and Custom Processors

2009-03-27T10:54:24-05:00

In the past few months, sorl.thumbnail has become one of the standard libraries I always include in my Django projects. It’s unobstrusive and very easy to implement into templates, but my one grief with it has been the lack of capability for doing some custom processing on images. As it turns out, sorl actually allows custom processors to be added. When I found out about this feature, I set out to write some for my current project.

If you haven’t heard about the processors functionality, it’s all in the documentation. I am not sure how I missed it before. Implementing is pretty easy, first you have to define a THUMBNAIL_PROCESSORS variable in your settings.py file:

THUMBNAIL_PROCESSORS = (
    'sorl.thumbnail.processors.colorspace',
    'sorl.thumbnail.processors.autocrop',
    'sorl.thumbnail.processors.scale_and_crop',
    'sorl.thumbnail.processors.filters',
 
    'imagery.processors.pad',
    'imagery.processors.round',
)

The first four are obviously sorl’s own default processors. The last two are my custom ones. “pad” allows resizing without cropping, while keeping the final image dimensions always the same. So basically it centers the resized image in an area and fills the rest of the image with a given background colour:

from PIL import Image
 
THUMBNAIL_PADDING_COLOUR = (255, 255, 255)
 
def pad(im, requested_size, opts):
    """
    Adds padding around the image to match the requested_size
    """
    if "pad" in opts and im.size != requested_size:
        canvas = Image.new("RGB", requested_size, THUMBNAIL_PADDING_COLOUR)
 
        left = floor((requested_size[0] - im.size[0]) / 2)
        top = floor((requested_size[1] - im.size[1]) / 2)
 
        canvas.paste(im, (left, top))
 
        im = canvas
 
    return im
 
pad.valid_options = ("pad", )

The other one, “round”, is a bit more complex. Basically I needed a processor to add rounded corners to an image by pasting a mask on top. Since it’s not possible to pass parameters to a processor, I ended up having a method that can take one of a few rounding options and use the actual name of the option to find the correct mask file:

ROUND_VALID_OPTIONS = (
    "round",
    "round-box",
    "round-wide",
)
 
def round(im, requested_size, opts):
    """
    Adds rounded corners around the image
    """
    try:
        mask_type = filter(lambda x: x in ROUND_VALID_OPTIONS, opts)[0]
    except IndexError:
        mask_type = None
 
    if mask_type:
        mask = Image.open(os.path.join(THUMBNAIL_ROUND_MASKS_PATH, "%s.png" % mask_type))
 
        im.paste(mask, (0, 0), mask)
 
    return im
 
round.valid_options = ROUND_VALID_OPTIONS

This makes sorl indispensable for me!

Running Safari 4 Beta with Safari 3

2009-03-25T14:37:30-05:00

When Apple announced the Safari 4 Beta, I was itching to try it out right away, but I knew that if I installed it, the current WebKit would get wiped out my system. This might be acceptable for most, but I would like to keep testing my sites against Safari 3 at least for another year before moving on. So I waited until someone came up with a solution to install them side by side. Brian Mastenbrook’s package extractor seems like exactly what I need, it works very well for me so far.

Visit the bookmark »