Tag: Symfony2

Symfony2 vs Django – Models

As promised in my first post, I’m going to be looking at the reasons I chose to go with Django rather than Symfony2. Aside from wanting to learn a new language, there were a few things that jumped out at me when looking into Django.

One of the biggest was the dramatic amount of code necessary to do the same thing in Symfony2. Let’s look at a typical model for a blog. Here’s what it looks like in Django (I’ve added a small utility function via a manager):

models/blog.py

from django.db import models
class BlogManager(models.Manager):
def get_tags(self):
# get just the tags
tags = self.values('tags')
# combine all tags into a single list
all_tags = []
for tag in tags:
all_tags += tag.values()[0].split(',')
# strip whitespace
stripped_tags = [tag.strip() for tag in all_tags]
return stripped_tags
class Blog(models.Model):
title = models.CharField(max_length=255)
slug = models.CharField(max_length=255)
author = models.CharField(max_length=100)
blog = models.TextField()
image = models.CharField(max_length=20)
tags = models.TextField()
created = models.DateTimeField('date created', auto_now_add=True)
updated = models.DateTimeField('last updated', auto_now_add=True, auto_now=True)
objects = BlogManager()
def __unicode__(self):
return self.title
class Meta:
app_label = 'app'

view raw

blog.py

hosted with ❤ by GitHub

Now here’s the same model in Symfony2 along with the utility function:

Entity/Blog.php

<?php
namespace NewCoInc\AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;
use NewCoInc\AppBundle\Lib\FormattingLib;
/**
* Blog
*
* @ORM\Table(name="blog")
* @ORM\Entity(repositoryClass="NewCoInc\AppBundle\Entity\BlogRepository")
*/
class Blog
{
/**
* @var integer
*
* @ORM\Column(name="id", type="integer", nullable=false)
* @ORM\Id
* @ORM\GeneratedValue(strategy="IDENTITY")
*/
private $id;
/**
* @var string
*
* @ORM\Column(name="title", type="string", length=255, nullable=false)
*/
private $title;
/**
* @ORM\Column(type="string")
*/
private $slug;
/**
* @var string
*
* @ORM\Column(name="author", type="string", length=100, nullable=false)
*/
private $author;
/**
* @var string
*
* @ORM\Column(name="blog", type="text", nullable=false)
*/
private $blog;
/**
* @var string
*
* @ORM\Column(name="image", type="string", length=20, nullable=false)
*/
private $image;
/**
* @var string
*
* @ORM\Column(name="tags", type="text", nullable=false)
*/
private $tags;
/**
* @ORM\OneToMany(targetEntity="Comment", mappedBy="blog")
*/
private $comments;
/**
* @var \DateTime
*
* @ORM\Column(name="created", type="datetime", nullable=false)
*/
private $created;
/**
* @var \DateTime
*
* @ORM\Column(name="updated", type="datetime", nullable=false)
*/
private $updated;
public function __construct()
{
$this->comments = new ArrayCollection();
$this->setCreated(new \DateTime());
$this->setUpdated(new \DateTime());
$this->formatter = new FormattingLib();
}
/**
* Get id
*
* @return integer
*/
public function getId()
{
return $this->id;
}
/**
* Set title
*
* @param string $title
* @return Blog
*/
public function setTitle($title)
{
$this->title = $title;
$this->setSlug($this->title);
return $this;
}
/**
* Get title
*
* @return string
*/
public function getTitle()
{
return $this->title;
}
/**
* Set author
*
* @param string $author
* @return Blog
*/
public function setAuthor($author)
{
$this->author = $author;
return $this;
}
/**
* Get author
*
* @return string
*/
public function getAuthor()
{
return $this->author;
}
/**
* Set blog
*
* @param string $blog
* @return Blog
*/
public function setBlog($blog)
{
$this->blog = $blog;
return $this;
}
/**
* Get blog
*
* @return string
*/
public function getBlog()
{
return $this->blog;
}
/**
* Set image
*
* @param string $image
* @return Blog
*/
public function setImage($image)
{
$this->image = $image;
return $this;
}
/**
* Get image
*
* @return string
*/
public function getImage()
{
return $this->image;
}
/**
* Set tags
*
* @param string $tags
* @return Blog
*/
public function setTags($tags)
{
$this->tags = $tags;
return $this;
}
/**
* Get tags
*
* @return string
*/
public function getTags()
{
return $this->tags;
}
/**
* Set created
*
* @param \DateTime $created
* @return Blog
*/
public function setCreated($created)
{
$this->created = $created;
return $this;
}
/**
* Get created
*
* @return \DateTime
*/
public function getCreated()
{
return $this->created;
}
/**
* Set updated
*
* @param \DateTime $updated
* @return Blog
*/
public function setUpdated($updated)
{
$this->updated = $updated;
return $this;
}
/**
* Get updated
*
* @return \DateTime
*/
public function getUpdated()
{
return $this->updated;
}
/**
* Add comments
*
* @param \NewCoInc\AppBundle\Entity\Comment $comments
* @return Blog
*/
public function addComment(\NewCoInc\AppBundle\Entity\Comment $comments)
{
$this->comments[] = $comments;
return $this;
}
/**
* Remove comments
*
* @param \NewCoInc\AppBundle\Entity\Comment $comments
*/
public function removeComment(\NewCoInc\AppBundle\Entity\Comment $comments)
{
$this->comments->removeElement($comments);
}
/**
* Get comments
*
* @return \Doctrine\Common\Collections\Collection
*/
public function getComments()
{
return $this->comments;
}
/**
* Set slug
*
* @param string $slug
* @return Blog
*/
public function setSlug($slug)
{
$this->slug = $this->formatter->slugify($slug);
return $this;
}
/**
* Get slug
*
* @return string
*/
public function getSlug()
{
return $this->slug;
}
}

view raw

Blog.php

hosted with ❤ by GitHub

Entity/BlogRepository.php

<?php
namespace NewCoInc\AppBundle\Entity;
use Doctrine\ORM\EntityRepository;
class BlogRepository extends EntityRepository
{
public function getTags()
{
$blogTags = $this->createQueryBuilder('b')
->select('b.tags')
->getQuery()
->getResult();
$tags = array();
foreach ($blogTags as $blogTag)
{
$tags = array_merge(explode(",", $blogTag['tags']), $tags);
}
foreach ($tags as &$tag)
{
$tag = trim($tag);
}
return $tags;
}
}

view raw

BlogRepository.php

hosted with ❤ by GitHub

Wow, that’s a TON of code. I will mention that Symfony2 does offer some tools to help generate this code, which are very helpful. But it feels to me like they’re trying to overcome the shortcomings of the language.

Django Nomenclature

The first basic thing to know is Django doesn’t use the MVC nomenclature like Symfony2 and others do. It uses MTV – model, template, view. For the most part same thing, different name.

Other naming conventions are pretty much the same – you’ve still got config files, database fixtures, routing, static files (js, css, images, etc.), logs, tests, etc.

It’s how these are implemented where the differences become apparent.

Time for a Switch? PHP / Symfony2 vs Python / Django

UPDATE: Check this post for a comparison of Symfony2 and Django models.

UPDATE 2: For a framework speed comparison, check out this post.

For the past few years I’ve been using the CodeIgniter PHP framework for projects at TBWA. It’s a simple, straightforward framework that has done a solid job. New devs can get up to speed quickly on it with very little training and the framework itself is speedy enough for my purposes. But things have progressed significantly over the past couple years. I’m about to embark on a new project and it’s possibly time for something new.

After a bit of research I narrowed things down to sticking with PHP and moving to the Symfony2 framework or moving over to Python / Django. I won’t get into a debate of what language is better, faster, more elegant, more awesome, etc. There’s plenty of that out there already.

For me the choice is simple, use a language I know or make the switch to something new. Final destination for this will be a 3-tier set up on AWS or a similar cloud provider. I’m using RightScale which provides ServerTemplates for both PHP and Django, making tuning and rapid deployment (via Chef) about the same for both. So the implications of running servers for one vs the other aren’t necessarily a concern (yes, performance is a valid issue but I believe either framework can be tuned to achieve acceptable throughput as demonstrated by the sites currently using them).

Before diving into Python I decided to quickly learn Symfony2 first since I already know PHP. The framework site has a ton of clearly written docs so it was easy to get up to speed. This tutorial was also very helpful. There’s a lot going on with Symfony2 – Composer for dependency management, Doctrine for ORM, Twig for templating, Assetic for asset management, PHPUnit for testing, etc. Of course all of these can be used without Symfony2, but the framework does a nice job of making them all play nicely together. It’s clearly where PHP development is headed. It you choose this direction, I highly recommend PhpStorm as your IDE as it’s got built-in support for the framework.

With that out of the way it was time to learn some Python / Django. Having zero experience with either the language or the framework, I decided to dive right into the Django docs, picking up Python along the way. Again, many of the same features can be found with this setup – pip for dependency management, Django’s built-in ORM and templating engine, webassets for asset management, unittest2 for testing, etc. Django also has a simple admin interface that can be automatically generated which I’m sure would come in handy for some projects. The getting started docs are a little sparse in comparison but a quick Google search will usually answer any question. And again, Jetbrains has a great IDE for Django development – PyCharm.

One last factor to take into account was who is behind these frameworks. On the Symfony2 side we’ve got SensioLabs (a French digital agency) and Fabien Potencier along with multiple contributors. Django, on the other hand, is backed by the non-profit Django Software Foundation with a governance board, core team and multiple contributors. License wise, Symfony2 is MIT while Django is BSD.

Based on the title you’ve probably guessed I’ve selected Django. But first, I’ll use the next couple posts to explore some of the differences in the frameworks as well as development workflow and configuration.