To have your routings work again, edit your module.config.php files and replace Zend\Mvc\Router\RouteStack with Zend\Mvc\Router\RouteStackInterface. That’s it.

For once I want to see a client flexible (and with budget generous) enough  to trust a development team and to allow them as much time as they need, not force them to develop half-solutions.

Walking on water and developing software from a specification are easy if both are frozen.

One of the most important issues for me is versioning . It doesn’t matter whether you are using svn , git , or whatever, it’s only important to be able to version via tags ( I use tags) or other mechanisms .

When you work from time to time on a particular project, you will certainly loose track of what you do and you will probably forget most of your code.   For me it’s important to know the differences between versions, even if I don’t plan them.

The standard versioning system is composed of 3 digits : like x.y.z . Most of the people think these numbers are random , or incremental , but they are not. For example if product A has the version 1.1.0 and the next version is 1.1.1 , i will know that some bugs have been fixed.  A changelog will  further detail this . If the next version will be 1.2.0 I know that some new features will be added to the product. If the new version will be 2.0 I know product A will go trough major changes and most of the base code will be rewritten and improved (also means backwards compatibility is broken).  And finally , if product A is versioned 0.y.z , I will know that the product is not considered ready yet.

How do I use this in my projects?

If I work on small things , bug related stuff, I will increase the minor ( z) . So from 0.1.0 I will go to 0.1.2 .

If I add new features, I will increase the middle digit (y). So from 0.1.0 I will go to 0.2.0 .

If I finish a first stable and complete version, I will go from 0.1.0 to 1.0.0 .

At deploy

Let’s say my current version is 0.1.2 and  the new version is 0.2.0 . My site being www.example.com , I find it convenient to create the following subdomains : sandbox and history.

First , I will place the new version ,  0.2.0 in the sandbox environment. All the testing will be done there. If everything looks ok,  example.com  contents  will move to history, and sandbox will move to the live site, example. com

So at this point, the environments will be as follow:

example.com - 0.2.0
sandbox.example.com - 0.2.0
history.example.com  -  0.1.2

If anything goes wrong , I will easily revert example.com to 0.1.2 , using the history environment.

Having versioning in place , allows you to see all the changes that took place in time , and also provide snapshot of your application from the past.  If you provide meaningful description to your commits, you will be able to generate a nice automated text that will build your changelog.

Hope this helps.

class Foo
{

    private static $_bar = null;

    private function getBar()
    {
        if ( null == self::$_bar) {
            //very expensive operation
            self::$bar = $this->expensiveOperation();
        }

        return self::$bar;
    }

    private function expensiveOperation()
    {
        return 1+1;//wow
    }
}

Extending the example

class Foo
{

    private function getBar()
    {
        if ( !this->isCached()) {
            //very expensive operation
            $this->saveCache($this->expensiveOperation);
        }

        return $this->getCache();
    }

    protected function saveCache($value)
    {
        file_put_contents($this->getCachePath(),$value);
    }

    protected function getCache()
    {
        return file_get_contents($this->getCachePath());
    }

    protected function isCached()
    {
        return is_file($this->getCachePath());
    }

    private function getCachePath()
    {
        return '/path/to/somefile.txt';
    }
    private function expensiveOperation()
    {
        return 1+1;//wow
    }
}
Final example
class Cache
{
    public static function isCached($tag)
    {
        return is_file(self::isFile(self::getCacheFile($tag)));
    }

    public static function save($value , $tag)
    {

        $file = self::getCacheFile($tag);
        file_put_contents($file , $value);
    }

    public static function load( $tag)
    {
        $file = self::getCacheFile($tag);
        return file_get_contents($file);
    }

    private static function getCachePath($tag)
    {
        return "/path/to/somefile_$tag.txt";
    }
}

class Foo
{
    public static function getBar()
    {
       if ( !Cache::isCached('my_tag')) {
            //very expensive operation
            Cache::save($this->expensiveOperation(),'my_tag');
        }
        return $this->load('my_tag');
    }

    private function expensiveOperation()
    {
        return 1+1;//wow
    }
}

All three examples are variations of the same technique.
Of course , the  file_get_contents thing is used for the example's sake only

This is a must have extension for devs who do a lot of refactoring , as you can see everything , including what uses or changes a variable , which in softwares like wordpress is a bless. Some pics bellow.

class a {
 //      private $stuff = array();
 public function foo()
 {
     $this->stuff['asd'] = 'foo';
 }

 public function __get($name)
 {
     return null;
 }
$a = new a();
$a->foo();

The above code will result in :

Notice:  Indirect modification of overloaded property a::$stuff has no effect

I think this happens only for 5.2.x . More details here.

I encountered this bug while refactoring a set of classes. The property got lost from the parent , who had a __get method set , and was called from the child class.

$image = new Image('/var/www/image.jpg');
$image->upload('http://www.somesite.com/upload.php');

However , when the Image class can not be used ,  most of use will google for  “how to upload an image with php curl”.

The following snippet of code can be used to upload a image:

$url = 'http://somesite.com/upload.php;
$file = 'image.jpg';

$curl  = curl_init($url);
curl_setopt($curl, CURLOPT_POST, 1);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POSTFIELDS,
             array('image' => "@$file;type=image;type=image/jpeg"));
$resp = curl_exec($curl);

Note the @ before the file. It will extract the binary contents of file , so be wary of your php memory limit.

One quick solution is to go to Magento->System->Roles , edit the Administrator group and set the permissions to All again.  Searching for a bug  related to this problem , I have found that the solution is allready posted here , so I’ll skip the rest of the details. Be sure NOT TO uncheck all the permissions and then save, or you  will not have to edit the database to restore your permissions  ( How cool is that? A store owner has to pay a programmer to fix the mess if he screws permissions).

If you accidentally found my post while trying to discover how you can create custom admin config options in Magento,  you can download a blank magento module (description here ), which can be used as a template for your admin configuration options.  Be adivsed that it still has the above mentioned problem.

K.

Because both Magento and WordPress have to be edited, neither can be upgraded anymore. And because you actually include and run WordPress code for each Magento request , a WordPress error will stop Magento from working.

And finally , wordpress content is only included and displayed within mangento , but not integrated.

Such lame plugins should never be posted.