Adam Leach

As promised, here is a post (similar to my Twitter API post) on using the Facebook API. There are many reason why one would want to access the Facebook API – maybe to create a mobile app that lets you post photos to your Facebook albums, or maybe you just want to show your last few Facebook status updates on your blog; what ever the reason may be, Facebooks Graph API mixed in with their PHP SDK makes it really easy to accomplish this.

Objectives

• Setup our environment
• Register an app on Facebook
• Understand the authentication process and extended parameters
• Understand Graph API
• Retrieve our latest status updates
• Add a new status update
• Retrieve our photos from our albums
• Add a new photo

Setup our Environment

You have two options here, you can access my github and download this project with all required files and library or you can follow this tutorial step by step – it’s really up to you. If you want to download all the files ahead of time, you can get them at this github repo. If you are going step by step, first create a folder (I’m calling mine facebook) in your server where you want this site, next create a folder named library in the root of this site, and finally add the following two files facebook.php and fb_ca_chain_bundle.crt in the library folder that you can get from the Facebook PHP SDK repo at: https://github.com/facebook/php-sdk/tree/master/src/.

Register an App on Facebook

I’m making the assumption you already have a facebook account and if you don’t, first create one. To create an app on Facebook, you first need to confirm your account by giving Facebook a phone number where they can send you a code. This may be a new process since I don’t remember having to do this a few months ago. Go to http://developers.facebook.com/setup and if your account is not verified, you’ll be prompted to add the information mentioned above. After verifying your accout, you’ll be taken to the ‘Create an Application’ page.

This is what the page should look like

Simply give your site a name and type in your site’s url and click create app. In my case I’m calling my app ‘Blog Test’ and my site would be ‘http://www.joeyrivera.com/’. Next you will be prompted to type in a captcha and continue. Now you are done setting up your app, you see a screen like the following with your app id and app secret:

Here is your app info

Authenticating and Extended Parameters

Facebook uses OAuth for authenticating involving tokens being send back and forth but we don’t have to concern ourselves with the details – the Facebook PHP SDK does it all for us. It makes sure to send all the required information in the proper format so Facebook gets what it needs and sends us back what we need. You can read more about authenticating with Facebook at their site and you can also read my Twitter API post that discusses the OAuth in a little more detail if you are interested. The SDK also takes care of handling all API calls for us so we only have to give it the resource we are trying to access, let it know if we want to do a get or post, and finally give it all the parameters required for the call.

Extended Parameters is an interesting way of restricting access to an app (I’m using the term app to describe what we are building here) through the API. Unless a user allows access to certain parts of their account, an app will not be able to modify nor read parts of the account even if they are authenticated. Extended Parameters need to be explicitly assigned at the point of authenticating. When the user is taken to Facebook and asked to allow access to their account, the user is also presented with all the various parts of their account this app wants to interact with. Here is an example of what the user will see when trying to authenticate with our app:

Extended Permissions

The first one in the screen shot is the default requested permission to access all the users basic information. The other three we need to accomplish our goals set including: read and post status updates as well as view and post photos. Here you can see a complete list of all the available extended permissions. If you access that link, you’ll see there are a lot of permissions. I recommend taking some time reading through their descriptions to get a better understanding of the kinds of things you can do with the API. There have been times where I’ve tried to do something with an app and the Facebook Graph API without success only to find out I hadn’t requested a required permission for that to work.

Time for code, what we are about to do is to create an array with our app id and app secret to feed to the Facebook class when we instantiate it. Next, we are going to check to see if we are authenticated and if not, redirect us to the Facebook authenticate page passing it the extended parameters we want access to. Below is the code for the config.php file. Download form my repository or create the file below on the root of your site:

config.php

Make sure to update the app_id and app_secret variables with the information you received from Facebook after registering your app. Let me give you a quick explanation of the code. First we include the facebook.php file that we downloaded from the Facebook PHP SDK github repository. Then we instantiate a facebook instance passing it the app id, app secret, and tell it to use cookies to store the session/token information after authenticating. Next we call getUser() to see if we are already authenticated – null means we are not, else we receive the users id. If we are not authenticated, we redirect the user to Facebook to authenticate. The url is provided to us from the getLoginUrl method. We are sending that method an array with a key req_perms (required permissions) and the value is a comma delimited list of all the extended permissions we want access to. Again, a complete list of all permissions can be found at Facebooks docs.

Go ahead and try to access this page in your browser. You should be immediately redirected to Facebook. If you are not already logged in with your Facebook account, you’ll first be asked to log in with the user which you want your app to access. Next you’ll see the ‘Request for Permission’ page, click allow and you’ll be taken back to the config.php page on your server. This process takes you back to the page which initiated the authentication which was the config.php page. We have now successfully authenticated with Facebook.

In testing your app, you may decide you need more or less extended permissions. While you are authenticated with Facebook and have your token stored in a cookie, you won’t be able to re-authenticate using this code since you’ll be getting a User object back so you have a few options: You can close your browser, clear cookies, and authenticate again after modifying your code; You can force another echo or header redirect to the getLoginUrl() again with the new parameters; or you can log into your Facebook account (the user you authenticated), click on account on the top right, privacy settings, and in the bottom left you’ll see application and websites, click on edit your settings. Under applications you use, you should see your app listed, click on edit settings. Finally click on the ‘x’ delete button to delete your app from the list. This will now remove your app from this users app list and won’t allow the app to access this account until the user authenticates again.

Graph API

This was confusing to me at first, specially since I keep rushing my project instead of taking my time to carefully look and read over the documents to truly understand what’s going on. Here is the Facebook Graph API overview if you would like to read that first but I’ll try to summarize it here. Graph API allows you to call various resources all of which will be returned to you as JSON objects. You’ll have to spend some time at the Graph API References page to understand the different objects available, parameters they have, and what the required extended permissions are to access them. I’ll try to explain connections in a sec.

Lets talk about the User object first. If you look at the reference page for user, you’ll see that to call the user object (the user who is authenticated by the app) you would call the graph api url with a ‘/me’ at the end. If the call is made successfully, you’ll receive a JSON object with all the possible properties defined in the reference page (if they are set). Here is a quick example.

user.php

If you run this code you get something like this:

This is my user object and properties.

Once you have the object, you can access it’s properties or do what you need with it. Now I’ll try to explain connections. If you look at the user reference page again and scroll down, you’ll see a connections section. These are the objects you can get that belong to this user. To access those objects you would call the url /me/object you want. For example, if you want to get this users albums, you would call /me/albums and this would return an array of album objects but remember to meet the required permission. For your app to access /me/albums, you need the user_photos extended permission (which we set in our config.php file).

So a connection is just a bridge between one object an another. Another example would be lets say we do as we did above and get all the users albums. Now we want to see all the photos inside each album. If you look at the album object, you’ll notice that under connections is photos which returns an array of photo objects. That is what we would call to get all the photos in that album for each album and you’ll see the code to do just this later on.

Get Status Posts

Create the following page and I’ll explain the code below.

status.php

First include the config.php file we created earlier (you’ll include this in all the other pages as well). The api method is what we’ll be using every time we need to call a resource and it can take in three parameters: the resource, get/post (defaults to get), and params (if any). In this case we want to call the statuses connection in the user object which returns and array of status messages. After receiving the messages, we loop through each and echo them out. If you want to see all the properties of each status, just do a var_dump on each status. That’s it, now the next example.

Add New Status

Here we are doing something a bit different, we are publishing to Facebook and for more info you can look at the Facebook Graph API Overview in the publishing section. We want to create a new post so lets look at the reference guide for information on post and its properties. Scroll down to the publishing section and notice we need the publish_stream extended property and you can see all the different properties that this object supports. I’m personally a bit confused on what is considered a required property and what it not, is seems nothing is required but for this example we want to submit a post with a message.

status_add.php

This is all the code required to make a post! It’s that easy. We call the api method, tell it we want to call the /me/feed connection, set method to post, and finally pass an array with the properties we want to set – in this case just the message property. If you wanted to set other properties, you would have set them in that array such as ‘link’ => ‘http://link.to.something’, etc. If the call is successfully, you’ll receive an id back which is the id for the new post you just created. Run this code and if all goes well, you should be able to go check our the users Facebook wall and see this latest post. I don’t think you can post the same message twice (unless I’m confusing Facebook with Twitter) so if you try it twice and it doesn’t work, that might be why.

View Photos From Albums

In this example, we want to get all the different albums for our user. Then we need to loop through each album and make a second call that will return all the photos for each album.

photos.php

Here we call the albums connection on user to get all the album objects. We loop through each and for each album get the album id to then call the photo connection on the album object. If this sounds confusing just let me know and I’ll try to explain this further. When I think of connections I think of joins in a db. It’s like saying I want to join the albums table for the user in the user table therefor retrieving all rows in ablum for a specific user.

Add Photo

In the interest of time and complexity, I’m just going to add a photo without specifying an album. By doing this, Facebook will automatically create a new album to add this photo to. Just know that you can specify an album to add photos directly too if needed.

photos_add.php

I choose this example for people that want to understand how to post a file through a service like this. First lets start at the top. We need to specify the path to the image we want to upload so change that path to where you file resides. Usually this would be the tmp path for a photo just uploaded to your server via $_FILE. Next we need to tell facebook to allow uploading of a file. I didn’t investigate that method much other then the comments said to specify the server so I use SERVER_NAME to signify this server. Next we make the call. We are calling /me/photos since that’s what is specified in the photos reference page under publishing. We are passing two parameters, message is the text that will show up with the image and source is the image we want to upload. Notice there is an @ before the path to the image. This is because we want to post the contents of the file and not pass a string to where the file is. Run this code and if all worked well, you’ll see this image and an new album in your users Facebook page.

Conclusion

If all went well, your users Facebook wall should look something like this:

My test users Facebook wall

I hope that with this, you have a good understanding on how Facebook’s Graph API works. Start trying to call other objects and play with different extended permissions. The Facebook team did a great job in providing us with the PHP SDK to make this so extremely easy so thumbs up to them. If you have any question/comments, just post them below.

The guide to redundant cloud hosting that I wrote recently will need some adjustments as I've fallen hard for the performance and reliability of DRBD and OCFS2. As a few of my sites were gaining in popularity, I noticed that GlusterFS simply couldn't keep up. High I/O latency and broken replication threw a wrench into my love affair with GlusterFS and I knew there had to be a better option.

Diagram of two web nodes with a replicated filesystem using DRBD & OCFS2

How does the performance compare to GlusterFS?
On Gluster's best days, the data throughput speeds were quite good, but the latency to retrieve the data was often much too high. Page loads on this site were taking upwards of 3-4 seconds with GlusterFS latency accounting for well over 75% of the delays. For small files, GlusterFS's performance was about 20-25x slower than accessing the disk natively. The performance hit for DRBD and OCFS2 is usually between 1.5-3x for small files and difficult to notice for large file transfers.

Couldn't you keep the data separate and then sync it with rsync?
Everyone knows that rsync can be a resource consuming monster and it seems wasteful to call rsync via a cron job to keep my data in sync. There are some periods of the day where the actual data on the web root rarely changes. There are other times where it changes rapidly and I'd end up with nodes out of sync for a few minutes.

To get the just-in-time synchronization that I want, I'd have to run rsync at least once a minute. If the data isn't changing over a long period, rsync would end up crushing the disk and consuming CPU for no reason. DRBD only syncs data when data changes. Also, all reads with DRBD are done locally. This makes is a highly efficient and effective choice for instant synchronization.

Why OCFS2? Isn't that overkill?
When you use DRBD in dual-primary mode, it's functionally equivalent to having a raw storage device (like a SAN) mounted in two places. If you threw an ext4 filesystem onto a LUN on your SAN and then mounted it on two different servers, you'd be in bad shape very quickly. Non-clustered filesystems like ext3 or ext4 can't handle being mounted in more than one environment.

OCFS2 is built primarily to be mounted in more than one place and it comes with its own distributed locking manager (DLM). The configuration files for OCFS2 are extremely simple and you mount it like any other filesystem. It's been part of the mainline Linux kernel since 2.6.19.

What happens when you lose one of the nodes?
The configuration shown above can operate with just one node in an emergency. When the failed node comes back online, DRBD will resync the block device and you can mount the OCFS2 filesystem as you normally would.

You're using an Oracle product? Really?
You've got me there. I'm not a fan of how they treat the open source community with regards to some of their projects, but the OCFS2 filesystem is robust, free, and it meets my needs.

Where's the how-to?
It's coming soon! Stay tuned.

Keep web servers in sync with DRBD and OCFS2 is a post from: Major Hayden's Racker Hacker blog.

c0b6ad7e-f251-11df-b20b-4040336e00ef

More than 100 Hadoop developers and enthusiasts congregated on the Yahoo campus for the monthly HUG meeting on November 17. As always, they were treated to some enlightening presentations in addition to good food and beverages.

After the usual 30 minutes of socializing and networking, James Dixon, the CTO of Pentaho, kicked off the presentations with an interesting talk on "Business Intelligence for Big Data." He spoke about the current Hadoop use-cases and its limitations when it comes to traditional BI use-cases. He introduced the concept of "data lakes" and spoke in depth about Pentaho's approach for BI on Hadoop. He ended the presentation with an interesting demo.

Here are the slides from Pentaho's talk.

Following is the video of the presentation.

This was followed by a talk on "Fuzzy Tables" by Ed Kohlwey from the strategy and technology consulting giant Booze Allen Hamilton. He introduced the audience to the concept of fuzzy matching and its application in the important field of biometrics. Biometrics DBs are a big data problem and hence a natural fit for Hadoop. He presented a detailed and in-depth look at the architecture and design of the Fuzzy Table concept and how it helps the biometrics databases.

Please see the link to the slides for more details.

The final presentation was by Ramkumar Vadali and his team from Facebook. They presented their implementation of HDFS RAID at Facebook. This is a very interesting and useful idea and has the potential to save a lot of storage space for real big-data customers of Hadoop. This presentation explained all the tradeoffs and benefits of this approach that has apparently saved Facebook 5 PB of storage.

Following are the slides from Facebook's presentation.

Here's the video of the Facebook presentation, HDFS-Raid.

This talk was a fitting end to an interesting HUG. Thanks to all the Hadoop users and presenters who attended the November HUG despite the imminent onset of the holiday season.

I know that everyone already knows this, but I happened to find out for myself recently!

I was looking at the way view helpers work in ZF2 and thought it would be more convenient if we altered the syntax a little. A side-effect of the change was that we'd have to use call_user_func_array, which is perceived as slow. I thought I'd whip up a simple test to find out how much slower it would be over a direct method call.

That is, how much slower is this code:

$a = new A();
call_user_func_array(array($a, 'b'), array(1));

than this code:

$a = new A();
$a->b(1);

Bear in mind that I don't do formal benchmarks and have no clue on methodology. Paul Jones is your man for proper testing of performance.

With that caveat out of the way this is the code I wrote to test:

benchmark.php

<?php

class A
{
    function b($a)
    {
        return;
    }
}

define ('ITERATIONS', 10000000);
$start = microtime(true);
$a = new A();
for ($i = 0; $i < ITERATIONS; ++$i) {
   $a->b(1);
}
$stop = microtime(true);
echo  'Direct method call: ' . ($stop - $start) . ' seconds' . PHP_EOL; 

$start = microtime(true);
for ($i = 0; $i < ITERATIONS; ++$i) {
   call_user_func_array(array($a, 'b'), array(1));
}
$stop = microtime(true);
echo  'call_user_func_array call: ' . ($stop - $start) . ' seconds' . PHP_EOL; 

This was the simplest possible scenario I could imagine and so would show call_user_func_array in the best possible light.

I ran the test on my laptop (using the command line) and got these results:

Direct method call: 21.155211925507 seconds
call_user_func_array call: 72.147792100906 seconds

i.e. call_user_func_array is around 3.5 times slower over 10 million iterations.

Nobody uses their laptop to serve a website though! Being the curious sort, I thought I'd test the difference of this script between PHP 5.2 and PHP 5.3 in a completely unscientific way as I'm lazy! I happen to have a server with both PHP 5.2 and PHP 5.3. on it, so I used that:

PHP 5.2:

Direct method call: 8.3424661159515 seconds
call_user_func_array call: 26.904649972916 seconds

PHP 5.3:

Direct method call: 3.35181903839 seconds
call_user_func_array call: 11.5989868641 seconds

As you can see, my server is much faster than my laptop :) Also, the relative difference is the same. i.e. PHP 5.3's call_user_func_array is as slow as it is in PHP 5.2.

I think I'll move everything to PHP 5.3 for the free performance gain! Of course, The question remains as to whether we should avoid call_user_func_array or not.

I would however recommend testing your own apps and see if it makes any difference and please don't take this post as anything other than something interesting I found out!

One of the most interesting topics I've seen so far during my RHCA training at Rackspace this week is SystemTap. In short, SystemTap allows you to dig out a bunch of details about your running system relatively easily. It takes scripts, converts them to C, builds a kernel module, and then runs the code within your script.

HOLD IT: The steps below are definitely not meant for those who are new to Linux. Utilizing SystemTap on a production system is a bad idea -- it can chew up significant resources while it runs and it can also cause a running system to kernel panic if you're not careful with the packages you install.

These instructions will work well with Fedora, CentOS and Red Hat Enterprise Linux. Luckily, the SystemTap folks put together some instructions for Debian and Ubuntu as well.

Before you can start working with SystemTap on your RPM-based distribution, you'll need to get some prerequisites together:

yum install gcc systemtap systemtap-runtime systemtap-testsuite kernel-devel
yum --enablerepo=*-debuginfo install kernel-debuginfo kernel-debuginfo-common

WHOA THERE: Ensure that the kernel-devel and kernel-debuginfo* packages that you install via yum match up with your running kernel. If there's a newer kernel available from your yum repo, yum will pull that one. If it's been a while since you updated, you'll either need to upgrade your current kernel to the latest and reboot or you'll need to hunt down the corresponding kernel-devel and kernel-debuginfo* packages from a repository. Installing the wrong package version can lead to kernel panics. Also, bear in mind that the debuginfo packages are quite large: almost 200MB in Red Hat/CentOS and almost 300MB in Fedora.

You can't write the script in just any language. SystemTap uses an odd syntax to get things going:

#! /usr/bin/env stap
probe begin { println("hello world") exit () }

Just run the script with stap:

# stap -v helloworld.stp 
Pass 1: parsed user script and 73 library script(s) using 94380virt/21988res/2628shr kb, in 140usr/30sys/167real ms.
Pass 2: analyzed script: 1 probe(s), 1 function(s), 0 embed(s), 0 global(s) using 94776virt/22516res/2692shr kb, in 10usr/0sys/5real ms.
Pass 3: using cached /root/.systemtap/cache/bc/stap_bc368822da380b943d4e845ee15ed047_773.c
Pass 4: using cached /root/.systemtap/cache/bc/stap_bc368822da380b943d4e845ee15ed047_773.ko
Pass 5: starting run.
hello world
Pass 5: run completed in 0usr/20sys/285real ms.

The systemtap-testsuite package gives you a tubload of extremely handy SystemTap scripts. For example:

# cd /usr/share/systemtap/testsuite/systemtap.examples/io/
# stap iotime.stp
15138470 6351 (httpd) access /usr/share/cacti/index.php read: 0 write: 0
15142243 6351 (httpd) access /usr/share/cacti/include/auth.php read: 0 write: 0
15143780 6351 (httpd) access /usr/share/cacti/include/global.php read: 0 write: 0
15144099 6351 (httpd) access /etc/cacti/db.php read: 0 write: 0
15187641 6351 (httpd) access /usr/share/cacti/lib/adodb/adodb.inc.php read: 106486 write: 0
15187664 6351 (httpd) iotime /usr/share/cacti/lib/adodb/adodb.inc.php time: 218
15194965 6351 (httpd) access /usr/share/cacti/lib/adodb/adodb-time.inc.php read: 0 write: 0
15195692 6351 (httpd) access /usr/share/cacti/lib/adodb/adodb-iterator.inc.php read: 0 write: 0
   ... output continues ...

The iotime.stp script dumps out the reads and writes occurring on the system in real time. After starting the script above, I accessed my cacti instance on the server and immediately started seeing some reads as apache began picking up PHP files to parse.

Consider a situation in which you need to decrease interrupts on a Linux machine. This is vital for laptops and systems that need to remain in low power states. Some might suggest powertop for that, but why not give SystemTap a try?

# cd /usr/share/systemtap/testsuite/systemtap.examples/interrupt/
# stap interrupts-by-dev.stp 
        ohci_hcd:usb3 :      1
        ohci_hcd:usb4 :      1
            hda_intel :      1
                 eth0 :      2
                 eth0 :      2
                 eth0 :      2
                 eth0 :      2
                 eth0 :      2
                 eth0 :      2

On this particular system, it's pretty obvious that the ethernet interface is causing a lot of interrupts.

If you want more examples, keep hunting around in the systemtap-testsuite package (remember rpm -ql systemtap-testsuite) or review the giant list of examples on SystemTap's site.

Thanks again to Phil Hopkins at Rackspace for giving us a detailed explanation of system profiling during training.

Tap into your Linux system with SystemTap is a post from: Major Hayden's Racker Hacker blog.

c0b6ad7e-f251-11df-b20b-4040336e00ef

I came across a situation last week where I needed to access a view helper that was in the default module's views/helpers directory when I was in another module. This came about because my layout.phtml uses a view helper that is in application/views/helpers.

By default, it doesn't work and you get an error along the lines of:

Plugin by name 'LoggedInAs' was not found in the registry; used paths:
Plan_View_Helper_: /www/funkymongoose/habuplan/application/modules/plan/views/helpers/
Zend_View_Helper_: Zend/View/Helper/

The fix is simple enough. All you need to do is add this line to your application.ini file:

resources.view.helperPath.Zend_View_Helper = APPLICATION_PATH "/views/helpers"

This will then ensure that the view helpers in your application/views/helpers directory are always available.

This also works for accessing the view helpers in any other module too where the syntax looks like:

resources.view.helperPath.{Module}_View_Helper =
    APPLICATION_PATH "/modules/{module}/views/helpers"

Finally, don't forget that the order is important if you have view helpers of the same name in different modules. Personally, I would try to avoid that if you possibly can :)

I've been using Vim for close to a decade. I've often said that "Unix is my IDE" -- because Vim is built in the Unix philosophy, allowing me to pipe input into it, out of it, and every which way I want. It fits very nicely with the Unix philosophy of doing one task well, and allowing redirection. I've found it ideal for web development in general and PHP development specifically -- in fact, I've had excellent experiences in every language I've tried my hand at developing in when using Vim.

Vim is also my chosen productivity suite. When I want to write a document, I don't go into OO.o Writer or MS Word or some other word processor; I open up a window and start typing. In most cases, I can either cut and paste my work into other tools, or pipe it to transformation tools. I worry about the content first, and the presentation later... like any good MVC application.

Like any good tool, you have to invest time in it in order to reap its benefits. My learning has, to date, fallen into three time periods:

• The initial months in which I first learned Vim, via vimtutor and Steve Oualline's Vim book.
• A period in 2006-2007 when I felt the need to make my coding more efficient, and first started playing with exuberant-ctags and omni-completion.
• The last quarter of 2010 (yes, that's now) when I was introduced to a number of new tools via Twitter.

So, this is my Vim Toolbox, 2010 edition.

JavaScript Framework Matrix – Overview with functions and examples.

From the site:

” The Javascript Framework Matrix ought to give you an overview of popular JavaScript frameworks and their functions. There are various examples for the frameworks and every snippet contains links to the official documentation. The choice of a framework depends on many factors and can’t be made of this document only. The matrix shall solely demonstrate the different API styles and functionalities of the JavaScript libraries.”

It is no secret -- there are many benefits of having a fast website. The faster your website loads, the longer a visitor is likely to stay. The actual stat is that for every 100ms, you lose 1% of your visitors. Google and other search engines have started to punish websites that load slowly by giving a SEO bump to those that load quickly.  And with or without research, you can just think about your own habits. If a web page takes a long time to load, you are likely to abandon it and move on to something else.

So, if making your website fast is important, what are some practical best practices to do so? The biggest websites online use a variety of resources and tricks to make their websites load as quickly as possible. Some common techniques include using a CDN (content delivery network), upgrading to a dedicated server, upgrading network equipment and running multiple data centers around the world. These techniques are all effective, but difficult for most websites because of costs, expertise, access and time - until recently. CloudFlare is a service that brings the tools previously reserved for the largest websites to every site online. 

How does CloudFlare work? 

When you sign up for CloudFlare (which takes 5 minutes), your traffic is routed through CloudFlare's network. Our network acts like a reverse proxy and is distributed all over the world. What that means is that we cache certain resources (like images) at our nodes. Our nodes are scattered all around the world and the idea is that we serve copies of resources from our nodes, rather than having to go to your origin server. So if your visitor is coming from San Francisco, their requests will go through our San Jose node and a visitor's request from Paris, would go through our Amsterdam node. The end result is that requests served from our nodes are closer to the visitor so they are delivered faster. And, the requests that go all the way to your origin server also happen quicker since part of the load is offset by CloudFlare's nodes. 

Rather than having to decide what does and does not get cached, CloudFlare automatically takes care of it for you. The result is that on average, a website on CloudFlare loads 30% faster than before. The performance benefit ranges site to site and depends on a variety of things including type of site and location, but for most websites, CloudFlare makes a noticeable difference.

Dynamic Websites

A common question is what happens if my site is dynamic? If your website is dynamic, you can still use CloudFlare. Our intelligent caching system will never cache dynamic content so the content is always fresh, but the same idea applies: we will take care of the larger images, CSS and Javascript, which means your server is freed up to serve the dynamic resources quicker. 

Who can use CloudFlare 

To try CloudFlare, it takes less than 5 minutes to sign up. Any website or blog can join as long as you own the domain name. So a website like CuteNinjaKittens.com works, but CuteNinjaKittens.Wordpress.com does not. The core service is free, which means that CloudFlare is accessible to any website online. 

CloudFlare was built because having a fast and secure website is essential. Our goal is to build a service to take care of speed and security for you, so you can get back to focusing on why you created a website in the first place. 

Side note: The photo of the cheetah was taken by one of our team members, Damon. Damon has a passion for photography and took this photo on one of his SE Asia trips. And in case you didn't know, the cheetah is the fastest land animal on earth.  

Related tips on improving website speed:
How to Optimize Websites and WordPress for Speed
Tips for speeding up WordPress blogs

Permalink | Leave a comment  »

• The new version 1.1 of the already improved InnoDB plugin is now the default (and only) InnoDB (in 5.1 the InnoDB plugin version 1.0.x was an optional engine).
• Multiple buffer pools and rollback segments, splitting of log_sys and flush_list mutex, and other improvements that together give a major contribution to the improved scalability and performance of 5.5.
• Thanks to the InnoDB team for continuing to do impressive work!
  

• In earlier MySQL versions LOCK_open, which protected table opening (among other things), was one of the main things that stopped MySQL from scaling on many CPU's, especially when many tables were used. By introducing proper DDL locking this issue is now mostly fixed.
• A big thanks to Konstantin Osipov and Dimitry Lenev for the hard work they have done in getting this to work.
  

• Thanks to Mikael Ronström for driving this!

• This was actually the result of a minor bug fix for how mutex and condition variables were used on Windows. By using native Vista primitives instead of homegrown ones, a big speedup was achieved.
  
• Thanks to Vladislav Vaintroub for getting this fixed!

• Thanks to Google and Mark Callaghan's team for providing the initial patches for this.
  

• Thanks to Marc Alff for driving and developing this.
  

• Done by MIT student R.J.Silk and Sergei Golubchik for MariaDB 5.2. Donated to Oracle by Monty Program Ab.
  

• As far as I know, this feature has been moved to appear in 5.6 enterprise and will not be part of the community server.

• This project was discontinued by Oracle the same day the feature was deemed ready to be pushed into 5.5.

• regression in parser compared to 5.1.x. This was reported just after 5.5 was released, but something like this should have been noticed during testing.
• regression compared to 5.1.x.
• cannot select from innodb_trx when trx_query contains blobs that aren't strings
• Object names not accessible via case sensitive reference on lctn=1 systems
• Change in execution plan for count_distinct_group_on_key causes 400 % performance drop
  

• cost calculations (in optimizer) are off
• Slowdown (related to logging) in 5.1.21 vs. 5.1.20
• Stored routines do not detect changes in meta-data.
• crash when federated table loses connection during insert ... select
• comparisons with Information schema tables don't honor collation
• Partitioning performance drops drastically with hundreds of partitions
• Event set to DISABLED and ON COMPLETION NOT PRESERVE is deleted at server start
  

OK, it is not the end of the world yet, but a leaked screenshot of the latest Yahoo all-hands shows that delicious has no bright future in the company.

So in order to preserve the years of work I put into this web service of awesome I am backing up my data. There are a few simple ways:

• Go to the terminal and do a “curl https://{your username}:{your password}@api.del.icio.us/v1/posts/all > bookmarks.xml” to get an XML file of your bookmarks
• Go to https://secure.delicious.com/settings/bookmarks/export to download an HTML document with your bookmarks

You can then import and sync your bookmarks in your browser of choice or upload them to Google Docs.

As to the future? Who knows?

We generate a lot of logs. To give you some sense, across the CloudFlare network every minute we write a half a Gigabyte of just log data. Collecting, reducing, sorting, and displaying that data back to you is one of the biggest challenges of running a service like CloudFlare. Over the last few days we've been upgrading our core logging infrastructure to make the displaying portion a lot faster. We want our stats page to be lightening quick whenever you load it or run a query. We were hitting an I/O bottleneck with some queries that produced what we felt were unacceptably slow results. While we have some long-term plans on how to enhance the core storage architecture to get around this, in the short term we needed a fix we knew would work so we turned to our friends at Fusion-IO.

Permalink | Leave a comment  »

Editor's note: This post originally appeared on the Delicious blog. We're reposting here for you to access:

What's Next for Delicious?

Many of you have read the news stories about Delicious that began appearing yesterday. We're genuinely sorry to have these stories appear with so little context for our loyal users. While we can't answer each of your questions individually, we wanted to address what we can at this stage and we promise to keep you posted as future plans get finalized.

Is Delicious being shut down? And should I be worried about my data?

- No, we are not shutting down Delicious. While we have determined that there is not a strategic fit at Yahoo!, we believe there is a ideal home for Delicious outside of the company where it can be resourced to the level where it can be competitive.

What is Yahoo! going to do with Delicious?

- We're actively thinking about the future of Delicious and we believe there is a home outside the company that would make more sense for the service and our users. We're in the process of exploring a variety of options and talking to companies right now. And we’ll share our plans with you as soon as we can.

What if I want to get my bookmarks out of Delicious right away?

- As noted above, there’s no reason to panic. We are maintaining Delicious and encourage you to keep using it. That said, we have export options if you so choose. Additionally, many services provide the ability to import Delicious links and tags.

We can only imagine how upsetting the news coverage over the past 24 hours has been to many of you. Speaking for our team, we were very disappointed by the way that this appeared in the press. We’ll let you know more as things develop.

Next week the YUI team will begin planning for release 2.9.0 to be shipped in the second half of Q1 2011. YUI 2.9.0 will be the last major dot-release of the 2.x codeline, and the team will be aggressively reviewing all open tickets against the YUI 2 project and either assigning them to be a part of the 2.9.0 release, closing them as “WON’T FIX”, or moving them to the YUI 3 project.

The reality of time and resource constraints forces us to focus on top priority items that will provide some closure to YUI 2.x and allow us to redouble our efforts on 3.x development. Here are some of the criteria that we’ll be using to guide us in deciding what should be included in release 2.9.0:

• Issues that negatively impact core use cases.
• Emerging issues related to new browser releases on the A-grade matrix.
• Enhancements and new features will be de-prioritized for YUI 2 and considered for YUI 3.

The transition of the YUI team from developing two parallel codelines to focusing solely on YUI 3 does not mean the end of the YUI 2 project. All present and future YUI 2 releases will continue to be hosted on the Yahoo! CDN, the YUI 2 codebase will continue to be hosted in GitHub, and we’d like to explore community-based maintenance of YUI 2 in the future.

As we continue our planning process, we’ll be fine-tuning our schedule, looking for feedback from the community, and communicating progress updates throughout the release cycle.

If you have a Zend Framework Front Controller plugin which throws an exception, then the action is still executed and then the error action is then called, so that the displayed output shows two actions rendered, with two layouts also rendered. This is almost certainly not what you want or what you expected.

This is how to handle errors in a Front Controller plugin:

1. Prefer preDispatch() over dispatchLoopStartup() as it is called from within the dispatch loop
2. Catch the exception and the modify the request so that the error controller's error action is dispatched.
3. Create an error handler object so that the error action works as expected.

This is the code:

<?php

class Application_Plugin_Foo extends Zend_Controller_Plugin_Abstract
{
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    { 
        try {

            // do something that throws an exception

        } catch (Exception $e) {
            // Repoint the request to the default error handler
            $request->setModuleName('default');
            $request->setControllerName('error');
            $request->setActionName('error');

            // Set up the error handler
            $error = new Zend_Controller_Plugin_ErrorHandler();
            $error->type = Zend_Controller_Plugin_ErrorHandler::EXCEPTION_OTHER;
            $error->request = clone($request);
            $error->exception = $e;
            $request->setParam('error_handler', $error);
        }
    }

}

That's it.

Learn best practices for apps running inside a mobile browser, as well as on desktops and devices.

As the technologies around HTML5 continue to develop, people need a better way to distinguish the more experimental parts of HTML5 from the parts ready for use in mainstream sites. The recent browser technology kerfuffle around WebSockets offers a clear example of the problem that developers and consumers will face again and again over support for emerging standards.

With many HTML5 technologies still under active development, our approach is to give developers better choices and avoid false dichotomies around standards support. The IE9 browser has site-ready HTML5 support that developers and consumers can depend on. We will also offer developers “HTML5 Labs” for more experimental technologies still under development. By clearly separating prototype implementations from mainstream browser product ones, we can avoid many negative consequences.

In the IE9 product, we’re delivering on the key parts of HTML5 that are site-ready. IE9 offers support for real-world web patterns that developers are using today as well as the HTML5 patterns we expect to become more mainstream. IE9 does this because we want to improve interoperability on the web by providing developers a consistent programming model through the same mark-up. The goal is supporting great new capabilities, ideally in a way that interoperates or will interoperate soon across browsers.

We will also offer prototype implementations for the more experimental or unfinished parts of HTML5 that some developers may want to try, but consumers can’t depend on yet. We will be explicit about the implementations that are more prototype than product. These prototypes are how we balance providing a product for millions of consumers while actively engaging in speculative technology discussions with developers and enthusiasts and avoid confusing either group. You can read more about that here.

In this post, we look at the pattern of putting unfinished technology into a product, the negative consequences of doing that, and our alternative approach for other HTML5 technologies that are still under construction today.

The WebSockets

First, WebSockets are a good idea.

They are both a technology and a set of standards that are under construction. They’re often included as part of the HTML5 discussion. With WebSockets, browsers and sites can do some neat things that are otherwise very hard, very slow, or not possible. You can see videos of some scenarios enabled at http://www.websockets.org/ – a site not actually related to any of the organizations working on the standard, but from a company that has some product offerings in the space.

Implementing a technology while the blueprints that describe it are still changing significantly causes many problems. In this section, we’ll use the experience of WebSockets to illustrate common challenges of under construction technologies. Below, through the transparency of Mozilla’s process, you can read for yourself how several different problems played out.

This is a view into the difficult discussions and decisions around a technology under construction: guarantees that websites will break multiple times between today and when the technology is finished, the security risks to people using the technology, and the challenge of listening to a lot of contradictory feedback.

Let’s look at bug number 602028 in Bugzilla, Mozilla’s issue tracking system. For people less interested in these details, this is a good place to skip ahead to the next section.

This bug was first reported 5 October 2010. The bug suggests initially that “while the final WebSockets protocol is sorted out,” Firefox should do “prefixing.” One of the first comments in the bug immediately stakes a position (of disagreement), and calls out the compatibility issue that developers will face writing sites that work across browsers with this technology under construction:

We most certainly should not… Prefixing in Gecko doesn't gain anybody anything… It only hurts us, because "Firefox doesn't implement HTML5". Comment 2

A subsequent comment cites the same facts – volatility and compatibility issues – as an argument in the other direction.

The reason that we want to prefix it is because we know, 100%, that it's going to change. We also know that other browsers will update it as well. We don't want it confused with… anything other than experimental and the best way to do that is prefix it as such.

The new version will not be compatible with existing implementations. Comment 7

Other comments go on to cite precedents for either course of action (here, and here), adding “WebSockets won't exit demoware status for a few years.” That’s a powerful comment about the pace of technology adoption. Cynically, the discussion goes on that “the who's-in-the-lead perception may trump all other considerations… We [Mozilla] are… constantly eating WebKit's dust. I would lay a bet we'll do it again here.”

A key point in the discussion is that developers “can be expected to expect their server's [sic] will break as new versions of WebSockets are implemented in browsers.” A Google employee working on WebSockets goes on to add “the best strategy is to just keep breaking people.” A Mozilla person responds with his concern that this

assum[es] that the developers will have the perfect knowledge of everything that's happening on the web, what the status is of various standards are and if things are going to change. Given my personal experience that's a dangerous assumption. Comment 27

That’s when someone brings up the security issue, and another person makes the observation that it might not be worth “being able to check-off another ‘HTML 5 support’ box on the marketing slides.” Someone goes on to say what the standard should do and that they should follow it, to which someone else responds:

That would be great. Except that there is no standard yet, just a series of working drafts, with incompatible handshakes, and no plan… that doesn't simply cause servers using older handshakes to barf on newer ones.Comment 73

The Negative Consequences

First, work on WebSockets continues today and Microsoft is part of that discussion. No one should interpret this recent news as the end of WebSockets.

One tech publication wrote that “the Web Sockets history illustrates some pitfalls of the style and pace of Web standards development,” and that “including support for a specification [that] wasn't done” is just the latest wrinkle. The article’s headline describes “the risk of unfinished standards,” while another article describes “emerging Web standards like WebGL and WebSockets,” and a comment from a Mozilla leader here refers to “speculative features.”

WebSockets is just one of many, many unfinished, emerging, and speculative features. Rushing ahead with implementation while the blueprints are changing a lot creates dissatisfaction. This (warning: potentially NSFW) video dramatizes that developer dissatisfaction. That dissatisfaction is the result of supporting unfinished, emerging, and speculative features in the mainline product.

The question is how to balance the implementation of these under construction technologies (in order to resolve under construction issues) with the needs of developers (who don’t like re-writing their code over and over to get new capabilities) and the needs of consumers (who expect sites and browsers to just work). Today, iPhone and iPad 4.2 support WebSockets. Firefox and Opera have recently disabled their implementations because of (among other things) the security and compatibility concerns.

An Alternative Approach, because WebSockets are Not Alone

One alternative approach to these experimental features is being much more explicit about implementations that are more prototype than product. This is the approach Microsoft is taking. You can read more about it here. Through these prototypes we balance the objective of providing a product for millions of consumers and engaging in early speculative discussions with developers and enthusiasts, without confusing either group.

There are many other technologies under development today that are still under construction. Because they are not site-ready today and will not be ready, relevant, and real-world before we release the IE9 product, these emerging standards are susceptible to the same problems and negative consequences that WebSockets has faced. Some technologies are in transition and being reconciled with others (or potentially abandoned in favor of others). SMIL animations and SVG fonts, though they are used in the Acid 3 test, are on the way out in favor of CSS animations and WOFF. The Web SQL specification, for example, was formally taken off the Recommendation track at the most recent TPAC with the emergence of IndexedDB as a better path.  IndexedDB is itself an emerging and unfinished standard, along with WebSockets, the File API and WebGL (as the Ars Technica article above points out).

Site-ready also looks at the larger context of developer needs today and tomorrow and the viable alternatives as well as the state of the standards process. For example, CSS3 is an enormous set of technologies. IE9 already implements many CSS3 modules that are site-ready. Several other CSS modules (like CSS3 Gradients) are still emerging and unfinished. Other modules have perfectly fine interoperable alternatives, like using script in place of CSS3 Transitions and CSS3 Animations. For other technologies, like web workers, other considerations apply as well. Web workers introduce complex multi-threaded programming concepts to JavaScript, and require extensive prototyping (just like WebSockets) to fully explore the impact on developers and the broader web programming model.

There are many technologies that can easily play out the way WebSockets have. Developers and consumers are better off if these technologies are brought forward as explicit prototypes rather than in the product that so many people depend on. WebSockets and the IndexedDB web storage are the first prototypes in the new program. Some experimental CSS3 modules are potential candidates for prototypes, along with other technologies (e.g. the File API). This is a process we’re excited to work through with the community.

Looking Ahead

In developing IE9, we considered how different specifications are still evolving at different rates. IE9 supports technologies that, while not always finished, are developed enough to avoid the problems that WebSockets illustrate today.

In the IE9 product, developers can expect site-ready HTML5 so they can take advantage of the best of HTML5 that is ready and can still experiment with emerging HTML5 with HTML5 Labs. By keeping these separate, developers get what they need without the negative consequences of co-mingling very different things in the same browser.

IE9 offers support for the most relevant, real-world web patterns that developers are using today as well as the HTML5 patterns we expect to become more mainstream. By relevant and real-world, we mean the technologies with the broadest impact for browser users (e.g. CSS ahead of MathML). By support, we mean providing developers a consistent programming model that enables the same mark-up. The goal is supporting great new capabilities, ideally in a way that interoperates or will interoperate soon across browsers.

This approach (along with its supporting points, like test suites and “same markup” as a goal) has garnered strong support from developers. It’s also resulted in some surprising headlines over the last year, like “Only Microsoft gets web standards” according to “Mozilla man [who] blasts Apple and Google for HTML5 abuse,” from The Register.

In this context of unfinished technology, measuring how much HTML5 different browsers support through “benchmarks” does not make much sense. In particular, many of these tests (like Acid 3) include different partial collections of unfinished standards, while they exclude deep or broad assessments of the quality of the implementations. The key questions for tests are how appropriate is their scope, how accurate and rigorous are the individual tests, and how comprehensive is their coverage. The standards bodies involved in the process of developing the standards (like W3C and Ecma) are a great forum for the development of trustworthy, high-quality tests.

Professional website developers are busy. They write a code for a living and genuinely don’t have the spare time to wade through comments on all these under construction specifications and keep track of every build of every browser. With this approach, we make it easier to take advantage of the capabilities that are stable and ready for prime time.  We remove much of the guess work for developers of working with a moving target. The result is more time for site developers to innovate and create better web experiences.

Back in March when we released the first platform preview of IE9, we were clear that we love HTML5 so much we want it to actually work. One aspect of that involves using the whole PC to run HTML with the best performance. Another aspect is working with community and standards bodies on test suites. Making sure that developers avoid the frustration of wasted time re-writing sites over and over as technologies change – and that consumers avoid frustration of sites that break easily – is just as important.

Thanks,

Dean Hachamovitch

We are happy to announce the release of Periodic, our first premium WordPress Theme. Periodic is a custom built theme suited for online magazines, news portals and large blogs. The simple, clean elegant interface is meant to be a perfect backdrop to your content. The theme is ready to start working, out of the box, with a multitude of theme options, custom widgets and shortcodes to help you personalize your environment.

The impetus behind Periodic

We have been toying with the concept of Periodic for nearly a year but were never afforded the proper time to dedicate to the project. After “vidagirl Magazine®” closed their doors earlier this year, the topic of conversation was ramped up significantly. We knew we developed a strong WordPress framework with the vidagirl custom theme and this would provide us with developmental jump start on the project.

So we looked at the old development concepts created for the vidagirl theme and started making decisions about what would work and what was appropriate for Periodic. vidagirl was first built for WordPress 2.7, so many of its functionality was deprecated and outdated. Periodic needed to show the muscle and extensibility of WordPress 3+. We knew custom menus, featured thumbnail images, custom widgets and an administrative panel were a must.

We also wanted to afford potential customers the ability to publish video posts using their YouTube hosted videos and elected to take this concept one step further by using the powerful jQuery plug in, Fancybox, to serve up videos anywhere you see the “play” button.

The design was to be uncluttered, modern and sleek. The color palette would consist of no more than 3 colors (you have 6 different color schemes to choose from) and the customer would be the decision maker regarding what functions of Periodic suited their needs. And, after a few weeks of throwing out design concept after design concept, we arrived at Periodic v1.

Periodic Theme Features

Periodic is packed with many of the features WordPress users are looking for in a custom theme. Aside from the WordPress 3+ custom menus, featured image thumbnail support, YouTube video posting and a powerful admin, Periodic sports 6 widget areas, 9 custom shortcodes, threaded comments, comment and author avatars and an author archive, just to name a few. For a full listing of Periodic’s features, please read About Periodic in the Periodic demo.

Purchase Periodic for $35

You can purchase Periodic today, for $35, from ThemeForest and be up and running in a matter of minutes. Periodic comes with regular free updates for all valid customers and we are always open to suggestions and feedback, from customers, on how we can further improve the theme.

Launch Demo

Since signing up for any new service can often lead to a number of questions, I created a guide of things you should know after activating CloudFlare. 

1. Check to make sure that your DNS records are correct on the DNS settings page.

If you need to add or edit entries to your DNS records, you can do so by going to:

Your Websites->Settings->DNS settings

One very important note to make about DNS: While CloudFlare can resolve DNS for all of  your subdomains, CloudFlare can only proxy domains that would be considered web traffic (www, blog, etc.). Please read more about the subdomains that are suitable to have a gray or orange cloud here.

2. Familiarize yourself with the CloudFlare Settings page

The CloudFlare Settings page is where you will find all of the optional features that can be turned on or off. Some key features on this page include:

CloudFlare Security Level Settings

Use case: You can set the security level for your website to high, medium or low.

CloudFlare’s Development Mode

Use case: You would want to turn this option on when you’re making changes to static files (javascript, CSS, images, etc.)  on your site that you want to appear immediately.

Purge Cache

Use case: You want to clear the CloudFlare cache of all the static files for a domain

CloudFlare --> Websites --> Settings (pull down menu) --> CloudFlare Settings

3. Install mod_cloudflare to get the original visitor IP

Since CloudFlare acts as a reverse proxy for you site, your visitor logs will show our IP addresses unless you make a modification to your server. We have a group of resources available here, including for Apache servers.

Note: WordPress users also have the option of installing ourWordPress plugin instead.

4. Whitelist CloudFlare’s IP addresses (recommended)

Whitelisting our IP ranges with your hosting provider ensures all of your website’s requests are served properly.

Note: CloudFlare customers that are activated through our partners,HostGator andVEXXHost, are not required to take this step.

5. Bookmark our Status Page

We run five data centers on three continents and we are constantly monitoring our systems. To get the most current updates, you can follow our:

System status page

Twitter System Status account

Finally, we get a lot of questions about the Pro service vs Free service. With the Pro service, you receive four additional benefits:

i) Faster subsequent page loads (so the second, third and fourth page loads are much quicker)

ii) Web Application Firewall to protect from comment spam, SQL injection and XSS attacks

iii) SSL compatibility

iv) Stats updates every 15 minutes (vs 24 hours)

The pro service is done on a month by month basis so you can easily try it for a month by choosing “Upgrade to Pro” in your CloudFlare account.

Also see:

CloudFlare and accessing cpanel

CloudFlare and ftp problems

If you ever have a question, please contact us. We read every email that we get and love to hear from our users.

Permalink | Leave a comment  »

There's been a lot of discussion on the MVP distribution list about various certifications and what SQL Server roles they cater to. Furthermore, there's a lot of disagreement on what the multitude of job titles mean. In this survey I'd like to find out what you think your primary job role is, and if you're up for it, add a comment or send email about what you job role is, what you're expected to do under that job role, and what you're not expected to do.

Note: I don't imply anything by the order of job roles in the survey.

em24_survey_x = "3c02eaf2-56a3-4c76-b596-3e385a302deb"; em24_survey_width = "255"; em24_survey_height = "338"; em24_styles = ".em24_s {border:solid 1px #626A84; width:250px;} .em24_s td {font-size:12px;} .em24_q {background:#798BC6; color:#ffffff;} .em24_ai0, .em24_at0 {background:#E7F3FF; border-top:1px solid #B3C7D9;} .em24_ai1, .em24_at1 {background:#E3F7DE; border-top:1px solid #B3C7D9;} .em24_v {background:#798BC6}";

I'll report on the results during the first week of January.

Thanks!

Here are two new HTML5 experiences you can run in your browser, designed in the spirit of the holiday season and with hardware accelerated HTML5 in mind.

Check out Santa’s Workshop, where the speed of your browser on your PC determines how many elves help pack Santa’s bag for the big night, and how fast they work. We built this experience using HTML5 technologies like integrated SVG graphics and HTML5 audio.

See how big of a storm your browser and your PC can kick up with HTML5 Blizzard. Your snowflake score shows you how many falling snowflakes can be animated in real time (60FPS). The more snowflakes you see, the faster your browser and PC. This experience combines HTML5 canvas, SVG, audio, CSS3 and WOFF fonts together to create a winter wonderland.

Just over a year ago we presented the earliest look at IE9 and how browsing experiences are better through the power of underlying hardware and operating system. Starting in March at MIX 2010, and throughout the year, we demonstrated our approach to bringing full hardware acceleration to the web in IE9. We showed continuing progress with the release of seven platform previews, the IE9 beta, and through samples on the IE test drive site.

We showed how web applications built on the next generation of hardware accelerated HTML5 approach the level of interactivity and performance found in native apps, and we had some fun along the way (as did many partners) – we hope you did as well.

Thank you!

Your participation and feedback is an important part of how we build IE9. Today we want to say thank you to everyone who has downloaded IE9 beta and previews, run the test drives, reported issues on Connect, or submitted feedback through the Send Feedback (alt+X, K) in IE9 beta. We also want to thank the people and groups who make the standards process work, the broad community of web developers, and enthusiastic consumers who work to move the web forward.

From the entire IE team, we wish you a happy hardware accelerated Holiday season, and we look forward to another exciting year on the web in 2011.

Rob Mauceri
Group Program Manager, IE

At YUIConf in November we released a preview of YUI 3.3.0, our next major release on the YUI 3 codeline. We’re now up to our third preview release, and if you have some time over the winter holidays to help us kick the tires we’d love for you to give it a spin. You can use the YUI 3.3.0pr1 seed file from the CDN to get started, download the distribution from YUILibrary.com, or check out the 3.3.0pr3 distribution hosted on YUIBlog (note: performance is quite sluggish on YUIBlog due to the lack of combo-handling; rest assured that your CDN-driven implementations generally will be faster than corresponding 3.2.0 usage).

Some of new things to look for in this release:

• all-new AutoComplete (beta)
• all-new Charts (beta), powered by SVG, Canvas and VML
• all-new DataTable (beta), the beginnings of a more modular upgrade from the popular YUI 2 component
• new Dial control (beta), an innovative take on a finite range control or slider created by Yahoo! designer Jeff Conniff
• all-new Resize utility (beta), provided by Eduardo Lundgren of Liferay, coauthor with Nate Cavanaugh of the YUI 3-based AlloyUI extensions available in the YUI 3 Gallery. (You can meet Eduardo and Nate in this AlloyUI whirlwind tour shot at YUIConf 2010.)

There is much more to love about YUI 3.3.0, and we’ll be sharing more information as the GA date nears. At present, we’re aiming for a release window in the second week of January. We welcome your feedback on the preview in the YUI forums and in the ticket database if you find issues of concern when you test out your own implementation with the new release.

My job is great: I get to play with technology and code most days. My job is also hard: how does one balance both functionality and usability in programming interfaces?

I've been working, with Ralph Schindler, on a set of proposals around the Zend Framework 2.0 MVC layer, specifically the "C", or "Controller" portion of the triad. There are a ton of requirements we're trying to juggle, from making the code approachable to newcomers all the way to making the code as extensible as possible for the radical performance tuning developers out there.

Every Thursday is Tech Thursday where we share a random assortment of technical links we found and liked:

How to create a 3-column layout with CSS.

Utilize the HTML5 File API to choose, upload, preview and see progress for multiple files.

An introduction to HTML Prototyping.

Apple released 5 free iOS development books via the iBooks store. I am unable to link to the books here, please download the iBooks app itself and search for 'Apple Developer Publications.'

Examples of SQL injection attacks.

HTML5 and CSS3 without guilt.

Spirit of Indiana (Jones) – syncing HTML5 video with maps. A guide to recreating the travel/flight sequences in the Indiana Jones movies using HTML5.

Watch this clip as Ben Stiller tries to explain Twitter and the Internet to Regis Philbin.

Wirify turns any web page into a wireframe.

Spritebox is a WYSIWYG editor for creating CSS sprites, currently in beta and looks to be a good tool to have in the toolbox.

Easel JS, a javascript library to help make working with HTML5 Canvas easier.

Mozilla and Peer 2 Peer University are creating the School of Webcraft, developer training that's free, open and globally accessible.