Quelques retours sur le code

Bravo pour l'article, je ne connaissais pas du tout ce type de programmation, maintenant ma curiosité a été piquée ;-)

Aurais-tu des exemples de d'application non triviaux dans lesquels ce type de programmation fonctionne bien ?

Sinon j'ai parcouru rapidement le code et j'ai quelques conseils :

• Ton module utilise java sous le capot. Il serait bien d'en parler dans le READEME (ce n'est vraiment pas une dépendance anodine) et même de permettre à l'utilisateur de configurer quel java utiliser (via variable d'env par exemple).

• Il aurait été mieux de créer un répertoire owlready dans ton repo contenant le code python, l'avantage étant que la racine du repo est beaucoup moins fournie donc plus lisible, ainsi que le fait de pouvoir utiliser ton module sans avoir à l'installer en se étant dans le répertoire du projet.

• Ton répertoire test n'utilise pas de framework de test, je te conseil pytest qui est absolument génial (tu créé un fichier commençant par test_, tu mets des fonctions commençant par test_ qui font des assert et tu lances le tout avec avec py.test, c'est brillant de simplicité et extrêmement puissant). L'avantage étant que tu auras des rapport sur tes tests beaucoup plus précis et que tu pourras être beaucoup plus expressif dans tes tests (fixtures, setup/teardown, modules tiers etc.)

• De même je te conseils d'utiliser travis qui te permettra de faire de l'intégration continue (d'autant plus importante si tu cherches à avoir des contributeurs externes)

• La PEP8 n'est pas respecté, vu que c'est le standard ça rend tout de suite le code moins lisible. Il y a des outils comme autopep8 qui te permettent de mettre en forme ta base de code automatiquement, et flake8 en linter pour faire de la PEP8 sans y penser ;-)

• Les import * sont à proscrire (allez, à la rigueur on peut les utiliser dans le __init__.py quand celui-ci se contente de definir l'api exposée), ça rend le code beaucoup plus complexe quand on ne le connait pas, d'autant plus quand on le consulte en ligne et qu'on ne peut pas faire des greps dans le projet :'-(

• Mettre plusieurs commandes sur une même lignes via les point-virgules rend les choses confus, d'autant plus avec une indentation à 2 espaces, exemple qui m'a fait saigner:

class CallbackList(FirstList):
 __slots__ = ["_obj", "_callback"]
 def __init__(self, l, obj, callback):
 super().__init__(l)
 self._obj = obj
 self._callback = callback
 def _set (self, l): super().__init__(l)
 def _append(self, x): super().append(x)
 def _remove(self, x): super().remove(x)
 def reinit(self, l): old = list(self); super().__init__(l) ; self._callback(self._obj, old)
 def append(self, x): old = list(self); super().append(x) ; self._callback(self._obj, old)
 def insert(self, i, x): old = list(self); super().insert(i, x) ; self._callback(self._obj, old)
 def extend(self, l): old = list(self); super().extend(l) ; self._callback(self._obj, old)
 def remove(self, x): old = list(self); super().remove(x) ; self._callback(self._obj, old)
 def __delitem__(self, i): old = list(self); super().__delitem__(i) ; self._callback(self._obj, old)
 def __setitem__(self, i, x): old = list(self); super().__setitem__(i, x) ; self._callback(self._obj, old)
 def __delslice__(self, i): old = list(self); super().__delslice__(i) ; self._callback(self._obj, old)
 def __setslice__(self, i, x): old = list(self); super().__setslice__(i, x); self._callback(self._obj, old)
 def __iadd__(self, x): old = list(self); super().__iadd__(x) ; self._callback(self._obj, old); return self
 def __imul__(self, x): old = list(self); super().__imul__(x) ; self._callback(self._obj, old); return self
 def pop(self, i): old = list(self); r = super().pop(i) ; self._callback(self._obj, old); return r

Je le répète, j'ai beaucoup apprécié ton article et j'espère que tu ne prendras pas mal ces remarques qui sont plus sur la forme que le fond ;-)