Devious Media have created this interested info-graphic with comprehensive details about each of the platforms. Let’s’ have a look.

Click Image for a Larger Version

for setting up multiple databases I got help from symfony’s 1.2 documentation so I’m using same code that is used there.

in config/databases.yml file you’ve to define both master and client database dsn and credentials

all:
  master:
    class: sfDoctrineDatabase
    param:
      dsn: 'mysql:host=localhost;dbname=master'
      username: user
      password: secret
  client:
    class: sfDoctrineDatabase
    param:
      dsn: 'mysql:host=localhost;dbname=client'
      username: user
      password: secret

and your schema.yml file looks like this, see connection parameter Client Model uses master database connection and Store Model uses client database connection.

Client:
  connection: master
  columns:
    name: string(255)
    username: string(255)
    password: string(255)

ClientDatabase:
  connection: master
  columns:
    id:
      type: integer
      primary: true
      autoincrement: true
    hostname:
      type: string(255)
    username:
      type: string(45)
    password:
      type: string(45)
    database_name:
      type: string(45)
    client_id:
      type: integer
      notnull: true

Store:
  connection: client
  attributes:
    export: tables
  columns:
    name: string(255)
    description: string(500)
    client_id: integer
  relations:
    Client:
     foreignAlias: Stores

you’ve to rebuilt your models and database after defining these multiple databases.

Considering above schema as our example if a client logs in to our system it will use default client dsn connection but we have to load their Store info from their client DSN and that maybe on some other server defined in CustomerDatabase Table.

The best way to do is to create a filter for your app, define it in frontend/config/filters.yml file after rendering filter

rendering: ~
client_db_connection:
  class: ClientDbSelectFilter

now create a ClientDbSelectFilter.php file in frontend/lib directory and code will look like this.

<?php
class ClientDbSelectFilter extends sfFilter
{
  public function execute($filterChain)
  {
    if($is_authenticated)
    {
      $client = Client::getClient(); //get current loggedin client
      if($client)
      {
        $database = $client->getClientDatabase();
        $dbUser = $database->getUsername();
        $dbpass = $database->getPassword();
        $dbName = $database->getDatabaseName();
        $dbHost = $database->getHostname();
        if($dbUser != '' && $dbHost != '' && $dbHost != '')
        {
          $dbUser = $database->getUsername();
          $dbPass = $database->getPassword();
          $dbName = $database->getDatabaseName();
          $dbHost = $database->getHostname();
          $dsn = "mysql:host=$dbHost;dbname=$dbName";
          $doctrineManager = Doctrine_Manager::getInstance();
          $doctrineManager->getConnection('client')
                          ->setOption('dsn', $dsn);
          $doctrineManager->getConnection('client')
                          ->setOption('username', $dbUser);
          $doctrineManager->getConnection('client')
                          ->setOption('password', $dbPass);
        }
      }
    }
    $filterChain->execute();
  }
}

above code will not work as it is, obviously you’ve to modify it according to your application. The code that actually changes DSN for client database is as follows.

$dsn = "mysql:host=$dbHost;dbname=$dbName";
$doctrineManager = Doctrine_Manager::getInstance();
$doctrineManager->getConnection('client')->setOption('dsn', $dsn);
$doctrineManager->getConnection('client')->setOption('username', $dbUser);
$doctrineManager->getConnection('client')->setOption('password', $dbPass);
        

Let me know what do you think or if  it worked out for you or not in comments.

Enjoy!

I’m assuming you have Wampserver and mySql database running on your computer. If you don’t, you can go ahead and download Wamp setup from here. Installation is easy, ask your grandma to install it for you. Run it after its installed. Now,

Step 1 – Get latest version of WordPress from here.

Step 2 – Extract the contents of downloaded Zip in your C:\wamp\www

Step 3 – Rename the folder wordpress to whatever you want i-e NewBlog

Step 4 – Click the WAMPSERVER icon in system tray and click phpMyAdmin. Now look for MySQL localhost Section, Enter the name of your new database, It can be anything but remember it as you’re going to need it later on. Click Create and close the window.

Step 5 – Now open localhost in your browser. http://localhost/

Step 6 – Look for Your Projects section, you’ll find names of folders that are located in your c:/wamp/www/.. directory. Click the link of your new site ( same as the folder you renamed earlier i-e NewBlog )

Step 7 – You will see this message in your browser. Click ‘Create a Configuration File’ button.

Step 8 – Click ‘Lets go!’ on the next page.

Enter the same database name you created in phpMysql. Enter root for username and leave the password blank. Keep database host and table prefix as it is. Click Submit.

Congrats, your WordPress is ready to install. Next steps are as easy as touching yourself.

It will ask you to enter site name and password for the admin account. Follow the steps and once its done it will take you to your shiny Dashboard or to login screen. Easy cheesy, no rocket science; no dolphin pregnancy complications.

Have fun with WordPress.

-AFI

Most of the common image formats on the web today were established over a decade ago and are based on technology from around that time. Some engineers at Google decided to figure out if there was a way to further compress lossy images like JPEG to make them load faster, while still preserving quality and resolution. As part of this effort, we are releasing a developer preview of a new image format, WebP, that promises to significantly reduce the byte size of photos on the web, allowing web sites to load faster than before.

As mentioned above, WebP (pronounced “weppy”) is an all new image format set to replace the aging and bulky JPEG format, currently the king of the web. WebP, like JPEG, is a lossy compression format, so don’t expect images to look any better. However, WebP uses an entirely different compression method based on Google’s open-source VP8 codec, which results in images approximately 40% smaller than their JPEG counterparts.

WebP also utilizes a new container based on RIFF, allowing developers to insert metadata and potentially more future “features”.

Although WebP images will be smaller than JPEG versions, image quality may not be any worse, though we’ll have to wait and see for definitive proof. For a comparison, check out Google’s JPEG vs WebP gallery.

The new WebP image format has the potential to really “supercharge” the web. Google estimates that 65% of all data transmitted via web page is images and photos. With the potential ability to reduce that data by nearly 40%, WebP could result in your requested web pages and apps loading significantly faster.

Not only will end user’s pages load faster, but the data centers and web hosts around the world that deliver the massive amounts of content we consume daily will appreciate the dramatically reduced load they have to carry. Google is a prime example of a company that would greatly benefit from such a significant reduction in transferred data, [hopefully] without the loss of any visual quality vs JPEG.

But, taking things a step further, mobile networks will absolutely love the new format. AT&T has had quite a difficult time supporting the massive demand for data the iPhone has put on their network and a new image format such as this could potentially give these carriers the break they need, not to mention dramatically increase mobile web browsing speeds.

Here is Google’s complete blog post about the new WebP format.

As part of Google’s initiative to make the web faster, over the past few months we have released a number of tools to help site owners speed up their websites. We launched the Page Speed Firefox extension to evaluate the performance of web pages and to get suggestions on how to improve them, we introduced the Speed Tracer Chrome extension to help identify and fix performance problems in web applications, and we released a set of closure tools to help build rich web applications with fully optimized JavaScript code. While these tools have been incredibly successful in helping developers optimize their sites, as we’ve evaluated our progress, we continue to notice a single component of web pages is consistently responsible for the majority of the latency on pages across the web: images.
Most of the common image formats on the web today were established over a decade ago and are based on technology from around that time. Some engineers at Google decided to figure out if there was a way to further compress lossy images like JPEG to make them load faster, while still preserving quality and resolution. As part of this effort, we are releasing a developer preview of a new image format, WebP, that promises to significantly reduce the byte size of photos on the web, allowing web sites to load faster than before.
Images and photos make up about 65% of the bytes transmitted per web page today. They can significantly slow down a user’s web experience, especially on bandwidth-constrained networks such as a mobile network. Images on the web consist primarily of lossy formats such as JPEG, and to a lesser extent lossless formats such as PNG and GIF. Our team focused on improving compression of the lossy images, which constitute the larger percentage of images on the web today.
To improve on the compression that JPEG provides, we used an image compressor based on the VP8 codec that Google open-sourced in May 2010. We applied the techniques from VP8 video intra frame coding to push the envelope in still image coding. We also adapted a very lightweight container based on RIFF. While this container format contributes a minimal overhead of only 20 bytes per image, it is extensible to allow authors to save meta-data they would like to store.
While the benefits of a VP8 based image format were clear in theory, we needed to test them in the real world. In order to gauge the effectiveness of our efforts, we randomly picked about 1,000,000 images from the web (mostly JPEGs and some PNGs and GIFs) and re-encoded them to WebP without perceptibly compromising visual quality. This resulted in an average 39% reduction in file size. We expect that developers will achieve in practice even better file size reduction with WebP when starting from an uncompressed image.
To help you assess WebP’s performance with other formats, we have shared a selection of open-source and classic images along with file sizes so you can visually compare them on this site. We are also releasing a conversion tool that you can use to convert images to the WebP format. We’re looking forward to working with the browser and web developer community on the WebP spec and on adding native support for WebP. While WebP images can’t be viewed until browsers support the format, we are developing a patch for WebKit to provide native support for WebP in an upcoming release of Google Chrome. We plan to add support for a transparency layer, also known as alpha channel in a future update.

Sources: Google, Web Appstorm

But can WebP overtake the king image format JPEG. What do you think?

actAs:
  Timestampable: ~

Timestampable behavior  automatically adds a created_at and updated_at column and automatically set the values when a record is inserted and updated.  I mostly use Symfony Admin Generator to generate Backend. This behavior worked fined till Symfony 1.2, but in Symfony 1.3 / 1.4 for unknown reasons this behavior adds created_at and updated_at fields as required and their value must be filled during creation of new record in admin generator.

To fix this issue open your formClass located at

lib/form/doctrine/yourClassForm.Class.php

replace yourClass with actuall class name and add following code in configure function.

public function configure()
{
  //Following code will remove Required validators from these fields.
  unset($this->validatorSchema['created_at']);
  unset($this->validatorSchema['updated_at']);
  //following code will remove fields from form
  unset($this->widgetSchema['created_at']);
  unset($this->widgetSchema['updated_at']);
}

Hope this help