If you log in to the Google AdSense site and mouse over the “10″ banner from the lower-left corner for a few seconds, Google will start a retro Ping Pong game. Google celebrates 10 years of AdSense and this is just a small gift. “AdSense has helped over two million partners grow their businesses in the last 10 years,” says Google.

{ Thanks, Mark. }

There’s just one week and a half and Google Reader will be history. If you’re using the service, it’s a good idea to niche services. Google wants to create products that are used by hundreds of million of users and Google Reader wasn’t one of them. Feedly and other similar services will have to find a business model for something that’s no longer cool, no longer supported by many browsers, no longer supported by Twitter (other sites to follow). For many people, social sites offer better value than feed readers and not even Google could change that.

“As a culture we have moved into a realm where the consumption of news is a near-constant process. Users with smartphones and tablets are consuming news in bits and bites throughout the course of the day — replacing the old standard behaviors of news consumption over breakfast along with a leisurely read at the end of the day. (…) Google is looking at pervasive means to surface news across products to address each user’s interest with the right information at the right time via the most appropriate means,” said Richard Gingras, Senior Director, News & Social Products at Google.

So what will you use instead of Google Reader?

Google Forms added a printing option. You can find it by clicking the print button from the toolbar or you can use the keyboard shortcut Ctrl+P.

It may not seem much, but Google made this feature more useful by changing how the forms look when printed. “When you print a form, each question is formatted in a way that makes it simple for people to fill in when printed on paper,” informs Google.

For example, Google includes helpful messages like “Example: December 15, 2012” when you’re supposed to write a date or “Mark only one oval” when you need to pick a single answer. The text box for longer answers is replaced by a few dotted lines.

It’s a much better option than clicking “view live form” and printing the page.

{ via +GoogleDrive }

Last week, I read a post by Beau Simensen about resource location in PHP. It was interesting, because I had already pondered over this topic in the context of Symfony2. Thinking about how to make Beau’s proposal work for Symfony2 brought me to a result that hit me like a stone. Both he and Amy Stephen made me realize how much this could change not just Symfony2, but the PHP ecosystem as a whole. After PSR-0 and Composer, this is the next important step to ensure interoperability between PHP libraries. And it could almost completely replace the new and hotly debated autoloading PSR. Let me take a few minutes of your time to explain why.

Resource Location

In almost every PHP application, you need to locate some kind of resource. A resource, in this context, could be a template file, a configuration file, an image or any other kind of tangible asset in your project. Zend Framework 2, for example, ships translation files for its validation messages. The configuration for using these files looks like this:

$translator = new Zend\I18n\Translator\Translator();
$translator->addTranslationFile(
    'phpArray'
    __DIR__.'/../vendor/zendframework/zendframework/resources/languages/en.php',
    'default',
    'en_US'
);
Zend\Validator\AbstractValidator::setDefaultTranslator($translator);

You provide an absolute path to the file and the translator will know where to find it. This works well and is generic. Unfortunately, it is also verbose and couples the configuration to the specific directory structure of the zendframework/zendframework package.

Resource Identifiers

Many libraries and frameworks reduce verbosity by inventing some kind of identifier for resources.  Let’s take an example from the CakePHP documentation:

class UsersController extends AppController {
    public function view_active() {
        $this->layout = 'Contacts.contact';
    }
}

The string “Contacts.contact†is the identifier of a layout template that is going to be used as layout for the view_active action. This template must be located in one of the following paths:

• /app/Plugin/Contacts/View/Layout/contact.ctp
• /app/View/Plugin/Contacts/Layout/contact.ctp

So it can be shipped with the Contacts plugin, but also overridden in the application. Essentially, CakePHP creates a mapping from resource identifiers (such as “Contacts.contactâ€) to paths in the file system. What happens if you want to use a *.ctp file that is located somewhere else, for example in a package you just installed via Composer? That’s not possible.

Let’s look at another example from Symfony2. In Symfony2′s configuration system, you can import configuration files into other configuration files. Let’s look at a typical routing configuration:

_wdt:
    resource: "@WebProfilerBundle/Resources/config/routing/wdt.xml"
    prefix:   /_wdt

Again, a custom kind of resource identifier is used to refer to the wdt.xml file in WebProfilerBundle. What if you want to import a routing configuration file from some place that is not in a bundle? Not possible (except if you use the absolute path, but that’s not portable so I’ll dismiss this solution).

This list goes on, but the pattern repeats.

Autoloading

Let me take a short excursion to talk about autoloading. As you probably know, autoloading refers to the dynamic loading of class files when classes are used for the first time. PSR-0 did a great deal to unify autoloading among PHP projects, and a new PSR (“PSR-Xâ€) is being discussed to improve PSR-0.

The core of PSR-0 is the mapping of class names to paths on the file system. For example:

require __DIR__.'/vendor/composer/ClassLoader.php';
 
$classLoader = new Composer\Autoload\ClassLoader();
$classLoader->add('Acme\\Demo', '/path/to/acme/demo');
$classLoader->register();
 
// loads /path/to/acme/demo/Controller/ContactController.php
$controller = new Acme\Demo\Controller\ContactController();

Do you see the pattern? Mapping identifiers of classes to PHP files and namespaces to directories is essentially the same as all the other mappings described before.

Let’s extend this example: What if I want to load some file from a location that is known to the autoloader? For example, I know that config.ini is located in the same directory as the class Acme\Demo\Application. The only way to do this right now is by using reflection:

$reflClass = new \ReflectionClass('Acme\\Demo\\Application');
 
$file = dirname($reflClass->getFileName()).'/config.ini';

But reflection is slow.

Uniform Resource Location

What if we could solve all of the above problems and use cases with one simple pattern? Our basic requirements are:

1. Map resource identifiers to one or more paths on the file system.
2. Use the same identifier pattern across different PHP libraries to make them interoperable.

The good thing: A specification for Uniform Resource Identifiers (URI) already exists (RFC 3986). Why not reuse it?

Let’s see how we could leverage URIs to locate PHP classes and files or directories relative to PHP classes:

$locator = new ResourceLocator();
$locator->addPath('classpath', '/Acme/Demo/', '/path/to/acme/demo');
 
echo $locator->findResource('classpath:///Acme/Demo/Parser.php');
// => /path/to/acme/demo/Parser.php
 
echo $locator->findResource('classpath:///Acme/Demo/resources');
// => /path/to/acme/demo/resources
 
echo $locator->findResource('classpath:///Acme/Demo/resources/config.ini');
// => /path/to/acme/demo/resources/config.ini

This is basically the same thing that autoloaders are doing today, but a little more generic. The presented URIs have two parts:

• a scheme: “classpathâ€
• a path: “/Acme/Demo/Parser.phpâ€

The “authority†(“host:portâ€) part is empty, which is why the double slash (“//â€) is immediately followed by the initial slash of the path. Other URI parts like the query (“?queryâ€) are not required as well, but could be added for custom (non-interoperable) implementations.

An autoloader can be based on such a resource locator b turning backslashes into forward slashes:

spl_autoload_register(function ($class) use ($locator) {
    include $locator->findResource('classpath:///'.strtr($class, '\\', '/').'.php');
});

Many of PHP’s standard functions can be used to work with URIs:

echo dirname('classpath:///Acme/Demo/Parser.php');
// => classpath:///Acme/Demo
 
echo dirname('classpath:///Acme/Demo/Parser.php');
// => Parser.php

As you see, URIs are a very strong concept that decouples resource location completely from the mechanisms of individual framewo

Truncated by the Symfony feed aggregator, read more.

Google announced some Google+ changes last week but some of them were rolled out gradually and I couldn’t see them.

The Google+ notifications button looks different: it’s now a bell. The number of new messages is more subtle and looks like iOS badges. The new notifications tray separates the messages you’ve read from the messages you haven’t read yet. There’s a new button that lets you “mark all as read” and a funny message: “All caught up!”. Thumbnails are bigger and you’ll sometimes see 4 of them for each message. The notifications tray now supports infinite scrolling, so you can read all your messages. One thing that’s missing is the support for keyboard shortcuts: they were really useful.

These aren’t all the changes: “When you read a notification on one device, we’ll mark it as read on your other devices. Likewise, dismissing a notification (with a swipe or a click) does so everywhere, so you can say goodbye to annoying repeats.”

Just in case you want to see the old interface for notifications, here are some screenshots:

{ Thanks, Garfield. }