Order fulfillment with Swiss Post and YellowCube

Setting the stage

We live in a time where more and more goods are purchased online. May it be your airline ticket or the diapers for your newborn, many things are often cheaper and more conveniently purchased online. As comfortable it is for the customer buying things this way, as challenging it can be for the seller. They need to have an online presence that is easy to use and need to have all goods in stock to sell and send them quickly.

This means that selling physical products requires sufficient storage space on-site, people that handle picking, packing and shipping and someone that handles returned goods. All this factors can sum up to a costly venture, especially when you don’t have any infrastructure from other sales channels already.

Architekture PostLogistics YellowCube Connector

The PHP-YellowCube interface is part of all YellowCube extensions for PHP based web stores

What is order fulfillment?

This is where YellowCube comes in handy. YellowCube is a fulfillment service offered and run by Swiss Post. But what is a fulfillment service anyway? In the case of YellowCube it means everything to do with the storing and shipping of the products you sell on your store. This means receiving and storing of the products, handling of the inventory, picking, packing, shipping and handling of returns.

How to implement it into your web shop?

So far so good, but how does this translate into real life? Liip has, in close collaboration with Swiss Post, developed a PHP-YellowCube-SDK and also the integration for Magento and Drupal web shops. The PHP-YellowCube interface provides an object-oriented wrapper to the SOAP based interface provided by Swiss Post. The code is readily available on Github. Please feel free to contribute to the PHP-YellowCube-SDK, as well as the Magento extension or the Drupal extension.

Please explain…

Now that we know about the SDK, we need to know how the basic process works. I want to show you what needs to happen in order to implement YellowCube successfully into a web shop. The process is agnostic to a certain integration, so I won’t go into details how it is integrated in a specific shop extension. I will explain the basic process, which applies to all web shop integrations in the same manner (more or less).

Continue reading about Order fulfillment with Swiss Post and YellowCube

Tags: , , , ,

Magento 2.0 Release

Finally Magento 2 has been released! I am especially glad as an ex-Magento employee. The Magento team has created a powerful and modern framework for eCommerce and I congratulate all of my ex-coworkers for this great milestone. But my post is not about that. Just after the release, there appeared a lot of blog posts that Magento 2 platform has changed the eCommerce world. But did it? In this post I am not going to describe all of the M2 bright sides (it has too many of them). My intend is to perform honest and objective M2 unboxing and to look inside of it from the point of view of the Magento community even if it’s going to be painful.

Magento Flag

Note: Magento 2 positions itself as an eCommerce solution and a ready-to-use product, not just a framework. Therefore my opinion about Magento 2 is based on this statement.

Continue reading about Magento 2.0 Release

Tags: ,

Magento Config Search

Working with Magento configuration it is always a chore. To make a change, you have to find a necessary section, then open it, then open its subsection, then sub-subsection and probably some more… and only after a dozen of cliсks you can finally change necessary Magento configuration item.
Once, while testing new functionality, after routine search of some rarely used settings, I finally got tired and decided to improve this process a little bit.
My attention was drawn to the search field at the top of the admin panel. Existing ‘admin search’ already knew how to perform search among customers, products and orders, so why not to add configuration section to this list as well? As always, I expected that I would have to rewrite basic functionality to achieve the desired result, but I found out a nice way to extend this functionality.

Configurations for the search is stored in the file below:


So, the injection was very easy. I had to add my search model only into the adminhtml/global_search node.

My ConfigSearch model is looking for the matches in the config fields labels, also it takes into account translations. The search result shows you the full config field label and its full path. When matches are found, you’ll see something like this:


When you click on one of the displayed results, you’ll be redirected to the page with this configuration section opened. The field will also be highlighted, so you can find and edit it even more quickly. Task is done!


I hope that this extension will help you a little bit with the navigation in the Magento Admin panel.
source code

Tags: , ,

Adding JavaScript and CSS files to head section of Magento

This is a guest post by Tim Bezhashvyly.

Have you ever wonder why are there so many ways of adding JavaScript or CSS file into a Magento page? The task is quite ordinary and can be accomplished by even junior Magento developer. The thing is each of us has just one approach in his arsenal when in fact the variety of available methods is much wider.

Finding out the complete list is easy. All methods reside in Mage_Page_Block_Html_Head class. The first pair is addCss and addJs. The syntax is quite simple:

Some core modules use <file> instead of <script>. There are some talks over the internet regarding which approach is correct. The fact is there is absolutely no reason what container to use. Magento will accept anything as long as the closing tag matches opening one and will send the contents as the first argument to the addJs method of Mage_Page_Block_Html_Head class.

You got it right, there is also a second argument. It allows you to send any additional parameters to be included into <script> or <link> tag:

The path of a script added by addJs method is relative to Magento root /js directory. For addCss method it is relative to skin directory of your theme.

In fact both those methods are just wrappers for universal addItem method which can add either CSS or JavaScript into your page.

The basic syntax is the following:

The type can be js, js_css, skin_js, skin_css, link_rel or rss.

js will include a JavaScript file and will search it in /js directory of your Magento installation. This is similar to what addJs method does.

js_css will create a CSS link and will also search the file in /js directory. This is handy for including stylesheets of some JavaScript libraries.

skin_js will try to locate a referred JavaScript file in js directory of your theme.

skin_css will create a CSS link to relative to skin directory of your theme. This is similar to addCss method described above.

link_rel can be used to create a custom <link /> element with custom attributes. Can be used for including CSS files located remotely.

rss will create an RSS link but you most likely will never use it.

In general addItem method accepts 3 more parameters. The params is the same as the one used for addJs and addCss. Then there’s if and condition.

If if is set the added link will be placed into wrapper. That means you will be able to limit its inclusion to some specific browser versions. The syntax is the following:

The blank <param /> is important here because as we already found out earlier Magento is not looking at the name of container tag but at it’s position. More info about conditional comments can be found here.

The last parameter is condition. It is not documented and I have not found any references on internet about how it works. The syntax is following:

Once Magento comes upon such a statement it checks if this_custom_css_is_allowed is set on the head block and if yes and it is not false the js/css item will be included.

This is quite interesting technique. As you surely know it is possible to control whether the js/css will be included into the page by sticking to the particular layout handles. The condition parameter gives you an ability to provide even more sophisticated configuration. So within your controller you can do something like this:

Or you can set this value through XML layout. However this will not make much sense as again you are coming back to layout handles:

There are some other valid methods available which are all just another shortcuts for addItem method:

addCssIe and addJsIe are working same as addCss and addJs but also sending IE value as the if parameter to addItem.

addLinkRel is just a shortcut for addItem with link link_rel type. The first argument is used as a file path and the second can be fed with all attributes like rel, media, etc which will be directly injected into the <link /> tag.

It may look like you don’t need any of those shortcuts if you have mastered the usage of addItem method. It may look like all those shortcuts are kept in the code for backward compatibility and you only need to know them to pass Magento Frontend certifications. Not quite. addItem method was included into Magneto from the very beginning and is will be converted into the private method in Magneto 2 leaving us all those shortcuts plus something new.


Playtime with OroCRM

We continued our exploration of e-commerce applications in the Symfony2 ecosystem at this months hackday with some playtime with OroCRM. OroCrm is currently in alpha phase and is unique in that its primary focus is to provide CRM tools for B2C rather than B2B of traditional CRM solutions. They plan to integrate with different webshop solutions to for example automatically open a lead if a customer leaves the site without checking out but had filled the shopping cart with a certain number of products. Since the venture is started by Yoav, one of the founders of Magento, their first target is of course Magento which we also leverage at Liip as our primary e-commerce platform. What is also interesting is that the OroCRM created a business application platform on top of Symfony2. The goal is to facilitate the creation of other business applications which can then be easily integrated together. One concrete example of this is AkeneoPim. Note that the platform uses the liberal MIT license while the CRM uses the OSL 3.0 license, same as Magento. Its quite similar to the LGPL with additional provisions that terminate the license for anyone initiating patent litigation against other users of the application.

Getting setup

In general OroCRM is quite trivial to install for anyone familiar with Symfony2. It was nice to see that they use the popular LiipImagineBundle among many other community provided Bundles. We made some small PRs to address some tiny details. We were a bit sad to see that the OroCRM team currently does not leverage travis-ci to make it easier for contributors to ensure that their contributions do not break the tests. But at least it was good to see that there is an extensive test suite.

First look at the UI

The first impressions of the UI were quite positive. There are some very useful navigational tools that are provided as part of the application platform that provide shortcuts, links to recently used tools and a search that can search across all data using a custom inverted index stored in the RDBMS. Note that the search index looks to be pluggable, so expect Solr support to be provided eventually as an option. That being said, the current set of features do not cover things like leads yet. There was unfortunately also no code yet to handle Magento integration. Its clear that at this point the focus is still more on providing infrastructure rather than trying to provide a finished feature set. Its an alpha after all.

Digging in a bit

At first we ran the application via the PHP 5.4 build in server that Symfony2 integrates conviniently via app/console server:run but the application behaved a bit flaky then. Its basically a single page app where all content is loaded as JSON and using the build in webserver we frequently ended up with JSON replacing the actual UI. OroCRM seems to use anchors to update the URL bar rather than push state. Using apache we didn’t notice those issues but were forced to create a virtual host since the Javascript code had several URLs pointing to /api/rest without taking care of the subdirectory the application was running in. Speaking of the UI we were dissapointed to notice that it is currently not responsive and no provisions seems to have been made for touch devices. We feel like it would be wise to address this topic early to ensure that all the infrastructure pieces will work for mobile users too.

Its all REST

The backend seems to support a REST API via WSSE authentication. SOAP also seems to be there or at least planned but we didn’t try it out. To make it easier to generate the required WSSE headers we send a PR with a little command. However many of the controllers use json_encode explicitly rather than leveraging the FOSRestBundle view layer. This in turn means that XML is not supported and furthermore its not so easy to configure on the model what fields should be returned. Its not clear why this is the case because in some controllers FOSRestBundle is used. It might be that this will eventually be refactored.

Low level infrastructure

In the system tab we found several very useful pieces that will no doubt be useful for many other business applications too. First there is a notification system which hooks into the ORM. Administrators can for example automatically send an email when a new contact is created. There is also an audit log that can be enabled on a per entity basis. Entities can be configured in the UI which generates the code and automatically updates the database schema. A new entity will by default map to a new table. There also seem to be some provisions for EAV to handle more unstructured content but its not yet possible to configure this via the UI. I would urge to look into PHPCR here instead or just serialize to JSON/XML.

Looking at the current CRM features

The key thing that is currently provided is the ability to create accounts and contacts. We noticed some issues in the validation. Sometimes there was not enough information given or validation was limited to server side validation. There were also some issues that due to the fact that validation was server side, red boarders denoting errors caught in the server side validation dissapear. There were also some usuability issues like there was no way to copy the address of the account over into the shipping address fields and there was no way to quickly create a new contact for an account. But hey, its an alpha so no worries there. We also looked briefly at security. Symfony2 out of the box provides quite a few tools to help write secure applications. So we didn’t find any significant things. We just noticed that while in most places html tags were simply escaped, for tags we found that html tags were stripped on display but persisted in the database.

The take away

OroCRM certainly looks promising though at this point the main thing that can be judged is the platform underneath. There are not that many actual CRM features, let alone webshop integration. Note that OroCRM alpha6 was released today featuring among many things a “Flexible Workflow Engine” and “Leads and Opportunities Workflow”. So it looks like they made a big step towards becoming an actual CRM.

Tags: , ,

Checking out Sylius: Symfony2 e-commerce

Last Friday we did a one day hackday with the goal of checking out the Symfony2 based e-commerce solution Sylius. Among the attendees were even two guests with Fabian and Stefano joining the Liipers David, Matteo, Patrick, Tobias and myself.

Getting started

We did not have any specific agenda and decided to just install and start exploring. For the most part this was a quite painless experience it just takes a while when 7 people clog up a wifi connection. Pawel had just completed the update for Symfony 2.3 the day before, so we found some minor bugs that we fixed. Stefano also submitted a PR to fix PDF generation on travis. Matteo spend some time updating the german translations.

Behat tests

Fabian decided to dig into the Behat tests which were failing on travis-ci.org due to memory issues. Sylius comes with a very extensive set of Behat tests. As a matter of fact maybe this is the best source of documentation of Sylius features. In the end his solution was to simply split the test execution by tag.

Adding some PHPCR love

One thing we noticed quickly while reviewing the database schema is the table used to store the ProductProperty class instances. It uses the Entity-Attribute-Value pattern, one of the reasons why its not so trivial to scale Magento. Essentially this is one commonly used approach to deal with unstructured data in an RDBMS while retaining some ability to run search queries. The big issues with the approach is that reading data out is quite hard but worse it basically requires one column for any kind of data being stored. In the case of Sylius its using a VARCHAR(255). So we figured we would simply use Doctrine listeners to modify the persisting to use PHPCR instead. The advantage being that with PHPCR it would allow to support all sorts of data types without length limitations. So this would for example allow to associated additional images, dates and longer descriptions with products. Stefano and I struggled a bit with the ORM listeners. We learned that persisted entities are not stored in the identity map until the RDBMS has actually generated an ID. Until then one has to use getScheduledEntityInsertions() to get access to the relevant entities. Once we figured that out the actual tasks of integrating PHPCR was comparatively trivial. Now it might however make sense to even go a step further and store the Product class itself in PHPCR as well using PHPCR ODM.

Dynamic routing

Sylius uses two “catchall” routes for products and categories. This is a quite common pattern found in CMS’s build on top of Symfony2 or many other general purpose web development frameworks. Basically one defines a route that simply catches anything below a specific pattern without knowing if anything even exists in the database that would match that. Then inside the controller a DB lookup is made and in case the data is missing a 404 is returned. In the Symfony2 CMF initiative we solved this need by introducing a chain router and dynamic router which has been adopted by ezPublish 5 and Drupal 8. It allows one to chain the standard Symfony2 router and any number of dynamic routers which means that static routes (like f.e. the homepage) do not need to be moved to the DB. The job of the dynamic router is to do a DB lookup during the routing stage. This means the controller is no longer responsible for this task. Stefano and I managed to implement this surprisingly quickly. One draw back of this approach is that now a DB lookup is also required to generate a route. Enabling the ORM entity cache however solved this problem quite easily.

Taxonomies for the CMF

So while Stefano and I worked in integration code form the CMF into Sylius, David attempted to do the opposite. He tried to integrate the SyliusTaxonomiesBundle into the CMF. However unfortunately he didn’t yet manage to get it to work.


Matteo and Tobias looked a bit more deeply at the admin tool and unfortunately found several missing features. More over they quickly realized that the different tools allowed bringing the data to an inconsistent state. They then spend some time making the order status actually dynamic, at the time its was all hardcoded. They were still a bit unsure about the actual concept of how the order status relates to the relevant potentially several different shipping status states.

Sylius in the real world

Patrick is actually already running a Sylius web shop in a private project. So he spend some time investigating how to upgrade and what has changed. He found that indeed a lot of has changed but everything that has changed, changed for the better. However there are still things missing. For example in his project they needed additional notifications when an order is created.

Take away

Sylius looks really promising and we were positively surprised with the provided feature set. The code is clear and well structured and very easy to get started for a Symfony2 developer. However there are still important missing features making it very hard to plan the amount of time needed to do an actual real world project. The added fact that a lot of code is still very much in flux makes things even harder. It seems however that one could take the code at any point in time and complete a project with fairly well working code. In this regard the situation is quite similar to the CMF which has also already been used by several companies to build production applications. No doubt once Sylius has a stable release it will be a very viable alternative to Magento for projects that need very heavy customizations. In this sense it will also be interesting to see how OroCRM and Akeneo will turn out as these could provide some advanced CRM and product management capabilities that should be easily integrable since both of these applications are written in Symfony2 as well.


So this weekend I visited my hometown Berlin for the PHPUCEU. Actually this was in very close proximity to where I grew up, which was nice as I was staying at my parents place. Usually staying there requires a one hour ride to the hipster areas of Berlin to attend a conference. In this case it was just a 2 stop U-Bahn ride. That being said, this wasn’t a “normal” conference. This was an unconference. As such attendees proposed talks they could give, but also talks that they would want to hear. Every morning every attendee would then have two votes for talks. The top voted talks would then be distributed across the 4 slots in the 3 available tracks. As such several of the sessions ended up being quite ad hoc with multiple people chipping in with what they new about the topic. What is also special about this event is that the sessions are just as long as the breaks to facilitate idea exchange about the session topics, but also about other topics. Overall I found this to be an absolutely thrilling experience.

Day one


I proposed a talk on PHPCR which was selected for the first session. I essentially gave the talk I had given multiple times before. But its still exciting to share the content repository vision for PHP. Looks like there might even be PHPCR support in the future for Jimdo and Magento?

Clean puppet

I attended this session by Soenke, Jakon und Hans-Christian mainly because I am still quite a noob when it comes to Puppet and Chef. I must admit, the possibilities excite me but I still prefer others to do the development for me. Somehow I just don’t like the DSL of Puppet nor the Rubyness of Chef. This session didn’t change this but did highlight some important aspects, specifically that you would keep the concept of environments as for up the chain as possible.

Behavior Driven Development

Kore and Gaylord gave this session. Gaylord was representing the more business level perspective while Kore the more technical one. The exciting part about BDD is that BDD can really bring those two sides closer together. However the most important take away for me from this session is that Behat can now generate stubs for Context definitions, which will drastically reduce the effort for expanding the DSL for non developers. Gaylord mentioned that he thinks that using BDD seriously increases development time. Yet the benefits of additional testing and always uptodate documentation outweigh these costs. We have played with BDD at Liip several times, but its time we get more serious about it.

Evening program

I missed the 4th session of the day because I was chatting with people outside. After the last session ended we got together and each session was briefly summarized. We headed to a local beer garden which unfortunately was a bit overwhelmed with us and so the service was quite non existant. However we still stayed several hours. Talking about technology and organization challenges.

Day Two

Agile documentation

This was the first session of the day for me. Soenke was making some important points about how documentation does not only provide benefit but also cost. And this cost is best managed by single sourcing documentation (ie. not duplicating documentation) and by making documentation executable (via BDD).


This session was slightly sabotaged by github. Kore and Hans-Christian wanted to explore Hood.ie life on stage but couldn’t get the necessary code in time. So instead Kore spoke a bit about the core idea behind CouchApps. I was also able to add some tidbits about what Hood.ie adds as I recently got a personal demo by Gregor, one of the core developers. We then went through some of the code examples on the site. In general I believe that the coolest thing in CouchDB is the replication protocol, which is why I never understood why Couchbase decided to focus on elastic scaling instead. Thanks to async multi master replication with local storage one can build a whole new class of mobile applications. There is a very high chance that Hood.ie will become a big part of the Liip technology stack.

Symfony2 Rest API

I held this session by basically doing a walk through of a client application we are currently building as well as the Liip Symfony2 techtalk edition. Overall I was showing off how to integrate various Bundles: FOSRestBundle, JMSSerializerBundle, NelmioApiDocBundle, FSCHateoasBundle (requires this PR) and HautelookTemplatedUriBundle. I also highlighted several limitations which let me to post this on my blog as a follow up.

NoSQL is not the answer

I had given this as a lightning talk at GotoCon in Zurich and figured it would be a useful topic for this event as well. I even managed to get Kris to come out of the sun for this session! He added some more insights. The tl;dr; of this session is: Stop using the term NoSQL as well as that there is lots of room for innovation on top of relation theory which the vendors are finally addressing thanks to all the hype around MongoDB, CouchDB and friends.

Take away

The big take away is that unconferences are awesome and from what I hear our yearly Liip internal techday will heavily draw from this concept. The second take away is that Symfony2 is the dominant framework in continental Europe. Third BDD deserves more attention at Liip.

For the very first time: Hello UK!

I have been on the conference tour for quite some time now and on top of that I travel about every 2nd weekend to some frisbee tournament around the globe. Yet I have never visited the UK. So far the most I have seen of the UK was transiting via direct bus from one London airport to another. So I was quite thrilled when my talk about the Symfony2 CMF was accepted for PHPNE in Newcastle. I was also quite keen to learn more about the PHP community over there. At any rate I flew in on Monday evening and made my way to the hotel in a light drizzle which perfectly matched my image of UK weather. But even in the dark one could make out the historical feel to the architecture in the city center. I cut the sightseeing short and crashed into bed. Next day I made my way to the conference venue which was set at a movie theatre. There were countless busy bee’s from the organization team and in general this conference was organized top notch. Quite an impressive achievement given that this was the very first PHPNE. The theatre also provided top notch projectors and of course comfy seats.

Rowan kicks off the show

Rowan did an awesome intro keynote talking about how to make better developers, touching both and practical aspects in terms of tech setup and continuing on to useful tips about self education and human interaction.

API Design by Alex

Next talk I listened to was about API design by Alex. It was a combination of general tips and lesson learned from introducing an open API at a university. I pondered raising my hand when the presenter flat out recommended to always go with JSON over XML for REST APIs. Personally JSON is my preferred format when the client is usually a browser as it integrates so naturally there. For server to server interaction I much prefer XML, since its simply a much better format when one needs to evolve data format as one can get away with many changes without requiring a new API version.

Bastian on logging and metrics

After this talk I attended was delivered by Bastian about logging and metrics. This is a topic I find quite important but unfortunately I have found its hard to convince clients to invest into this as they tend to focus more and features end users can see. However to ensure a stable environment which is sort of the basis for ensuring that customers can enjoy your site, logging is key. Furthermore only with metrics it is possible to figure out what features customers actually use, where they might get stuck and what could be easily dropped. It was nice to see that the tools Bastian chose to introduce are exactly the tools I had on my radar already. He specifically mentioned graylog, logstash, statsd and graphite.

Lunch time chat on knowledge exchange

Over lunch I ended up chatting with Rowan about internal knowledge exchange. Rowan works for Invica. Just like Liip they have multiple offices and deliver projects using various frameworks and applications. Interestingly they seem to have several teams that span across offices. At Liip we of course also sometimes collaborate between teams in multiple offices, however project teams for the most part always come together in a single office.

Fabrice showing the path to Symfony2

After lunch the sessions commenced again. I had seen Fabrice’s talk about migrating legacy applications to Symfony2 before. However it has evolved quite a bit since then. I will definitely apply many of his tips next time I have the task to migrate a legacy application and look forward to Theodo release some of their solutions as open source.

Intro to the CMF

Right after Fabrice’s talk I delivered my CMF presentation to a noticeably smaller crowd. I hear the talk that was running in parallel about dealing with failures was very good. At any rate I must admit I have seen this pattern before at other conferences. I tend to have a fair number of people asking questions in my talk and afterwards even more. So I figure that the market for people willing to explore a new content management approach is simply a bit smaller than other topics, yet for those who do have issues with the current solutions its quite an important topic. At the start of my talk I asked what frameworks people are using and it validated a feeling I had gotten in the previous talks: There was no clear goto framework for conference attendees. The preferred frameworks were all over the map.

Theij’s on the cloud

The closing keynote was held by Theijs who did a very energetic delivery to drive home the point that really the cloud is nothing more than .. the internet! Additionally he provided several good hints about what things to consider when using SaaS.

Bar chatting

After the closing ceremony with lots of prizes we then moved on to dinner and finally everybody met back at a local bar where we had free drinks all night. However instead of simply getting drunk there were many lively discussions. I talked quite a lot with people about Symfony2 and the need for RAD development layers on top of the core. I also chatted a bit about e-commerce solutions in the PHP scene, specifically Magento, Oxid, FoxyCart as well as Vespolina and Sylius. At any rate, people were so busy talking that the free drinks money actually only ran out just before the bar was closing anyway.

CMF workshop

For me however the conference wasn’t quite over then as thanks to a late afternoon return flight I had offered to provide a CMF introduction workshop on the next day. Anthony had managed to secure funds to give us a room large enough that I could give 10 people a 4 hour run down of all the details about the CMF with much more depth than my talk at the conference. Some people had already played with the CMF while others had only heard about it in a blog post. I led the attendees decide how to best spend the time. In the end all attendees installed the Symfony2 CMF Standard Edition, I answered several specific questions that some of the people had that already played with the CMF but aside from that I just ended up going through the PHPCR and Routing/Menu slides, showing a bit more about the SonataAdminBundle and various other pieces. After the workshop I grabbed lunch together with Lars and Marc. Lars had been posting various questions about how to implement publishing workflows on the mailing list and is now diving into implementing some missing functionality into the Jackrabbit transport layer of Jackalope, which was just merged.

Wrapping up

Overall I must say it was a great conference and I was especially grateful that I could do the workshop. As we are approaching the first stable release its important to get as many people double checking our concepts as possible. Secretly I am also hoping that the attendees will take what they have learned and spread the word in their cities and organizations. Even with the internet frameworks and applications tend to be strongest in close geographical proximity to the core developers. So having an opportunity to make the Symfony2 CMF known outside of continental Europe will hopefully help grow the user base.


Summer vacation in open source land

So I decided to take 2 months off this summer, quite on short notice so I would like to thank the Liip management to be so flexible on this.
Of course I don’t really ever take off from open source, so I have spent a fair bit of time working on the Symfony CMF.
Gathering feedback from the community via multiple blog posts, which taught me some things about OSS and then doing something with it like starting documentation, a simpler initial setup and adding some missing features.
I also gave talks about Symfony2 at user groups in Vienna, Odessa and Kiev and attended DrupalCon in Munich.
Oh and I gave another talk at Centralway as they seem to also be diving into the world of Symfony2.
During my time off I also spent a bit of time tweaking the integration example we have with Magnolia ahead of my presentation at the Magnolia Conference on PHPCR on the second day back from “vacation”.
It seems like just as my “vacation” contained what others would consider work, my week back at “work” contained what others would call “vacation”, i.e. I traveled to the Croatian island of Bol to attend ezSummerCamp to teach about Symfony and help interface the ezPublish community with that of Symfony2.
Finally I attended the Symfony2 CMF hackday in Fribourg.
What follows are some more details on what I learned along the way of all these trips and the things I worked on in between.


So I was approached by Julian at Symfony Live in Paris if I would be willing to come by and help energize the local Symfony2 user group with a talk.
As I was planning a trip to the Ukraine and Russia, I noticed that there would be cheap options to fly via Vienna so I contacted Julian who made it all happen quickly and was kind enough to host me.
What is great is that several Drupal core developers also came by to my talk and it seems like there is now more and more Symfony2 – Drupal collaboration going on between the user groups in Vienna.
Speaking of user groups, there is a new section for events on the Symfony2 websites listing meetings around the world.

Ukraine and Russia

I then went on to Odessa to play at the Ukrainian Beach Ultimate Frisbee Championships where I placed 3rd playing with the team from Odessa.
However I also did a presentation on Symfony2 at the Ciklum offices to a crowd of about 20 developers from the region.
After Odessa I went on to Kiev where I did another talk, this time to about 130 people in a panoramic room overviewing Kiev, at a Ciklum office.
I have met some developers from Ciklum through the projects we did for NZZ, who had invited me to come speak, so I was very happy I could make it happen.
Ciklum on the other hand took care of airport pickup, a place to stay in Kiev and a full day personal tour of Kiev.
What stood out from these talks was that there were a huge number of developers with really cool ideas and projects that somehow do not yet feel connected enough with the rest of the community.
So I was happy to do some tweets and email forwarding for them to get their voices heard.
For example one developer was having performance issues with Symfony2 forms so I suggested that he would create a test project on github and mail me the url which led to some major work by Bernhard to address form performance issues.
I went on to also travel to Moscow and Nishny Novgogrod to also play the Russian Championships, finishing 3rd and 4th in the open and mixed divisions and winning the spirit prize.
Unfortunately I didn’t manage to organize any talks while I was there, but I hear some people from Moscow attended my talk in Kiev.
Also it seems like some Magento developers were at my talk, but when I poked them about it I couldn’t get confirmation if using Symfony2 is on their radar.
Seems to me like its more likely they will adopt Zend Framework 2.

Working on the CMF

On my return I began focusing on the CMF.
The main feedback lesson I got was that while people were telling me that “PHPCR is too complex” in fact what they were saying was that “they don’t know enough people that know PHPCR yet” in order to trust it works and more importantly to trust that they can get help if necessary.
As such I realized that I needed to make it even easier for people to try it out, so I created the Symfony2 CMF standard edition and updated the homepage with lots of content.
Especially I finally setup rendering of the rST formatted documentation on readthedocs.org and did a first round of updates.
However there is still work to do there.
I also proposed an update to the roadmap.
Overall I think currently we have quite a momentum going with many people asking questions but more importantly also contributing here and there.
Actually we have always had a healthy stream of contributions to PHPCR, but now we are also seeing more people helping on Symfony2 Bundles for the CMF.
I also finally put together a website for the DecoupledCMS vision that Henri and I have been pushing at various conferences using the great logo designs Noora had created for us thanks to Liip sponsoring.

DrupalCon Munich

Next stop was DrupalCon in Munich.
Was great to catch up with many of the people I had met personally for the first time at DrupalCon Denver and of course also meeting many new people.
I didn’t attend talks, but there was plenty of hallway discussions and hacking where I could help with some insights on Symfony2, REST and so on.
The excitement about the Symfony2 adoption was still all around and since Denver many things have become clearer, but there still remains a lot of work and the time until the code freeze is running shorter and shorter.
One big todo that came up there was that we need to work together with Drupal and other big Symfony2 adopters on creating some governance for security and release management coordination.

Visiting Centralway

Just as my last week was starting Walid, who I met during a project at Joiz, contacted me that Centralway would love to get a short introduction into Symfony2.
So I went over to their offices in Winterthur giving a one hour code walk through to their developer team.
I was surprised to meet Hugo there, who I had originally met while working for Optaros and who I last talked to while he was working for Local.ch.
At any rate looks like Centralway is going to jump in with both feet into the Symfony2.

Vagrant at Liip

So my first day back, I spend one day at the office catching up with different discussions.
What I loved most about getting back is that Liip has now adopted Vagrant for project setup.
So getting the new project installed consisted of installing VirtualBox, calling “git clone” followed by “cd ..; vagrant up”.
How sweet is that? All members of the team have the same setup, no fuss.
It looks like Liip will bring all this goodness to the general Symfony2 world, with an open PR adding a Vagrant template setup to the official Symfony2 Standard Edition.

Magnolia Conference

Next day I headed to Basel for the Magnolia Conference.
It was funny to meet two old friends Zak and Sandro from the PHP world at my very first Java based technology conference.
Also caught up with Gregory who I had last seen at the hack day in April where we first prototyped the PHPCR – Magnolia integration.
But I met tons of more people and interestingly enough nobody was bashing PHP.
Instead I had lots of interesting technology discussions.
It was clear to everyone that the choice of language doesn’t save from or condemn to you.
Speaking of which the UI demo of Magnolia 5 was quite impressive and I believe that create.js could fit in very well with what they are doing there and I hope I have sparked interest in create.js with a few people during the conference.
Magnolia plans to release a set of tutorials show casing what is possible.


My final story covers ezSummerCamp where I was invited by Ivo, who I had met at an IKS event last summer in Paris, to speak on Symfony2.
For those unaware ezSystems recently announced that version 5 of ezPublish would be based on Symfony2 and that they aim to make a release this fall already.
Do note that this release would essentially just wrap ezPublish version 4 inside Symfony2 with several tools to help data exchange.
The intention is to enable developers today to write custom code in Symfony2 and to slowly move more and more of the legacy code to Symfony2.
Again I was amazed with how excited people were at all the possibilities this is opening.
One of the cool results was that during the hack day I prototyped an integration of the Symfony2 CMF routing component into ezPublish, which has now been committed.
This same component is also being evaluated by Drupal.
Fun times! Also again the topic of governance structures around Symfony2 has come up while taking to Nicholas.

Getting back again

On my way back from the summer camp, I just used “vagrant up” to bring up that new projected I am working on at Liip.
I quickly added the Symfony2 CMF components and bundles to it.
Its not a CMS project per se, but it will give us a quick way to let the customer edit content, handle translations.
Can’t wait to add inline editing as we should be able to wrap up a big refactoring of the create.js integration with the work done at yesterdays hack day in Fribourg.
Here is a quick summary of the results.
This hack day, but more importantly the growing number of contributors, is proving that we are now well on track with the Symfony2 CMF.
And now that it’s already far along enough so that it’s easier to integrate than trying to hack up something with the ORM means that we at Liip can finally start reaping the benefits of our investments!

Tags: , , , , ,

Looking back on Meet Magento 2012 in Leipzig Germany

The one and a half days at the Meet Magento #6.12 conference helped me to shape the vision of Liip as a Magento solution provider. I can see an exciting future with a lot of opportunities in the eCommerce business and the upcoming version Magento 2.

Magento is a widely accepted eCommerce solution for running web shops. It is available as both the open source Community Edition and as the paid Enterprise Edition. A worldwide community of developers contribute modules as extensions to the core functionality. At the conference, Bas Nawijn, – Magento’s Head of Sales for Europe and Africa – shared the vision of Magento as a flexible, open eCommerce platform that everyone can use. Also, Magento announced that Magento 2 should be available in the first half of 2013.

 Bas Nawijn holds the keynote

Bas Nawijn holds the keynote.

Yoav Kutner appears on stage

Yoav Kutner, co-founder and former CIO of Magento, appears on stage.

Liip has been developing eCommerce projects with Magento for three years. The first implementation was for Carlo Bernasconi AG, a web shop selling stones and mineral products for the building industry. This early Magento shop featured a custom-developed shipping fee calculator that takes into account the different locations throughout Switzerland from which the goods are delivered to the clients.

The Schild.ch web shop received a Best of Swiss Web Award in 2010 in the Technology category. Liip developed the shop on the basis of Magento Enterprise and has continued to work on its further expansion up to the present. The online shop accounts for growing revenue every year.

The Jungfrau.ch project with its online shop developed by Liip won a Best of Swiss Web Silver Award in the Business Efficiency category in 2012. The Magento Enterprise based shop has been extended to communicate with over a dozen different third party services including SBB tickets, Skidata ski passes, STC hotel reservations, and event ticket reservations.

The Liip Magento team has been an active part of the developer community. The five team members have attended many Magento conferences, the last one Imagine eCommerce 2012 this spring in Las Vegas. During their up to three years of experience they have developed many extensions and contributed some of them back to the Open Source community. One of the latest contributions was to the Openstream’s SaferpayBusiness extension. Despite the great success with the Magento implementations realized by Liip, we have not made it to becoming an official Magento Partner yet, but we are definitely considering this for the near future.

This year’s Meet Magento in Leipzig was my first Magento conference. It was a great chance to meet the German community and learn about what else is going on in the Magento ecosystem. Topics addressed in presentations by experts and solution providers ranged from case studies, payment solutions, building trust through independent certifications and labels, to general advice on how to improve customer satisfaction and conversion rate. Since I was mostly interested in eCommerce business, I did not attend any of the many developers’ talks also taking place. The conference was held in a relaxed yet dynamic atmosphere at the West In Hotel. At the end of the first day the attendees were invited to the After Show party at the fantastic Moritzbastei. Throughout the conference we got to enjoy good food and plenty of coffee.

Food, drinks and music at the Moritzbastei

Food, drinks and music at the Moritzbastei.

Leipzig proved to be the perfect place for a conference like this and the city itself is well worth a trip. I was glad to take an evening walk in one of the many parks. And I was suprised by the many big names of German cultural history that are present in the city – Johann Sebastian Bach and Johann Wolfgang Goethe being only two of them.

So at the end, on a very hot day I left Leipzig with the urge to listen to some Bach organ music, contemplating the things I’d learned and thinking about how we can further strengthen Liip’s eCommerce expertise using Magento.

Video footage of all the talks can soon be viewed on the Meet Magento website.

Tags: , ,