Nuxeo Developers Blog

CPS Platform R&D paper from EuroPython 2005 has been published

We published today the EuroPython 2005 CPS Platform R&D paper on cps-project.org that has been written as a refereed paper for this event.

(Post originally written by Julien Anguenot on the old Nuxeo blogs.)

OOoCon2005 - Koper Day 1

OpenOffice.org conference takes place this year at Koper in Slovenia (Near Trieste - Italy)

Sessions will focus on different main directions:
- development (red)
- eductional (green)
- community (orange)
- general (blue)

Today, a lot of interresting topics wil be covered and i plan attend mainly to the developpers ones
http://marketing.openoffice.org/ooocon2005/schedule/thursday.html

I haven't tested it, but you can see the live stream :)
http://ooocon-arnes.kiberpipa.org/
OOoCon as if you where there

Moreover, it is the time and place to meet people and finalize the scripting project. A lot of ideas are exchanged and i'm confident we will end with an efficient process to drive addons production from developpers to end-users.
This is a strong way to create a dynamic community proposing OpenOffice.org enhacement without diving into th core sources that don't attract newcomers.
Btw, if you're a core developper, you're welcome !! we need you
http://development.openoffice.org/todo.html
The list is not exhaustive. Just join and ask

Koper today : Raining

(Post originally written by Laurent Godard on the old Nuxeo blogs.)

YADI, part 3: timedtest, a decorator for time performance tests

Grig Gheorghiu has released a pretty cool tool, called pyUnitPerf. It's a
port of Mike Clark's JUnitPerf.

This tool runs your tests cases, and measure the time they take to run. It
can pop a Failure when the tests lasts too long. It also has a Load runner,
but nothing comparable to the amazing funkload tool

Thats quite useful in some cases, when your test fixture does not make the
code run slower, like it happens in ZopeTestCase.

So since pyUnitPerf associates a max time with a TestCase class, and since
test fixture can slow down the tests, it makes it really hard to use it, to
measure a distinct test method.

So I have taken back the idea and put it in a decorator that I can use on
all test methods I want to control, performances wise.   

The timedtest decorator

import unittest
import time

# might be changed to allow tolerance
# if tests are run on other boxes
TOLERANCE = 0.05

class DurationError(AssertionError): pass

def timedtest(max_time, tolerance=TOLERANCE):
    """ timedtest decorator
    decorates the test method with a timer
    when the time spent by the test exceeds
    max_time in seconds, an Assertion error is thrown.
    """
    def _timedtest(function):
        def wrapper(*args, **kw):
            start_time = time.time()
            try:
                function(*args, **kw)
            finally:
                total_time = time.time() - start_time
                if total_time > max_time + tolerance:
                    raise DurationError(('Test was too long (%.2f s)'
                                           % total_time))
        return wrapper

    return _timedtest
    

Usage

It's quite easy to use, just decorate a TestCase method with it, giving the max time allowed for the test, in seconds:    

class MyTestCase(unittest.TestCase):

    def __init__(self, name):
        unittest.TestCase.__init__(self, name)

    @timedtest(2)
    def test_timecritical(self):
        time.sleep(1.5)

    @timedtest(1)
    def test_timecritical2(self):
        time.sleep(1.5)

if __name__ == '__main__':
    suite = unittest.makeSuite(MyTestCase)
    unittest.TextTestRunner().run(suite)

Now this can help much to make sure some critical code does not get too
  slow.
  

[tziade@Tarek Desktop]$ python timedtest.py
.F
======================================================================
FAIL: test_timecritical2 (__main__.MyTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "timedtest.py", line 28, in wrapper
    raise DurationError(('Test was too long (%.2f s)'
DurationError: Test was too long (1.50 s)

----------------------------------------------------------------------
Ran 2 tests in 2.999s

 

(Post originally written by Tarek Ziadé on the old Nuxeo blogs.)

Perspectives 2006 : un grand merci à tous !

Nuxeo a organisé aujourd'hui le séminaire Perspectives 2006, destiné à nos principaux clients et contacts. Ce séminaire, aujourd'hui dans sa première édition, sera renouvelé chaque année et sera l'occasion, comme aujourd'hui, de faire un bilan de Nuxeo, de CPS et de l'Open Source ainsi que d'exposer notre vision, notre stratégie et les faits marquants à venir. Les slides et des photos de l'évènement seront publiées sous peu sur nuxeo.com.

Perspectives 2006 a reçu un accueil très favorable et je souhaite remercier vivement les participants, nombreux, qui ont répondu favorablement à notre invitation. Nous avons passé un très bon moment et espérons que cela a été le cas pour tous !

Les premiers retours ont confirmé notre motivation et conforté notre stratégie. Nous espérons pouvoir renouveler cet évènement chaque année, et pour de nombreuses années ! :-)

Merci à tous ceux qui nous ont fait confiance et à ceux qui le feront !

(Post originally written by Eric Barroca on the old Nuxeo blogs.)

blogs @ nuxeo.com updated !

http://blogs.nuxeo.com has been updated and runs now against :

• Zope-2.8.1
• Latest CPS Platform
• Latest CPSBlog

(Post originally written by Julien Anguenot on the old Nuxeo blogs.)

wikimailing

I am thinking about a feature that could link portal knowledge in a very simple way, about the same way CPSSharedCalendar and CPSSubscriptions does when they send emails.

I keep on trying to find such features in existing tool, it has to exists.. Whenever I find it, i'll remove this stupid blog entry ;)

Well, here's what I've taught of:

• Provided that the portal members are actually using the webmail to talk to each other about their work,
• Provided that users are gathered in work groups, and therefore share a common knowledge:

Mails beeing sent for this private circle could have meta content, by using wiki notation, the webmail could then parse these mail bodies to display internal links to wikipages or to future wikipages.

This feature would also make the mail writing easier, since it can refers to common knowledge, and consolidate this knowledge because it is the central part of all dialogs and therefore all important infos,out of the dialog, are kept centralized.

One wiki per work group should be the perfect balance.

Here's a sample:

Regular mail exchanges :

Hi Bob,

Can we meet sometimes about the x32 project, 
do you remember about it ? 

I sent you a mail 4 months ago about it.

you have the specs here: http://xxx/specs 
 and the client web page is there: http://xxx/dsddd

Please let me know when we can meet about it,
and if you have more info about them, let me know. 

Bill

---

Hi bill,

Sorry, don't remember,  can't find your mail.
what was the subject ?

OK, anway, i have looked at the pages (the second link is down, though)
I have aslo found infos here: http://xxx/dsdsdssd

let's meet on tuesday

Bob

WikiMailing:

Hi Bob,
Can we meet sometimes about the [x32 project], 
Please let me know when we can meet about it, 
 don't hesitate to complete the informations we have. 

Bill 

---

Hi bill,

OK, i have completed them.

let's meet on tuesday, please create the meeting 
 page by clicking on the link below and fill it. thx

[x32 project meeting]?

Bob

CPSMailAccess could then parse the mail body, according to the user center of interests (ie: the groups he belongs to) and make links to different wiki groups.

OK, this is what we all tend to do. For example Trac links are heavily used in mails when we talk about bug or features, but, if we talk about other subjects, the principal knowledge base moves in the best cases from trac to another tool, but most of the time we have to look over our mails to recollect some infos...

,

The main idea is to pour email info richness into a centralized, common, base, and to make the mail beeing just what it should be: a simple trigger.

(Post originally written by Tarek Ziadé on the old Nuxeo blogs.)

YADI, part 2: a simple Psyco decorator

Psyco is a pretty cool tool from Armin Rigo, that can really speed up the code in some cases. It relies on generating machine code by writing the corresponding bytes directly into executable memory.

For language lawyers and people interested in the subject, the website has a lot of papers on how Psyco works.

But the caveats makes it quite unusable as a  global application directive and it's better to target the code where we want Psyco to do the speed.

Psyco comes with a handy set of API, and the proxy() function, that takes a callable object and returns a psychoed-callable object, makes it easy to create a decorator that can be used whenever needed.

import psyco

# decorator psycoed 
def psycoed(function): 
    try: 
        return psyco.proxy(function) 
    except TypeError: 
        return function 

The TypeError thing just prevents errors on objets that can't be proxied.

The psyco-effect is quite cool:

def normal():
    a = 0
    for i in range(5000):
        a = a + 3
    return a

@psycoed
def speedy():
    a = 0
    for i in range(5000):
        a = a + 3
    return a

if __name__ == '__main__':
    import timeit

    temps = timeit.Timer('speedy()', 'from __main__ import speedy').timeit(10000)
    print 'psycoed: %f s' % temps

    temps = timeit.Timer('normal()', 'from __main__ import normal').timeit(10000)
    print 'not psycoed: %f s' % temps

[...]

[tziade@Tarek Desktop]$ python psycote.py
psycoed: 0.249526 s
not psycoed: 14.255591 s

(Post originally written by Tarek Ziadé on the old Nuxeo blogs.)

YADI, part 1: Memento Pattern

YADI ?

"YADI" stands for Yet Another Design pattern Implementation, because GoF design patterns have been reviewed and implemented a bunch of people already, all over the web. I'd like to present my own implementation for some of them, though, in this blog.

This first post is about Memento, inspired from Zoran Isailovski's one on ASPN, (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/413838) but with a slightly different approach to simplify its use.

Memento: What for ?

Memento DP says: a state of the program data can be saved and reloaded, thus allowing to make safe transactionnal operations. In other words, some program data changes can be rolled back at some point, or commited.

The code pattern that describes it the best is:

begin_transaction()
try:
  ...
except:
  rollback_transaction()
  raise
else:
  commit_transaction()

Depending on what the program does, the scope of data that are to be saved can vary a lot. Transactions in RDBMS covers the whole database for instance.

The easiest way to implement Memento in Python is to set the transactional level to objects.

And the easiest way to implement this is to create a decorator that allow some methods of an object to become transactionnal.

The transaction decorator

The decorator transaction could be:

import copy

def get_memento(object):
  """ get the object state """
  return copy.deepcopy(object.__dict__)

def set_memento(object, state):
  """ restore the objet """
  object.__dict__.clear()
  object.__dict__.update(state)

def transaction(method):
  """ decorator """
  def bind(object, *args, **kw):
    state = get_memento(object)
    try:
      return method(object, *args, **kw)
    except:
      set_memento(object, state)
      raise

  return bind

This implementation is based on the copy module, that works with the __dict__ atribute of the object, thus it won't work if the object is a new-style class that has dropped the use of __dict__ in some ways (slots, descriptors, etc..).

Anyway, it's pretty usefull on most classes, and they can implement the __deepcopy__ method to control the copy behavior.

Example of use

The example below implements a run() method, that becomes transactionnal

class M(object):
  def __init__(self):
    def o():
      print 'OK'
    self.a = 12
    self.b = ['a', 32]
    self.l = o

    @transaction
    def run(self):
      self.b.append('c')
      self.o = 12
      self.a = '14'
      self.a += 1

objet = M()

try:
  objet.run()
except TypeError:
  pass

print objet.a
print objet.b
objet.l()

[...]

[tziade@Tarek Desktop]$ python memento.py
12
['a', 32]
OK

When run() fails, because a + 1 (a is a string) leads to a TypeError, the state of M is automatically rolled back.

(Post originally written by Tarek Ziadé on the old Nuxeo blogs.)

CPSGeo : Simple GIS for CPS

What is it ?

Cartographic maps are extremely useful tools for analyzing and summarizing information with a spatial component, and many CPS documents have a spatial component: events happen at places, and reports are often concerned with places. With the addition of a few simple properties, CPS documents can be promoted to GIS (Geographic Information System) features. The CPSGeo product provides a new geolocation schema for documents, and a lightweight web GIS application for locating and displaying document features cartographically. CPSGeo builds upon open standards for GIS interoperability such as GML, the Geography Markup Language, and WMS, the Web Map Service specification. The body which oversees these standards is the Open Geospatial Consortium (http://www.opengeospatial.org).

Documentation

You may check the CPSGeo manual over there :
http://www.cps-project.org/sections/projects/cpsgeo_simple_gis_for/doc/cpsgeo_manual

And as well the doc sub-folder of the product :
https://svn.nuxeo.org/trac/pub/browser/CPSGeo/trunk/doc/

Download

We released a first devel version of CPSGeo (0.1.1-1) that you can grab from there :
http://www.cps-project.org/sections/projects/cpsgeo_simple_gis_for/releases/cpsgeo_0_1_1_1_tgz

The source code is over there :
https://svn.nuxeo.org/trac/pub/browser/CPSGeo/trunk/

Note, CPSGeo works against latest CPS versions. CPS-3.3.6  or trunk will be fine.

Screenshots

Couple of screenshots to get a quick overview.

http://www.cps-project.org/sections/projects/cpsgeo_simple_gis_for/screenshots/view

Report bugs

https://svn.nuxeo.org/trac/pub/newticket
http://lists.nuxeo.com/mailman/listinfo/cps-users

Home page

http://www.cps-project.org/sections/projects/cpsgeo_simple_gis_for

Thanks to Sean Gillies for his work on this component.

We would love hearing from your experience using CPSGeo :)

Enjoy !

(Post originally written by Julien Anguenot on the old Nuxeo blogs.)

Nuxeo et l'Open Source : Monsieur Zapolsky, Linagora est toujours bienvenue...

Update: Alexandre Zapolsky m'a depuis contacté et une rencontre est prévu pour éclaircir et régler tout cela. Je tiens à ajouter qu'il n'est pas question ici question d'une critique du modèle de Linagora ni de choix de cette société d'utiliser d'autres technologies que CPS. Il est uniquement question du caractères Open Source, parfois injustement contesté, de CPS.

Depuis quelques temps, on nous rapporte régulièrement les échos de propos tenus par Monsieur Zapolsky (PDG de la société Linagora, société de service en logiciel libre) concernant l'attitude de Nuxeo par rapport au monde du logiciel libre / Open Source. Ces propos, injustes et diffamants, commencent à être trop présents pour que je prenne le temps de répondre publiquement et d'en profiter pour faire un bref état de l'implication de Nuxeo dans le monde du libre et de l'Open Source (je tiens d'ailleurs à préciser que ce billet a été précédé d'un mail envoyé la semaine dernière à l'intéressé, sans réponse à ce jour).

M. Zapolsky semble trouver que Nuxeo ne respecte pas le jeu de l'Open Source et refuse des contributeurs (en particulier, selon lui, Linagora - qui ne nous a pourtant jamais contacté pour nous faire part d'une demande de collaboration).
 
Je trouve cela vraiment étonnant étant donné les retours que nous avons des membres de la communauté CPS et de nos actions (clients, utilisateurs, intégrateurs ou partenaires). Nos partenaires commerciaux pourront d'ailleurs confirmer notre souhait de voir les améliorations réalisées lors de projets être intégrées dans le coeur de la plate-forme.

En premier lieu, j'aimerais rappeler quelques faits importants :

• CPS est un logiciel libre / Open Source complet, disponible sous licence GPL (dont le caractère Open Source n'est, je pense, plus à démontrer :-).
• Le développement est totalement ouvert (dépot Subversion public, bugtracker en ligne, roadmap et architecture discutées dans une mailing list de développeurs, tests unitaires et fonctionnels en ligne, etc.) et un simple coup d'oeil à la timeline permet de se rendre compte qu'au vu du nombre de contributions (commit SVN) quotidiennes à CPS (6600 sur les 8 derniers mois soit plus de 40 en moyenne par jour ouvré) il semble difficile d'imaginer qu'il puisse y avoir une version privée / secrète de la plate-forme !
• Le portail collaboratif CPS Project permet à la communauté CPS de publier et consulter de l'information, de la documentation, des astuces et de coopérer dans les espaces collaboratifs.
  
• Les listes de discussions pour les développeurs et les utilisateurs (FR et EN) sont très actives et recoivent plus de 40 messages par jour en cumulé.
• Nuxeo offre par ailleurs des contributions majeurs à la plate-forme Zope : nous employons 6 core developers Zope, largement reconnus dans la communauté (notamment Florent Guillaume, Julien Anguenot, Ruslan Spivak ou Lennart Regebro).
• Lancement de nouveaux projets OpenSource importants comme Z3ECM ou la Zope Foundation, en partenariat avec de nombreux acteurs.
• Plus de 10 développeurs externes à la société contribuent activement à CPS (en plus des 15 développeurs Nuxeo) et ajoutent des fonctionnalités majeures, notamment Jean-Marc Orliaguet (Université de Chalmers, Suède), Martijn Faassen (Infrae). CPS dispose d'ailleurs d'une équipe totale de plus de 25 core developers actifs (ce qui équivaut ou dépasse largement de nombreuses équipes de développement chez les éditeurs propriétaires du secteur, y compris les ténors traditionnels).
• Nuxeo a actuellement publié plus de 150 000 lignes de codes uniquement pour CPS et plusieurs milliers dans Zope (note: en ne comptant que le code Python, excluant les lignes vides, les commentaires et les modèles HTML). Ces chiffres ne signifient naturellement rien dans l'absolu mais sont, à mon avis, un indicateur important de la contribution et de l'implication de notre entreprise.
• Nuxeo encourage les sociétés de services déployant CPS pour leurs clients (y compris lorsque nous n'intervenons pas).

Étant donné ces faits vérifiables je trouve réellement étonnant de penser que Nuxeo n'est pas assez OpenSource... Je vous invite d'ailleurs à comparer les faits exposés plus haut à l'implication de la société Linagora sur son site communautaire. Je vous laisse le soin de le consulter pour éviter tout polémique et rester factuel. Un indice, quand même : c'est très loin de ce dont je parle ici ;-)

Nuxeo est, effectivement, une entreprise qui cherche à croitre et à se développer. Est-ce un problème ? J'espère sincèrement qu'aucun lecteur ici ne nous en tiendra rigueur. Nous souhaitons, en outre, montrer qu'il est possible de construire une entreprise produisant des logiciels libres / Open Source (à l'instar de MySQL, RedHat ou Mandriva, par exemple) et pas seulement en utilisant ce type de logiciels (à l'instar de tant de sociétés de service — et/ou SSLL). Depuis sa création, Nuxeo suit cette voie. Nous espérons réellement créer un écosystème dynamique autour d'une plate-forme libre qui excelle dans son domaine. CPS est actuellement la solution OpenSource d'Entreprise Content Management (ECM) la plus complète, à en croire des analystes tels que Gartner, Markess International ou KnowledgeConsult et des grands intégrateurs tels que CapGemini, Euriware ou Unilog (nous sommes bien-sûr de cet avis ;-).

Nuxeo est, à notre connaissance, la seule entreprise française à produire autant de logiciels libres, avec Mandriva. Je souhaite sincèrement (pas uniquement par altruisme ;-) que cela continue pour livrer chaque jour de meilleures solutions à nos clients, fondées totalement sur des logiciels Open Source, et espère vivement que d'autres entreprises en France et en Europe vont avancer dans cette voie (mais c'est un autre sujet).

J'aimerais que tous les donneurs de leçon lisent bien la liste ci-dessus avant de critiquer gratuitement et sans fondement notre attitude envers l'Open Source et reste disponible pour en discuter. Il semble que peu d'entre eux soit aussi impliqués que Nuxeo dans la promotion et la production de logiciel Open Source, en en respectant les règles.

Je suis vraiment déçu par l'attitude de M. Zapolsky et Linagora. Je n'ai rien contre la concurrence et il se peut que nous nous trouvions parfois à travailler sur les mêmes dossiers (même si je n'ai pas le souvenir ou la connaissance que ce soit arrivé récemment). Je suis ravi que Linagora réussisse (en tout cas j'espère que c'est le cas), même si j'ai des réserves sur leur positionement stratégique à long terme. Pourquoi ne pas travailler avec fair-play et savoir vivre ? Pourquoi attaquer injustement des confrères alors qu'il y a tant de logiciels libres à créer et développer ?

Cela ressemble à une guerre fratricide alors que nos adversaires sont ailleurs ! Travaillons plutôt ensemble pour développer nos atouts face à nos réels adversaires commerciaux : les éditeurs de logiciels propriétaires du même secteur. Je n'ai rien contre les critiques, sauf quand elles sont injustes et pensais pouvoir compter sur une attitude au minimum fair-play de la part d'une entreprise comme Linagora, et de son PDG, que sa position de Président d'une association qui se veut représentative du secteur devrait mettre au-dessus de telles mesquineries.

Alexandre, pour terminer, si tu souhaites que ton équipe puisse contribuer à CPS, qu'elle en a les compétences et promet de ne pas "casser le build", tu es vraiment le bienvenu. Je serais ravi d'ouvrir moi-même les accès...

Technorati Tags: cps, nuxeo, opensource

(Post originally written by Eric Barroca on the old Nuxeo blogs.)