Notice: Unknown: "id" returned as member variable from __sleep() but does not exist in Unknown on line 0

as well as broken object relations on unserialized objects. But its very tempting to use the entities in situations that implicitly require serialization – for example in Zend_Auth. A “User” entity used in Zend_Auth would be written to session, and thus serialized implicitly, creating the already mentioned problems.

However, its relatively easy to create a proxy to the entity. For example:


class UserProxy {
    protected $entity;
    protected $identity;
   
    public function __construct($entity)
    {
        $this->entity = $entity;
        // Get the identifier from the entity
        $this->identity = $this->entity->getId();
    }
   
    public function __call($name, $arguments)
    {
        return call_user_func_array(
            array($this->entity, $name),
            $arguments);
    }
   
    public function __sleep()
    {
        return array('identity');
    }
   
    public function __wakeup()
    {
        $this->restore();
    }
   
    protected function restore()
    {
        if (!empty($this->identity)) {
        // Replace with however you get
        // the entity manager
        $entityManager = Zend_Registry::get('em');
        $this->entity = $entityManager
            ->find('User', $this->identity);
    }
}


Now you just use the proxy in place of the entity in situations requiring serialization.


$toSerialize = new UserProxy($userEntity);


Any method calls made to the Proxy will be forwarded to the entity by the magic method. If the Proxy object is serialized, upon waking up, it will use the identifier to restore the entity.

In Bisna/Application/Container/DoctrineContainer.php, find the method startORMMetadata (should be the last method in the file), and replace it with the following (apologies for messed up indentation ):


private function startORMMetadata(array $config = array())
{
$metadataDriver = new \Doctrine\ORM\Mapping\Driver\DriverChain();

if (($drivers = $metadataDriver->getDrivers()) && count($drivers) == 1) {
reset($drivers);
$metadataDriver = $drivers[key($drivers)];
}


return $metadataDriver;
}

You should be good to go. Hopefully this saved you some time in research. I’ll try to push this update to github as well.

Any comments about missed configuration options are always welcomed!

Every year millions of monarch butterflies fly more than three thousand miles from Canada to Mexico, to the same mountains where a year earlier their grandparents spent the winter. This phenomenon is the migration of the Eastern Monarch. Last month I took the trip, organized by Expedition Travel, to the Transvolcanic mountain range in Mexico to witness the colonies of overwintering monarchs.

The monarchs in the colony were quite active, thanks to plenty of sunlight. Their generation took the trip in the fall of previous year from Canada down to Mexico, where they spent the winter clinging to trunks and branches of the Oyamel trees. Now they were mating and flying north to Texas. They would reach Texas in early spring, and females will lay eggs on young milkweed plants before dying. The generation born from the eggs will live for a month, and make the trip further north, reaching Alabama, Carolinas, etc. The generation after them will continue the path north, reaching Pennsylvania, Ohio, New York. They also live for a month. The following generation is called Methuselah generation, since they end up living nine times longer than the previous generations, fly up to Canada, and then make their way back to Mexico, flying close to 50 miles per day during the migration, and then spend five months at the overwintering site.

What motivates the monarch to take this dangerous trip? Their host plant – the milkweed is more abundant in North America, than it is in Central. Mexico has 6 species of milkweeds, while US has over a hundred. Yet, they can’t just stay in North America, since they can’t withstand temperatures below freezing being a tropical butterfly. Milkweed is poisonous, but Monarchs are able to digest it, and use it for protection against the predators. A bird that eats a monarch experiences a heart attack, and will not eat another monarch, or anything that looks like it (ex: Viceroy).

Monarchs take various paths in getting to Mexico. Some follow the coast down to Texas, feasting on flowers blooming thanks to the fall storms, then fly across the land to Mexico. Others fly down to Florida, to Cuba, then to Yucatan, then follow the land back North to the Transvolcanic range. Monarch’s wings are covered with scales that repel water, so they’re able to rest on the water, assuming the waves are not high, and then take off from the water. Not much more is known about the paths that monarchs take, but what is known has been discovered thanks to the Monarch Watch tagging program.

The monarch is a butterfly ruled by the sun. When the autumn sun reaches fifty two degrees above the horizon, monarch reproduction cycle shuts down, and migration is kicked off. The generation that flies to Mexico has never been there, yet they’re able to find the exact spot year after year where their grand-parents spent the winter. It is believed they use a combination of senses to reach their destination. They’re able to orient themselves to the sun by using polarized light. Then they’re able to sense the magnetic field of the earth thanks to small magnetic sensors in the base of their wings. This is also extremely helpful, since the mountains where they end up for the winter are of volcanic origin, and are thus rich in iron. Finally, the millions of monarchs every winter leave behind billions of microscopic scales, and its possible that the monarchs are able to detect these using chemical scents.

Once the monarchs reach their destination, they start accumulating in clusters, with the base butterfly holding on to the pine needle, and others holding on to its wings. These clusters can get several butterflies deep, with the temperature in the center of the cluster slightly higher than on the outside. But there is a danger, where a strong enough wind will cause the base monarch to lose grip and fall to the ground. Several mice in the region count on this, and are ready to eat the fallen butterflies. They even line their nests with monarch wings for decoration. Who can blame them?

There are several factors threatening the monarch migration. The biggest threat to them is illegal logging. A biosphere reserve protects the locations of largest colonies, but local villagers frequently cut wood in the forests. The hundred year old pines they cut are critical to Monarchs survival of the winter, because their trunk holds heat, and monarchs layer the tree trunk relying on this heat source.

Another major threat is climate change. The migration relies on the timing of key events, for instance flowers blooming in Texas as they key food source for monarchs, or milkweed plants hatching. Any shifting in the timing of these events could threaten the entire phenomenon. Other threats are due to overpopulation, where wild fields are plowed over and used for agriculture, pesticides that are used poison the land, etc. No one wants to kill the monarchs, but unfortunately, they end up being collateral damage. Hopefully, we can preserve this amazing sight for our future generations.

It’s always mesmerizing to watch the process of metamorphosis. Last summer I had that opportunity. We found a dragonfly larva on the trail near Lost Pond in White Mountains, New Hampshire. The larva was ready to hatch, so I took my spot with the camera, and got ready to film the emergence.

View the slideshow of the emergence

To my surprise, after drying off, the larva continued its journey inland, away from the water. I thought it was unusual, as most hatch just above the water, or right near it. This one was very determined, and all my attempts to place it on a photogenic plant failed.

After crawling three or four yards from the edge of the water, the larva reached a tree. Only then did I notice three other exuvia (empty shells left after the dragonfly emerges) on the trunk. This one crawled up to the side of one about 6 feet off the ground, and finally stopped.

One other interesting thing to notice, is that the larva was missing the middle leg on the right side – lost to a predator earlier in its life. The emerged dragonfly was also missing a leg in the same spot.

Metamorphosis like this fascinates humans. We are amazed by this transformation for several reasons. Mostly because even in the twenty first century we still don’t understand it fully. But also because we see deep symbolism in the change that the individuals undergo through. Indeed, occasionally it takes a radical transformation, but what emerges is much grander than what was before.

First, let me state that although the book title implies the book is written for TYPO3 version 4.2 (which is deprecated now), the content applies equally well for the most recent version of TYPO3 4.4 (same is the case for my book). Second, I expected this book to be targeted at TYPO3 integrators – programmers who need to set up shops. Instead, this book is aimed at small, DIY business owners, trying their foot in e-commerce. The preface promises to walk the reader through setting up the site from scratch to build a profitable web presence. This is somewhat conflicting, as I found that some knowledge about TYPO3 is already required to begin reading this book.

One major issue I stumbled across is the lack of coherent flow in the book. This causes the reader to jump back and forth, as some sections don’t make sense until after subsequent chapters are read. This also leads to a lot of repeated content, and in general makes the book tough to follow. Let me walk through the chapters of the book and provide a better path to follow.

Chapters 1 & 2 cover basic TYPO3 installation, upgrades, templates, typoscript, and extension installation. Enough typoscript is given to confuse a newbie, so these chapters should only be read after some experience with TYPO3 basics. Likewise, if you’ve built a TYPO3 powered site before, you can safely skip this section.

Chapter 3 delves into the core of the book and describes the available commerce extensions. The description is very light, but the reader is instructed to consult the extension manuals for more information. The main extension chosen for the rest of the book is tt_products. Setting up a test paypal account is covered in detail, however most of the details of integrating it with TYPO3 and tt_products are left missing.

Chapter 4 starts by covering content import from CSV files, which is a bit premature at this point. It then explains adding new product using standard TYPO3 record editing features, and explains how to add a tt_products content element to a page. This is a chapter I would recommend rereading after experimenting with the shop setup.

Chapter 5 jumps into user registration, and covers frontend users and user groups. For commerce specific information, the book explains how to setup discounts for returning users.

The next chapter, chapter 6, diverges into menus, sitemap, navigation, and search. A lot of typoscript code is presented, but very little is explained, so the reader is expected to have a good foundation of typoscript at this point.

Chapter 7 provides a very light coverage of order management – something I would have liked to see more of, as it is arguably the most important step in the e-commerce flow after making a sale. No workflows, supply chains, or customer notifications are mentioned. The chapter also covers the basics of SSL and its integration into TYPO3. It also describes payment addins – something that was promised in chapter 3.

Chapter 8 gives an overview of the backend administration. Very little commerce specific information is given, and ideally this chapter should follow the installation chapter. Experienced TYPO3 users can safely skip this chapter.

Chapter 9 gives a top level of SEO optimization techniques. This is a topic that whole books could be, and have been, written on. Some TYPO3 specific information is given, but I would have preferred to see more.

Chapter 10 closes out the book by providing general tips for e-commerce, starting with basic business principles and ideas, and ending with site layout. This information is great for shop owners, but not for technical implementers. No TYPO3 specific information is given.

I was disappointed in not finding any information about TYPO3 and Magento integration, as that is a very popular topic. Unfortunately, its not covered at all in the book.

As a summary, if you were just starting out your TYPO3 e-commerce journey, I would recommend that you get some other introductory TYPO3 books (Building websites with TYPO3 by Michael Peacock and TYPO3: Enterprise Content Management at the minimum). Only then will you have a good foundation for this book, but then some of the chapters would become irrelevant.

If you want to see the language and type of information covered in the book, you can download a sample chapter.

Shooting spider webs can sometimes be tricky. Exposition is probably the toughest to get right. Camera meters are frequently fooled by the background, and the thin spider web ends up overexposed or blends into the background. What I found to work best is to position a bright web against a dark background, set the exposure to -1.5, and then play by ear (or rather by eye), checking to see if the image is exposed correctly.

Facebook introduced some new ideas, and expanded the existing products. The big announcements were centered around the Open Graph. It essentially allows you to treat any content on the web (identifiable by a unique URL) as an object in the graph. Users can interact with objects, “liking” them and thereby adding them to their profile and subscribing to status updates. This essentially takes Facebook interaction into the open web. It will be interesting to see how this concept evolves, as Facebook definitely hasn’t thought it through completely – specifically issues with duplicated objects from different sources.

Implementation of Open Graph objects is very simple, done through meta tags identifying the object and linking them to the administrator profile or application. Facebook also provides simple social widgets, specifically the like button, activity stream, and recommendations list. These widgets can be included as a simple iframe on any page, and show user’s friends interaction with the site, without requiring the user to login through Facebook Connect, as was previously the case. You can see examples of social widgets on CNN.com

Another big announcement was the Graph API. This is essentially a rewrite of the old API methods available on the Facebook in a simple, REST based fashion. The API centers on the concepts of objects and connections, and is self described through introspection, which allows the developer to see the connections available for the object. The object can be anything within the facebook system – and by extension on the open web through Open Graph. Furthermore, real time API updates ping your system when there are updates to the user data, so that you can take appropriate action. Authentication is based on oAuth 2.0 standard, and is much simpler than current implementation. Permissions are now simplified in one dialog box presented to the end user asking for very granular permission level the application needs.

Smaller, but still crucial updates came in areas of search, Facebook credits, analytics & insights, policy, and more. It’s too much to discuss here, but Open Graph has been the theme of the conference, and all updates center around the idea. Facebook is clearly moving in this direction, and is using its highly active user base to change the way we interact with the web.

Snowpocalypse, 2010

• TYPO3 for Connecting External APIs: Flickr and Youtube
• Rendering Images in TYPO3 4.3: Part 1
• Rendering Images in TYPO3 4.3: Part 2

I’m curious as to how well this material represents the book. Let me know your thoughts!

But even more – TYPO3 extensions can easily leverage this framework to cache their output, configuration, or anything else they need to cache. Furthermore, the choice of backend is left up to the individual installations. Some may decide to use DB tables, others files, yet some others will go with an in-memory caching system, like memcached, or APC. Choice of storage would be completely transparent to the extension, which will simply use the framework regardless of the backend.

Given all the caches TYPO3 offers, why would you want your own cache? Reasons vary. If your extension is a USER_INT object (which is not cached), but it queries the database, or external resources, you should use caching in your extension. Should the extension be used on a high traffic page, you don’t want it to become the point of contention.

In this simple guide, I’ll cover some basics of enabling caching in your extensions. I’ll assume you’re running TYPO3 of at least version 4.3.0, and your extension lists this as a dependency. If it doesn’t, make sure to surround all code using the caching framework with checks for TYPO3 version (use t3lib_div::compat_version() function), and test on all supported TYPO3 versions.

First you need to define the cache. Add this to the ext_localconf.php:

// If cache is not already defined, define it
if (!is_array($TYPO3_CONF_VARS['SYS']['caching']
   ['cacheConfigurations']['my_extension'])) {
   $TYPO3_CONF_VARS['SYS']['caching']
      ['cacheConfigurations']['my_extension'] = array(
      'backend' => 't3lib_cache_backend_DbBackend',
      'options' => array(
         'cacheTable' => 'tx_myextension_cache',
         'tagsTable' => 'tx_myextension_cache_tags',
      )
   );
}

We use the database cache as the default. So we need to define the cache tables:

CREATE TABLE tx_myextension_cache (
   id int(11) NOT NULL auto_increment,
   identifier varchar(128) NOT NULL DEFAULT '',
   crdate int(11) unsigned NOT NULL DEFAULT '0',
   content mediumtext,
   lifetime int(11) unsigned NOT NULL DEFAULT '0',
   PRIMARY KEY (id),
   KEY cache_id (`identifier`)
);
CREATE TABLE tx_myextension_cache_tags (
   id int(11) NOT NULL auto_increment,
   identifier varchar(128) NOT NULL DEFAULT '',
   tag varchar(128) NOT NULL DEFAULT '',
   PRIMARY KEY (id),
   KEY cache_id (`identifier`),
   KEY cache_tag (`tag`)
);

Of course, any installation can overwrite the default definition by writing the definition in localconf.php:

$TYPO3_CONF_VARS['SYS']['caching']['cacheConfigurations']
   ['my_extension'] = array(
   'backend' => 't3lib_cache_backend_MemcachedBackend',
   'options' => array(
      'servers' => array('127.0.0.1:11211'),
   )
);

Since the ext_localconf.php in our extension is included after localconf.php, the extension needs to check that the caching definition is not already defined.
Now in your extension you need to create and initialize the cache object:

if (TYPO3_UseCachingFramework) {
   // Create the cache
   try {
      $GLOBALS['typo3CacheFactory']->create(
         'my_extension',
         't3lib_cache_frontend_VariableFrontend',
         $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['my_extension']['backend'],
         $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations']['my_extension']['options']
      );
   } catch(t3lib_cache_exception_DuplicateIdentifier $e) {
      // do nothing, the cache already exists
   }
   // Initialize the cache
   try {
      $this->cache = $GLOBALS['typo3CacheManager']->getCache(
         'my_extension'
      );
   } catch(t3lib_cache_exception_NoSuchCache $e) {
      // Unable to load
   }
}


$this->cache will now hold the cache for your extension. You can now check if the cache has a certain ID:
$this->cache->has($id);
If it does, retrieve it:
$this->cache->get($id);
If not, then generate the content and store it:
$this->cache->set($id, $content, $tags, $lifetime);

See the interface for more operations you can perform on the cache. The greatest thing about the caching framework is the fact that the specific caching backend is completely transparent to you – and each installation can use whatever method they deem appropriate, without any changes to your extension.