Day one

PHPCR

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 programm

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).

Hood.ie

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 dominante framework in continental Europe. Third BDD deserves more attention at Liip.

State of Jackalope-Jackrabbit

The basic node API is implemented and working fully. You can do direct access to paths and walk the tree hierarchy and read and write data. All data types including binary streams are supported.
We do support the workspace and session write operations including cross-workspace synchronization of nodes.

Queries can be expressed in the JCR-SQL2 language as well as the query object model. Additionally, jackalope provides a fluent query builder on top of the query object model. Most features of query are supported, the exceptions being query parameters and storing a query as stored query.

Exporting the repository to the standard "system" format and also the "document" format works, as does re-importing any repository dump (including those generated by Java JCR implementations).

Node type definitions can be inspected and are used to restrict allowed data when used. Both the CND file format and the object model to define custom node types are supported.

The observation journal is a log of everything that happened in the repository since a specified timestamp. It can be filtered to just see events an application is interested in. Filtering is for example done by repository path and by type of event like adding, changing, moving or removing.

Versioning is implemented and working. You can make nodes versionable, create new versions, inspect the version history to see old versions and restore old versions. Activities and version labels however are not yet implemented.

Session scoped locks are implemented. They allow to block a node, and optionally its subtree, to synchronize operations.
We did not yet implement open scoped locks, but that should not be too hard to do.

Besides building PHP content management, Jackalope-Jackrabbit can also be used to connect PHP applications to the Java jackrabbit based systems Magnolia CMS and Adobe CQ (currently called Adobe Experience Manager)

A couple of optional PHPCR features are not (yet) implemented:

• Permissions and capabilities: Checks whether the current user is allowed to do an operation
• Same Name Siblings: multiple children of the same node each having the same name
• Shareable nodes: would allow a node to have more than one parent
• Access Control Lists (ACL), because Jackrabbit does not expose this feature over the remoting protocol jackalope uses
• Lifecycle mmanagement
• Retention and Hold
• Transactions, because Jackrabbit does not expose this feature.

It is not a design decision not to support those features. We would be happy about contributions to those features, though right now we focus on stabilizing and improving the features already supported.

Changes

Bootstrapping

The RepositoryFactoryInterface was defining static methods. This is not legal PHP but the interpreter accepted it. We changed them to class methods and require the factory to have a no-argument constructor. Instead of

Jackalope\RepositoryFactoryJackrabbit::getRepository()

you now need to do

$factory = new Jackalope\RepositoryFactoryJackrabbit; $factory->getRepository();

Workflows

Jackalope now supports the SessionInterface::cloneFrom method and NodeInterface::update methods. This allows to copy a node into a different namespace, modify it there and then synchronize the changes back. With this, you can build workflow concepts.

Observation

The observation journal now is now usable. We figured out how to only get the events you actually care about when using the skipTo method. You can now use jackalope-jackrabbit as a message queue.

CLI commands

You have now commands to move a node, to touch (= create) a node and properties and to list the node types present in your repository.
The CLI commands are reorganized to a logical naming schema. We grouped them by what they affect: phpcr:node:*, phpcr:workspace:* and phpcr:node-type:*. We now differentiate between workspace:purge that deletes the whole repository and node:remove that can only delete a subtree but never "/".

Performance

Besides some performance tweaks, we implemented the new PHPCR NodeInterface::getNodeNames method. This method allows to get the names of children of a node without actually needing to fetch them from the backend. Perfect for showing a list of nodes without the overhead.

Node Type Definition

We can now convert between the CND file format and node type objects and back. This means you can register node types in jackalope-jackrabbit by using the node type API.

Stability tweaks

The import and export got improved to work more reliable and some bugs are fixed. Jackalope-jackrabbit takes more effort now to avoid same name siblings from being created. If they should still happen to be created, deletion is fixed to be able to delete them. We fixed issues with the types of values returned by queries.

Preliminary Adobe CQ support

We already have Magnolia CMS support since last year. Adobe CQ is another CMS built on top of the commercial distribution of Jackrabbit called CRX. We tested compatibility with CRX and jackalope can now read and write data from that content repository.

Responsive Web Design is, simply said, a web design approach aimed at crafting sites to provide an optimal viewing experience. RWD makes a website easy to read and navigate with a minimum of resizing, panning, and scrolling, across different browsers and platforms (desktop to tablets to phone) based on fluid grids, flexible images and media queries.

But why should you care about Responsive Web Design?

Previously, sites were chiefly designed for desktops. But the mobile web has became more popular. According to statistics the mobile internet is expected to overtake desktop internet usage this year. This makes it necessary to design websites that are flexible and can be viewed from almost any device.

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.

It might be interesting for you, our potential employee, to know how a typical day at Liip is for me. So first a little bit about myself. I'm only half a Liiper the other half of me is studying at ZHAW. I'm lucky enough to work and study at the same time without making all to great sacrifices. I'm employed as a software developer but lately I'm doing all sorts of things since the teams now organize themselves at Liip.

So let's dive into this more or less regular tuesday.

I get up at 07:00 and move towards the bathroom bla bla not interesting. I jump on the train at 07.39 and are on my way to Zürich. Since the ride takes about 50 minutes, I start to work on my MacBook which is my private machine as well as my work horse. Time to find some tickets to work on. Oh the importer of that project needs to change. Let's do that.

After I get out of the coding zone I'm already arriving in Zürich. It's time to get my bike from the Velostation and drive 2-3 minutes to the Liip ZH office.

I arrive at the office and connect my MacBook to my 2 beautiful 24" screens. Let's finish up the importer changes before the Daily starts.

09:00 it's Daily time. My team, called team Lego, stands in front of the scrum board and we discuss with each other what we are going to do today. The business developer in our team asks if anyone has time to help him with an upcoming offer. I tell him that I'd help.

After that me and one half of my team have a sprint meeting where we show the customer what we did in the last 2 weeks. The client can add changes to existing features or change the coming sprint if he thinks it's necessary. We also use this time to get feedback from the client for unclear user stories.

12:00 lunch time, we go to Giardino where most of the company get their lunch. It's almost our mensa but the food is better.

Back in the office, time to form the changes from the meeting into jira tickets and put them on the scrumboard.

Now it's time to see how I can help our business developer to prepare that offer he was talking about in the Daily. I have to read through a whole bunch of stories and estimate them, come up with the right technologies for the job and explain each of them in the offer. It's very different from coding but challenging nevertheless.

17:00 like a swiss clock the coworkers call for STZBR. Off we are to giardino to have our well deserved after work beer. We talk about software issues but also about whatever comes to mind.

After a beer or two, I take my bike to the train station and get onto the next train.

As you see, the work at Liip is not just about coding. Yes I do code a lot, usually more than on this particular day, but working at Liip is also about the people, coordinating with them, solving problems together and most of all helping each other.

If you think you could fit into this family, give it a try and apply for one of our open positions.

There are two actually quite cool reasons for the delays. One is that we had two projects at Liip where we had to integrate the CMF into existing projects. It was fun, but we found quite a lot of issues and missing features in Doctrine PHPCR-ODM that we fixed resp. implemented. (The Symfony2 Form component is incredibly powerful, but requires the persistance layer to work very exactly and we did not want any more workarounds and hacks to a achieve functionality.) The other reason is that many other people started using the CMF too. Some found issues that need to be fixed, others even managed to contribute fixes themselves - but which took time to review and comment on. Also, a lot of new features have been built or are currently being built.

One feature I am particularly happy with is that PHPCR-ODM can now cascade persist referrers. This is quite useful for example to embed route and menu editing into the edit form for static content, as shown in the screenshot. (This is already in the ContentBundle and should come into the sandbox with the next update.)

Getting to a release

As soon the above 2 client projects have stabilized, Lukas and I plan to focus on cleaning the base layers PHPCR and Jackalope to a point where we can tag release candidates, then bring Doctrine PHPCR-ODM to a state that can be called 1.0. We might have to postpone new features, but try to find all the interface changes and similar things to avoid BC breaks once 1.0 is stable.

Getting things out depends on contributions from the community too. While it is great to get new features, we now need to focus on cleaning up those we already have. On improving the documentation. On investigating bugs. The Release plan links the important missing pieces, if you want to dig into something.

There is the idea for a hackday in May or June. Please contact me or Lukas if you are interested. If we have enough interest, it is much more likely that we actually organize something.

I will present PHPCR at the Symfony Live conference in Paris beginning of April. I will also be at the hackday on Saturday if anybody is interested in meeting me there. Additionally, Thomas and me planned a (very focused) hackday on April 3rd to integrate SonataPagesBundle with PHPCR on the 3rd. If you are interested in helping with that integration, please contact me or Thomas.

Documentation hackday

This week, we also did a hackday at Liip, with focus on documentating some of those new features people built. I tried to collect what we achieved that day:

• Allow to edit menu and routes embedded in content documents
• Slideshow block and documentation
• Documentation for the Reference collection form type
• Documentation for the Image form type. And a imagine cache invalidator service. Wanted to make the form type more powerful, but still looking for the right solution.
• Improved Symfony documentation on doctrine events
• Doctrine exposes the method to get the current locale of a document regardless of whether the locale is mapped on the document.
• The Image and File documents of doctrine are cleaned up
• Started work on another problem when replacing child documents but still discussing the concept
• Jackalope-Jackrabbit will give better exceptions on login problems

Some little more info at the webtuesday web page

In vielen Firmen zeigt sich das Bild des Mitarbeitenden, der nur als Vollzeitbeschäftigter Karriereschritte machen kann. Teilzeit - gerade auch wenn für Kinderbetreuung eingesetzt - wird vom Arbeitgeber oft als zu kleines Engagement gewertet. Wir verstehen deshalb Angestellte in solchen Firmen, welche die Frage nach Teilzeit nur sehr zögernd oder vielleicht überhaupt nie stellen. Unsere Erfahrung zeigt, dass gelebte Teilzeitarbeit über verschiedene Funktionen und Rollen dazu führt, dass diese Furcht verschwindet. Wohl deshalb arbeiten bei uns weit über die Hälfte aller Mitarbeitenden Teilzeit (60% - 90%). Für unsere männlich dominierte Branche ist das bemerkenswert. Die Väter (und Mütter) betreuen am freien Tag ihre Kinder. Jüngere Kollegen ohne Kinder machen Ausbildungen oder gehen anderen Beschäftigungen nach.

Nicht die Männer sind schuld

Wir sind der festen Überzeugung, dass Männer Kinderbetreuungsarbeit leisten wollen. Denn sobald eine Organisation diese Flexibilität praktiziert und beispielsweise durch die Beförderung eines Mitarbeitenden mit Teilzeit in die Geschäftsleitung vorlebt, sind Männer sehr wohl bereit sich vermehrt für die Erziehung zu engagieren. Dadurch kann die Partnerin ihrerseits zu einem substanziellen Beschäftigungsgrad arbeiten und damit wiederum ihre Chance auf Karriere innerhalb ihrer (hoffentlich zeitgemässen) Organisation erhöhen. Somit leisten wir mit Teilzeitarbeit einen Beitrag zur Vereinbarkeit von Beruf und Familie. Zudem haben Väter, die an mindestens einem Tag ihren Nachwuchs betreuen, wohl ein intensiveres Verhältnis zu ihren Kindern. Auch bringen sie mehr Verständnis auf für die Situation der Partnerin. Auf diese Weise kann Teilzeitarbeit von Familienvätern zu einem ausgeglichenerem Familienleben beisteuern.

Die Mär, Teilzeitarbeit lasse sich nicht organisieren

Es ist kaum abzustreiten, dass es praktisch ist, wenn Mitarbeitende jeden Tag verfügbar sind. Auf der anderen Seite ist es auch nicht so anspruchsvoll, sich etwas um die freien Tage herum zu organisieren; und sicherlich nicht nur in unserer Branche. Bei uns konstituieren sich die Teams (4-7 Personen) selber und gehen auch gegenseitig Kompromisse ein, damit eine gute Verfügbarkeit mit gleichzeitig gutem Output generiert werden kann. Teilzeitarbeit kann die Effizienz sogar steigern. Denn die Mitarbeitenden kommen ausgeglichener zu Arbeit, haben weniger Fehlzeiten und legen ihre privaten Termine auf den freien Tag. Wir als Arbeitgeber fühlen uns mit dieser Situation wohl aber auch unsere Mitarbeiter - wie die Bewertungsplattform kununu zeigt.

Verfasst haben den Artikel Nadja und Gerhard.

Question: How reliable is Jackalope, can i trust my data to it?

Answer: Jackalope is still on the young side, but running successfully in a couple of real life applications. We also built a PHPCR API test suite that checks on many features. The PHPCR test suite is by no means as complete as the JCR technology compatibilty kit (TCK) testing suite. With jackalope-jackrabbit, the data is stored into Jackrabbit however. Jackrabbit is really mature and validates the data coming in over DavEx. In the very worst case when Jackalope totally fails, you could still write Java code or use Java tools to interact with Jackrabbit directly. In my experience I never needed to resort to that.

Question: You mentioned that same name siblings are not supported by Jackalope. Is there any particular reason for Jackalope for not supporting this? Is support coming, or is this a design choice?

Answer: Same name siblings is one of the optional chapters of JCR. Jackrabbit supports them, so it would be doable to implement them in Jackalope as well. It can be rather tricky to do it, having unique child names made a lot of the code easier. But if somebody wants to take the effort to implement it, I would be happy to provide support and help understanding implementation details.
The main reason to have them, by the way, is that JCR / PHPCR can import arbitrary XML documents, and such documents tend to have same name siblings, just think of a Xhtml document for example.

Question: What if I need a particular PHPCR feature not yet implemented in Jackalope?

Answer: Jackalope is an open source project. Contributions are always welcome, and the community will help. Liip is also open to consulting work for such tasks. Note that there are a few chapters that will be impossible to implement with jackalope-jackrabbit until the jackrabbit side implements exposing them over DavEx. This is not impossible, but considerably more effort. The next major version of Jackrabbit, codename "Oak" will focus more on feature completeness over the remoting protocol.

Question: Where are queries executed? Is there any way to measure the impact on the Magnolia repository? (I wouldn't want my main sites performance to degrade dramatically) Is there some sort of cache or index on the PHPCR side?

Answer: Normal requests for nodes are cached by Jackalope for the PHP session. SQL2 or QOM queries however are not cached. The impact will not be higher than when implementing the functionality in Java in a custom module inside Magnolia CMS. The load should be slightly lower even, as the DavEx remoting is more low-level than the full JCR API. And the PHP application can life on its own separate server. Nontheless it makes of course sense to cache rendered pages or page-fragments on the PHP side. But that is an application level task.

Question: DavEx provides to the Jackrabbit used in the Magnolia CMS. Is there a way to connect to different repositories?

Answer: DavEx is an implementation specific protocol invented for jackrabbit to do remoting. Jackalope thus can talk to any Jackrabbit instance, and it has no problem opening several sessions with different servers. But connecting to any non-jackrabbit JCR implementation is not supported. JCR is an API, not a protocol. Note that there are ideas to generalize the jackrabbit-protocol into another standard called JSOP.

Question: Something is unclear to me: Are calls from Jackalope to the Jackrabbit repository bypassing Magnolia?

Answer: Yes, exactly. The Magnolia CMS DavEx module just provides a servlet that receives the requests and pipes them through to the jackrabbit DavEx layer. This is needed because Magnolia CMS runs Jackrabbit in its own process and does not use the DavEx remoting.
The following diagram shows the interaction between Jackalope, Jackrabbit and Magnolia CMS. The PHP application is talking to the PHPCR interfaces, implemented by Jackalope. Jackalope uses the HTTP based DavEx protocol to talk to the Jackrabbit DavEx handler which is exposed by the servlet Magnolia plugin. Magnolia CMS is accessed through web requests and uses its in-process connection to Jackrabbit to read data. If Magnolia CMS needs to know about data changes done by the PHP application, it would have to use the observation feature of Jackrabbit to listen for changes on the content.

When not using Magnolia CMS, you could also run jackrabbit standalone or use the .war archive in any servlet container like Tomcat.

Question: Is there also support for the other "direction"? A case where Magnolia would use a PHPCR-backed repo/app instead of being the master?

Answer: This is partially answered above - JCR and PHPCR are APIs for code, not a protocol. A PHPCR server implementation would need to expose its content over DavEx for jackrabbit to connect to it. Besides the effort to build that, the scenario does not make too much sense. PHP is typically used in request-response setup where all objects are lost after a request. Such a server would be extremly slow as it would spend most of the time bootstrapping. While there are solutions for building PHP application servers like react, i don't see a real benefit.
What can make sense is to configure Magnolia CMS to talk to a remote Jackrabbit rather than use the in-process Jackrabbit bindings. Then Magnolia CMS and the PHP client would both connect to the same repository outside of Magnolia CMS.

Question: Will the Magnolia DavEx Module be available as a Maven dependency?

Answer: It is available in the maven repository of Magnolia CMS. Here's the dependency snippet:

<dependency>
<groupid>info.magnolia.davex</groupid>
<artifactid>magnolia-module-jackrabbit-davex</artifactid>
<version>0.2</version>
</dependency>

You can use the http://nexus.magnolia-cms.com/content/groups/public/ repository, which contains all public artifacts from Magnolia, CE and Forge, releases and snapshots.

Or - for just the Magnolia Forge projects, either of these, depending on what you're after:

• http://nexus.magnolia-cms.com/content/repositories/magnolia.forge.releases/
• http://nexus.magnolia-cms.com/content/repositories/magnolia.forge.snapshots/