Now let’s talk about OAuth. OAuth is a very common way to authenticate with social networks, websites or applications. I am going to show you how you can do it in Nuxeo.

OAuth

We already use OAuth for our OpenSocial gadgets since it comes as a Shindig dependency, which lets us share Nuxeo gadgets in external containers. It’s time to extend that. We need to let users grant access to any service provider registered in the Nuxeo Admin Center. We’ve added some code to handle the three-legged authentication. This will help through the different phases (request, authorization, access). Then I wrote a quick WebEngine module to use it in Nuxeo. This is really straightforward using the IDE. You select WebEngine project in the wizard and you get a simple WebEngine site that you can extend and modify quickly using the hot reload features of the IDE. This module can handle three different URLs:

1. http://mysite/nuxeo/site/oauthsubscriber?servicename=myServiceProviderName&serviceurl=myURLencodedServiceProviderURL

This page will show the service provider name and description, ask you if you want to authorize it, and will let you enter a code given by the service provider, if necessary. You need to give the service provider name and URL as query parameters.

2. http://mysite/nuxeo/site/oauthsubscriber/authorize?servicename=myServiceProviderName&serviceurl=myURLencodedServiceProviderURL

This will start the authorization process. Two things can happen. In the best case, your service provider supports callback. Once you click on the link, a new page will open and ask you if you want to authorize Nuxeo. Once you click, you are redirected to a page saying you are registered. In the worst case, your service provider does not handle callback. You get a code that you have to enter manually on the WebEngine OAuth subscriber page. Once you’ve entered the code, you should land on the page saying you are registered.

3. http://mysite/nuxeo/site/oauthsubscriber/callback?servicename=myServiceProviderName&serviceurl=myURLencodedServiceProviderURL

This is the URL where you are redirected if the service provider supports callback.

Now I have everything I need to ask authorization to a service provider. I can store the secret token and use it to sign every request the user will make to the service provider.

Speaking of service providers, you’ll need to register the service provider in the Admin Center. You need to give the name and the URL of the service. Be careful, they are used to identifying your service. You also need to fill in the following fields: description, request, authorization and access URLs, the consumer key and the consumer secret key.

Real Life Example: Yammer

This is actually the reason I started playing with OAuth. Yammer can be really useful when your team is split between Paris, New York and Boston. And I know Roland and Eric were getting frustrated when they could not share documents from our Intranet to Yammer. I’m happy to say that this is not an issue anymore
It’s actually pretty easy to set up once you’ve taken care of the OAuth part. All you need is a simple operation and Nuxeo Studio. The goal is to code an operation that posts the message on Yammer using a document and uses it in an operation chain in Studio.

So about that operation, the quickest way to do this is again to use Nuxeo IDE. Create a new project and a new operation. Here’s what the code looks like:

@Operation(id = ShareInYammer.ID, category = Constants.CAT_DOCUMENT, label = "ShareInYammer", description = "This operation will post the given document and comment on yammer")
public class ShareInYammer {

	public static final String ID = "ShareInYammer";

	@Context
	public CoreSession coreSession;

	@Param(name = "document")
	public DocumentModel doc;

	@Param(name = "comment")
	public String comment;

	@OperationMethod
	public void run() throws Exception {
		OAuthAccessor accessor = NuxeoOAuthClient.buildSigningAccessor(
				WEOAuthConstants.getDefaultCallbackURL(),
				YammerConstants.GADGET_URL,
				YammerConstants.YAMMER_SERVICE_PROVIDER_NAME,
				coreSession.getPrincipal().getName());
		OAuthClient client = new OAuthClient(new URLConnectionClient());
		final List<OAuth.Parameter> parameters = OAuth.newList(
				YammerConstants.YAMMER_MESSAGE_BODY_PROPERTY_NAME, comment,
				YammerConstants.YAMMER_OPEN_GRAPH_TITLE_PROPERTY_NAME, doc.getTitle(),
				YammerConstants.YAMMER_OPEN_GRAPH_DESCRIPTION_PROPERTY_NAME,
				doc.getProperty("dc:description").getValue(String.class),
				YammerConstants.YAMMER_OPEN_GRAPH_TYPE_PROPERTY_NAME,
				YammerConstants.YAMMER_OPEN_GRAPH_TYPE_DOCUMENT_PROPERTY_NAME,
				YammerConstants.YAMMER_OPEN_GRAPH_URL_PROPERTY_NAME,
				DocumentModelFunctions.documentUrl(doc));

		client.invoke(accessor, OAuthMessage.POST,
				YammerConstants.YAMMER_MESSAGE_POST_URL, parameters);
	}

}

Now it’s easy to export your operation to your Studio account and use it in your project.

All the source code is available on GitHub: https://github.com/ldoguin/nuxeo-yammer-sample.

That’s it for today. See you next Monday

So without further ado, here goes Question #1:

How do I integrate with nuxeo-platform-login-portal-sso in my portal?

By going to the URL above, you’ll see the answer to this question, with a detailed explanation and example code. This is a nice way to handle authentication of any external application to a Nuxeo server, using the http or automation client for instance.

One of the main assets of the Nuxeo Platform is the richness of its APIs: CMIS, REST, WebServices, WSS, Content Automation. Content Automation is a subset of our REST API and is probably the most powerful and simplest means to access Nuxeo. Its strength and richness lies in its ability to provide access to all the services offered within the Nuxeo Platform, but also because of how it integrates with other Nuxeo tools, such as Nuxeo Studio for customizing it, or Nuxeo IDE for extending.

From our wiki:

So here is a short screencast showing you how to write and deploy an operation on a Nuxeo server using Nuxeo IDE, and how this operation can be called from a simple python script. You will also witness the awesome hot-reload feature of the IDE

Here is the python script:

#!/usr/bin/env python
import urllib2, base64, json, sys

def count_words(document, field, server='localhost', port=8080,
    user='Administrator', password='Administrator'):
    """Call the CountWords operation on a text field of a document"""

    url = "http://%s:%d/nuxeo/site/automation/CountWords" % (
        server, port)
    auth = 'Basic %s' % base64.b64encode(user + ":" + password).strip()
    request_headers = {
        "Content-Type": "application/json+nxrequest",
        "Accept": "application/json+nxentity, */*",
        "Authorization": auth,
    }
    request_body = {"params": {"document": document, "field": field}}
    request_body = json.dumps(request_body)

    request = urllib2.Request(url, request_body, request_headers)
    response = urllib2.urlopen(request)
    return int(json.loads(response.read()).get(u'value', 0))

if __name__ == '__main__':
    print count_words(sys.argv[1], sys.argv[2])

And this is the java code:

package org.nuxeo.sample;

import org.nuxeo.ecm.automation.core.Constants;
import org.nuxeo.ecm.automation.core.annotations.Operation;
import org.nuxeo.ecm.automation.core.annotations.OperationMethod;
import org.nuxeo.ecm.automation.core.annotations.Param;
import org.nuxeo.ecm.core.api.ClientException;
import org.nuxeo.ecm.core.api.DocumentModel;
import org.nuxeo.ecm.core.api.model.PropertyException;

/**
 * @author ogrisel
 */
@Operation(id = CountWords.ID, category = Constants.CAT_DOCUMENT, label = "CountWords", description = "")
public class CountWords {

    public static final String ID = "CountWords";

    @Param(name = "document")
    DocumentModel doc;

    @Param(name = "field")
    String fieldName;

    @OperationMethod
    public Object run() throws PropertyException, ClientException {
        String text = doc.getProperty(fieldName).getValue(String.class).trim();
        return text.isEmpty() ? 0 : text.split("\\s+").length;
    }

}

Now that this modification has been completed, we were curious about what this new 5.4.3-SNAPSHOT distribution without EJB would bring us in terms of performance against our old distribution with EJBs.

Here is the result:

Tests have been made on identical Hardware using the same set of data.
If you follow links above, you will see the full FunkLoad diff report between the 2 configurations.

We’ve already discussed how the Nuxeo distribution on JBoss 5 strongly decreases response time against JBoss 4, as well as pointing out the sluggish performance of the EJB containers on JBoss 5 (see our release notes) and we further validate this as you can see we are closer to the tomcat distribution performance on JBoss 5 without EJB (second row into the table above).

This is only our initial findings and we haven’t yet conducted further analysis or dug deeper to try to explain the reasons for why we are seeing these results, but, in the meantime, you can watch the jenkins job here.

In conclusion, we can say that the JBoss 5 tortoise hasn’t yet caught up with the Tomcat hare, but it’s close.

How to retrieve source code?

Here is how to retrieve Nuxeo source code in read-only mode. However, maybe you don’t need to do it: see below “How to contribute”.

Requirements: Python 2.7.x and Git 1.7.x

  git clone git://github.com/nuxeo/nuxeo.git
  cd nuxeo
  git checkout master
  python clone.py

Run ‘python clone.py -h‘ for more details.

Why Git and GitHub?

Before that move, Nuxeo folks were sometimes already using Git because they are involved in external projects using Git. Based on their feedback, it appeared that Git was technically as good as Mercurial, and that hosting services such as GitHub were greatly improving the code management and encouraging contributions.

GitHub provides good tooling around Git features and great visibility in the developer ecosystem.

We look at GitHub to help external people contribute to Nuxeo, but also to help improve our own internal code review process. For instance, we are using the pull-request system inside Nuxeo, between developers, when we want to highlight a code review request on some specific piece of code, besides the continuous code review we are used to, which is based on an automatic email per commit.

Finally, as we were using Git for the more recent Nuxeo addons, and still mostly Mercurial for the rest of the platform, it was becoming painful to maintain both sources. So, using only Git for the whole platform will also simplify the build, maintenance of the scripts, and the developers’ lives.

How to use Git?

Nuxeo developers will share their experience, document main commands and provide useful tips about Git right here.

Nuxeo policy on Git branches

• development branch is “master”
• maintenance branches are “5.5.0″, “5.4.2″, “5.4.1″
• stable branch, if used, will point at the latest stable release (currently release-5.5).

What about contributions?

Using GitHub will greatly improve the contribution process. http://doc.nuxeo.com/x/VIZH will be updated according to the new capabilities. Briefly, a contributor will have to:

• log in to GitHub with his own account
• sign the Nuxeo contributor agreement
• fork the Nuxeo module he wants to contribute to
• do some changes in the forked repository
• file a Jira issue and reference it in his commits
• send a pull request to Nuxeo

And that’s all. The Nuxeo development team will manage the contribution, optionally comment the diff, ask for changes, and finally merge it into Nuxeo.

No more Mercurial?

For now, there are still some Nuxeo projects under Mercurial. This move involves “only” the Nuxeo Platform source code (https://hg.nuxeo.org/nuxeo/ and its sub-repositories, including most addons).

Of course, hosting our source repositories has a lot of advantages and a few drawbacks. When migrating to GitHub, we had to migrate the Mercurial hooks we were using and solve other such technical constraints, but at the end, we succeeded in transposing all features and the interoperability we need.

Mercurial is a great tool and we’ll likely continue to use it when it makes sense, but we want to avoid having users switch from one tool to another.

The deprecated repositories are still accessible. A DEPRECATED.txt file has been added inside the main branches.

Becoming Independent from jBPM

I’m saying “becoming” independent because of course we are not stopping jBPM support. It just won’t be the default task/workflows provider in future versions of DM.

So now that the first question is answered, let’s move to the second one, which is why?

The main reason is that even if jBPM is very powerful, it does not provide an easy way to make adaptive workflows.

Unfortunately, in the real world, when it comes to projects you need a lot of flexibility.
You can define a global process, but users and the administrator need to be be able to change the workflow.

So even if the jBPM toolbox is great, it mainly targets Java Developers and it’s clearly not suited for end users and even administrators.
That’s the reason why we want to make Content Routing the default workflow engine of the Nuxeo Platform in our upcoming releases.

In order to prepare for this migration, we want the Nuxeo services to be as independent as possible from jBPM, so that the switch to Content Routing will be painless.
So here comes the new task Service.

The Task Service

With the 5.5 release we introduced a way to manage Tasks outside of any jBPM process. We’ve added a document based task service focused on simplicity and flexibility. Simplicity because you don’t have to know many different concepts. If you are a Nuxeo developer or studio user, you are familiar with documents and content automation. This is all you need to know to create a task.
To be fair this capability has existed since 5.3.2 with the Workflow.CreateTask operation. But this was relying on the jBPM taskinstance api and now it’s relying on the document task. It means that tasks are now stored in VCS.

Migration should be 100% transparent:

• the Task Operations have not changed
• REST APIs are maintained
• Tasks created in jBPM and not directly associated to a process will be automatically migrated upon first access
• jBPM Tasks are still accessible via the new TaskService

What’s next

The only part of Nuxeo Platform 5.5 still using jBPM is the Workflow. It’s a first step toward the integration of Content Routing as the default Workflow engine in Nuxeo, and we will surely let you know about the progress of this project. At this point we will gain true flexibility. As workflows will be based on content routing and content automation, you will be able to redefine or modify them easily at runtime. This has already been put in practice with Nuxeo’s Case Management Framework. So if you’re curious, give it a try and test it out now.

Packaging improvement

Distributions are Marketplace Packages

The DM, DAM, SC, and CMF distributions are now available as Marketplace packages.

This new packaging system is used in the SetupWizard to allow to choose between different profile at installation time.
You can also use the Admin Center or the nuxeoctl to add or remove these packages.

For projects having a custom distribution based on one of ours, no problem, we provide presets for automatically transform the new unique Tomcat distribution into a DM, DAM or CMF.
Also, the “EAR” (zip) assemblies do still exist.

Using the wizard is just an additional option.

Coordinated Release

All distributions of the platform will now be released at the same time : CAP / DM / DAM / CMF / SC.

This is a little bit more work on our side, but this will allow to have consistent HotFixes management for all flavors of the Platform.

Plain-old WAR deployment through static archive

The support for static EAR has been extended to static WAR generation.
This means you can more easily run Nuxeo on a bare Java container, like a vanilla Tomcat!

The recipe is simple :

• configure your Nuxeo as desired (deploying additional bundles or Marketplace packages)

• run “nuxeoctl pack “

The pack command will produce a static EAR if you run JBoss and a static WAR if you run Tomcat.

Infrastructure changes

EJB3 phased out!

Nuxeo EAR packaging no longer comes with EJB3 support.
The support has been dropped due to very bad performances of EJB3 layer in JBoss 5.

If you used to communicate with Nuxeo services via RMI you can either switch to Automation API or use nuxeo-web-embedded distribution to deploy Nuxeo services directly inside your application.

Native Relation Store

The Relation Service can now be configured to use VCS (our native content persistence engine) as a backend instead of Jena/RDF.
This improves performances of the relation service and also allow queries to include properties on relations.

It’s now the default configuration for Comments, Forums and Document relations.

This new default configuration takes care about compatibility so that if you have existing relations in Jena graph you will still be able to transparently access them.

New Task system

Until 5.5, the Task system was directly bound to JBPM.

Starting with 5.5, a new TaskService is available and use VCS to store task.

This new TaskService is a first step toward the integration of Content Routing as the default Workflow engine in DM (will be available as a dedicated package in Q1 2012).

Migration should be 100% transparent :

• the Task Operations have not changed

• REST APIs are maintained

• Tasks created in jBPM and not directly associated to a process will be automatically migrated upon first access

• jBPM Tasks are still accessible via the new TaskService

• the jBPM task API is maintained

Theme Engine Improvement: Bring It on CSS!

Nuxeo Themes has been extended so that you can now contribute style of the pages with a plain CSS stylesheet.

The pages templates and layout are still managed by the Theme Engine, but all CSS information is now externalized to a plain a CSS that can manage flavors (pretty much as with LessCSS).

This makes styling of Nuxeo easier, both for a WebDesigner and a Nuxeo Studio user.

Content Persistence Engine Improvements (VCS)

Need for Speed?

Several performance improvements have been done in the persistence engine:

• caching for proxies and versions

• prefetch for complex properties

• reduce network round-trips (insert/update/delete)

Queries on Complex Types

Queries on complex types are now supported in NXQL (see NXP-4464).

Improvements of the full text search and phrase matching have also been done (see NXP-6720 and NXP-8070).

Better Oracle Support

Some compatibility and performance improvements have been done for Oracle DB.

Forms Engine: more Layouts and Widgets Features

Misc improvements

A lots of small improvements have been done in this area, especially to improve Ajax support and provide more configuration options from within Nuxeo Studio.

Extended JSON export API

Layout/Widgets JSON export API has been extended and is now used by Android SDK to generate Forms on the mobile device.

OpenJDK

We have finally done the work needed to provide full support of OpenJDK 6.

We also started to test the plateform with OpenJDK 7.

Build, unit tests and non-regression tests are running fine, so we will very soon provide official support.

For now you can still consider running Nuxeo Platform on OpenJDK 7 as experimental.

Third party libraries upgrades

GWT

Nuxeo is now using GWT 2.4.0.

JAX-WS

JAX-WS libs have been upgraded to 2.2.5 in order to fix some compatibilities issues.

OpenCMIS

Nuxeo Platform is now aligned on OpenCMIS 0.6 that comes with experimental support for the CMIS Browser binding (JS compliant API).

Features

User Experience

5.5 comes with a new look & feel and we have improved a lot of small details that should improve the overall usability of the platform.

Plus, it makes all customization & apps based on the Platform look nice by default! We hope you’ll enjoy it! (and if you don’t, you can customize the look easily!)

Rich Media as First Class Citizen

Based on our experience with Nuxeo DAM, Rich media support has been improved and merged into the main platform, as a system facet, so that all media features (conversions, players ) are available for any document type.

This also comes with a deep integration between DAM and DM that can now be installed side by side in the same webapp, the DAM UI becoming an Asset Browser.

QuickSearch

The QuickSearch bow has been improved to support smart automatic suggestion of search filters based on user inputs.

Depending on user’s input it will for example propose to search for Users, Groups, Documents containing text or Document having a given meta-data.

QuickSearch can also be used as a shortcut to Faceted Search.

You can see it in action in this video and then try for yourself in the 5.5.

Unleash the Social Enterprise: more Social features for the Nuxeo Platform

New social features are available in DM:

• rich profiles

  Now Nuxeo offers a rich profile for each user.
  Social Collaboration contributes to this profile to add social metadata. User can choose to make his profile public, or to keep it private.

• activity stream

  This new features gives an activity snapshot from your connections – those who are working on documents and content in the workspaces that you are allowed to follow. This gives a fast and simple, but secure way to easily access content and documents in the workspace, as well as a quick link to the user profiles of those involved in managing the content you follow.

• relationship between people

  Any user can now search for other users on the Platform and make a connection, by adding them to one of their relation circles. Once a user is connected to another he sees his activity stream (mini messages, document cretion and modification, etc.), his profile, his relations etc.

• Social Workspaces

  These new spaces feature private and public dashboards for end users, gadget management, and content and document libraries. They provide a quick and simple way to publish and access information while collaborating with others.

• mini messages

  Users can post and read short messages, from the people working with them in a social workspace, or from their relations

• new OpenSocial gadgets

  Fully OpenSocial gadgets for Mini messages and Activity streams, they can be used outside Nuxeo (in iGoogle for instance).
  Gadgets related to Social Workspaces: listing of (public) Social Workspaces, Activity stream and mini messages of Social Workspace, listing of Articles and News.

Case Management

This new release of the platform comes with a new version of CMF that can be installed as a Marketplace package.
Compared to the latest publicly released CMF version (1.8), it comes with a lot of improvements :

• Support for folderish caseItems

• Abbility to send any document type inside the case

• Content Routing improvements : new step type available : decisional folder

• Better user experience

NB : For now, it is not possible to install CMF with other packages like DM and DAM because there are some content model incompatibilities. We hope to have a functional solution to this problem in 5.6.

Update Center Improvements

Update Center has been improved to easier manage of Marketplace packages and Hot Fixes:

• install a package and all it’s dependency in one click
  ( useful especially if you need to install HotFix 12 for example)

• extended dependency management (including possible automatic uninstall of incompatible packages)

• small usability improvements

Installation and Uninstallation of packages that are not fully hot-reload compliant are now delayed until restart. This should solve most issues encountered when running on MS Windows based hosts.

You can also use NuxeoCtl to list/add/install/uninstall/remove packages without using the Web UI.

Upgrading from 5.4.2

We have been careful about Data and and API compatibility, so migrating from 5.4.2 should be easy.

For more details, please refer to the public Documentation.

Hot topics at ECE

The first day I participated in an Eclipse marketing meeting, where Ian Skerrett showed us how attendees are using Eclipse. Not surprisingly, most of the people are here for either the IDE features, RCP or model generation with EMF. Server side applications aren’t so appealing but they are definitely getting more and more attention. And it really showed in the program. There weren’t many server-oriented talks, but they were all well attended. I think my favorite one was about Gyrex. It basically helps you run clusters of Equinox servers with the help of several tools, like p2 for provisioning and deployment, a private cloud feature with ZooKeeper, Jetty for the web layer, etc… I’d really like to see Apricot in one of the repositories available with GyreX.

Apricot feedback

So, speaking of Apricot, for those of you who aren’t familiar with this name, Apricot is a content repository accessible through APIs. It will serve as a solid and efficient base for developing content applications. By “content applications,” we mean any application with a primary function of managing structured or semi-structured content in any way. This could be a Document Management application, a Digital Asset Management application, a Case or Records Management application, a Web Content Management application, or simply business-specific applications.
It’s part of the RT project, and we are still in the process of contributing the third party libraries.
If you are interested in this project, you will soon be able to view my screencast / tutorial showing how to build and develop content-centric apps with Apricot.

Eclipse ecosystem

One thing for sure is that giving business talks at ECE is definitely more challenging than giving really technical talks. The main reason for this is that the attendees want to know more about Eclipse as a technical platform. Most of them are developers, like the guys from Obeo. They work on MDA, for transforming models into code. We talked a bit about Nuxeo and code generation, and one of them even made me a small prototype (thanks Goulwen) . So who knows? Maybe we’ll see model-based generation of Nuxeo code.

Anyway, I had a blast at EclipseCon. I met some really cool people and I’m really looking forward to going back there with more Apricot, and maybe a case study.

Last week we released version 1.2 of our Eclipse plugin, Nuxeo IDE. It's as usual available through the marketplace or directly from the updatesite. First timers, you'll find everything you need to get started on our wiki.

So, what's new you ask? Well let's start with the coolest feature:

Seam Hot Reload

We've been waiting long enough and now hot reload is starting to show up in Nuxeo products. You can't reload the whole platform yet, but we made significant progress by adding Seam and WebEngine HotReload.

Better than words, here's the video showing how you can hot reload Seam code into Nuxeo apps.

As you can see in the screencast, we also added Seam wizards to help you understand how Nuxeo is using Seam. You have three different types of Seam bean, all heavily commented, explaining how to show content in a tab, execute code when clicking on a button or even how to wrap a service in a Seam component. And if you want to take this further by let's say, exploring the sources, there's a new way to do that as well…

SDK Introspection

One of the beauties of working with open source software is that you get to see all the sources, you get a complete view of how it's made, which makes the learning process much easier. That's why we added a new tab in the Nuxeo perspective called Nuxeo Components. It lets you browse all the services, extension points or components defined in the SDK. Here's a couple of screenshots from a component view:

You first have the bundle information, then a link to the implementation, the documentation, the services provided, and the list of extension points along with their contributions. Additionally, you have a link to the source of every java file referenced in those components.

And if Nuxeo sources are not enough, we've added the possibility to download sources of the third-party libraries we use. Right click on a jar, select properties and hit the download button.

That's all for today, but you can expect more NxIDE screencasts and tutorials in the coming weeks.
Happy Hacking

Last week was our second edition of Nuxeo World. Lots of very cool things to talk about…met some really interesting members of our community and in the process were able to exchange thoughts about ECM and Nuxeo. Two very inspiring days, along with a wonderful evening in which I had my photo projected on a 3x4m wall… thanks Roland . All of this of course happened for a reason, as I'm now filling the community guy shoes for Nuxeo.

Community@Nuxeo

So we finally gave in to the trend . We have a community liaison here at Nuxeo, and that would be me, Laurent Doguin. I'm thrilled because there are lots of amazing things to do, many topics to discuss and from what I saw during the 2 days at Nuxeo World, great people who are building our community. First things first, this blog (thanks M Soulcie) is where I'll regularly talk about what's going on in the community. Of course I won't be the only one posting here. Since this is a 'community' blog, you're all welcome to post content here. By the way Damien and Laurence already contributed their thoughts on the event.

I'll personally try to give you updates on what's cooking inside our walls so you guys get more visibility for your own projects. This will also be the opportunity to regularly talk about our Roadmap. I'll tell you a bit more about when we'll open it (Soon ).

Another part of my role will be to provide some technical, pedagogical content like tutorials, small case studies or quick examples. The first candidate for slated is the cookbook. I'm hoping to attract more and more developers to our platform and I'm sure we're going in the right direction with the release of the Eclipse plugin Nx IDE.

Sprint

Now for those of you who weren't at the Thursday evening party, we presented the results of our code sprint. Which consist of two whole days of coding, no interruption, on an appealing topic by teams of 2 to 6 persons. This means loads of coffee and pizza.  

Each team had to pitch their sprint and all the attendees voted at the end. There was some pretty neat stuff showcased. Additional details on this subject will be detailed to you through subsequent posts on our blog, but here's a little summary (full list available on our wiki):

The winning team presented it's Ajax suggestion search box. It basically suggests to you different types of search options. For instance if you type 'adm', it will suggest to you the Administrator user, the administrators group, the documents created by the Administrator user or the keyword 'adm'. This is a really sexy feature. Take a look at the video:

It was closely followed by the markdown team. They added markdown to the note document, with a nice pdf export. The iOS team did a basic app using automation with the help of Julien Jalon, Senior Software Engineer. The Android team was focused on the test setup for CI integration with the help of Edouard Mercier from Smart&Soft.

My own topic was the integration of the document rating system made by Damien Metzler from Leroy Merlin. We spent most of the time moving some metadata stored with hibernate into the documents schema while keeping the tests green. I still have to integrate it into the webapp with some shiny five star widget or maybe a Like/Don't Like button.

Next sprint will probably be held in 2012. The topic page is open so feel free to add suggestions. Everybody is of course welcome to participate, just drop me an email and we'll organise this.

Wrapping this up, we're all really happy about the way things transpired over these four days. A special thanks to Jeremy who managed most of the organisation and planning.

(@ldoguin on Twitter, LinkedIn)