[Zope3-Users] linuxfr news proposal / Proposition de news linuxfr

Wed Oct 18 14:47:49 EDT 2006

Sorry for english speaker, this is a copy of a message sent on the french list 
(http://lists.afpy.org/cgi-bin/mailman/listinfo/zope3-french-user , about a News 
proposal to promote Zope 3 on http://linuxfr.org

===============================

Bonjour à tous,

Afin de promouvoir un peu Zope 3, et puisque la version 3.3 est sortie il y a 
peu, je propose de faire une news linuxfr.  Plutôt que de poster moi-même 
directement la news au risque d'écrire des conneries, je préfère vous la 
soumettre pour relecture et amélioration. Mon but initial n'est pas de faire une 
news classique pour dire « zope 3.3 est sorti », mais d'illustrer brièvement ses 
meilleurs atouts et ses spécificités pour mettre l'eau à la bouche et faciliter 
la compréhension initiale pour quelqu'un qui démarrerait de zéro, sans avoir 
touché Zope 2.
Ca ne s'adresse donc pas aux utilisateurs de Zope 2 et je ne voudrais pas trop 
parler de Zope 2 ni de Five.

Si vous pensez que certains points sont inexacts ou si j'ai oublié de parler de 
trucs essentiels, dites-le moi, et dès que c'est ok je soumets !

cordialement,
Christophe Combelles

--------------------------------------------------------------
***** titre :
--------------------------------------------------------------
Que peut-on faire avec Zope 3.3 ?

--------------------------------------------------------------
***** cadre principal :
--------------------------------------------------------------
À l'occasion de la sortie de Zope 3.3.0 voici une micro présentation permettant 
d'appréhender rapidement ce qu'offre Zope 3 pour le développeur web.
     Zope 2 a la réputation d'avoir une courbe d'apprentissage unique en forme 
de Z : très rapide au début pour faire des choses simples, puis avec une pente 
négative car il faut tout désapprendre pour faire des choses propres, et lente à 
la fin pour maitriser les concepts avancés ; mais les gens s'arrêtent souvent en 
haut de la première pente. En outre, bien qu'encore utilisé dans des gros 
projets comme ERP5 ou Plone, et malgré la sortie régulière de nouvelles version 
(2.10 il  y a deux semaines), il est doucement en voie d'obsolescence.
     Zope 3 est une réécriture complète de Zope 2 et il est utilisable (et 
utilisé) en production. Il élimine la première bosse d'apprentissage et permet 
d'aborder directement la puissance de Zope plus facilement et plus proprement. 
Il est plus cohérent, plus homogène, plus léger et de plus en plus simple au fil 
des versions. Il est conçu dès le départ pour les gros projets, mais il est 
maintenant possible de faire des petits sites et c'est probablement la meilleure 
façon d'apprendre progressivement.

Zope 3 est sous licence ZPL 2, compatible avec la GPL.
--------------------------------------------------------------
***** liens :
--------------------------------------------------------------
Zope 3.3.0 :
http://www.zope.org/Wikis/DevSite/Projects/ComponentArchitecture/Zope330
La nouvelle FAQ :
http://zope3.zwiki.org/FAQ
un recueil de liens sur Z3 :
http://ccomb.free.fr/wiki/wakka.php?wiki=Zope3
--------------------------------------------------------------
***** 2ème cadre :
--------------------------------------------------------------
*Une interface web de gestion*

Zope 3 fournit une interface web, la ZMI, qui permet de visualiser le contenu de 
sa base de données. Elle permet d'inspecter les objets, de les modifier, d'en 
ajouter ou d'en effacer, d'inscrire certains dans un registre, de consulter leur 
interface.
La ZMI offre également une documentation des objets et des interfaces, ainsi que 
des textes, tutoriels et exemples de code.
Elle permet de commencer à jouer tout de suite avec Zope 3. Cette interface web 
est complètement modulable, extensible et transformable grâce à des composants 
et des skins.

*Un stockage très facile en base de données*

Appelée ZODB, elle permet d'organiser des objets de manière arborescente. 
Certains objets, comme l'objet Folder, peuvent contenir d'autres objets.
Le stockage des données se fait sans effort et de manière transparente : il n'y 
a pas de requête à faire, les objets stockés dans la base sont directement 
accessibles dans le code. Par exemple pour créer un objet Machin et 
l'enregistrer dans la base de données sous le dossier "folder", il suffit d'écrire
machin = Machin()
folder['machin']=machin
Pour le récupérer : monmachin = folder['machin']
Pour l'effacer de la base de données : del folder['machin']
Pour modifier son titre : folder['machin'].title = u'titre'
Le seul prérequis est que machin soit hérité de l'objet Persistent.

La cerise sur le gateau est la gestion des transactions, et la possibilité 
d'annuler n'importe quelle opération sur la base de données. On peut conserver 
tout l'historique ou le purger.

*Des templates de pages en XHTML*

Le module ZPT permet d'écrire des pages templates en XHTML en conservant la 
validité XML. Ceux-ci peuvent donc être envoyés à un graphiste ou être édités de 
manière transparente dans un éditeur wysiwyg.
Par exemple pour créer un titre dynamiquement dans une page html, il suffit 
d'écrire :
<h1 tal:content="objet/titre">mon titre</h1>
La partie « tal:content » indique de remplacer le contenu de la balise h1, 
c'est-à-dire « mon titre », par l'expression fournie. Et objet/titre permet 
d'accéder à l'attribut « titre » de l'objet « objet ».

Zope 2 offrait un système de macros permettant de créer des templates de 
templates, mais dans Zope 3 un système plus souple et plus puissant que les 
macros ont été créés : les Viewlets et les Viewlet Managers.

*Des interfaces*

Zope 3 ajoute à Python la notion d'interface et celles-ci y occupent une place 
centrale. Le principe est qu'un objet peut avoir plusieurs interfaces, à l'image 
d'un véhicule qui offre une interface volant pour conduire, une interface roues 
pour dialoguer avec la route, une interface siège pour dialoguer avec le dos et 
les fesses, etc.  Au lieu d'offrir chacun une seule interface complexe, les 
objets offrent une multitude d'interfaces très simples, dédiées chacune à une 
fonctionnalité particulière implémentée. Les interfaces permettent de savoir ce 
que les font objets, d'interroger un registre pour trouver un objet offrant une 
fonctionnalité particulière, ou de remplacer aisément des objets par d'autres 
ayant la même interface. (cf. Duck Typing : si ça fait coincoin, c'est un canard 
!).

*Des composants*

Zope 3 se base essentiellement sur l'assemblage de composants individuels. Il y 
a maintenant deux types principaux composants : les <i>utilities</i> et les 
<i>adapters</i> :
- Les <i>utilities</i> ne sont pas de simples utilitaires, ce sont les objets 
principaux qui permettent de batir d'une application (des objets conteneurs, des 
objets d'authentification, des objets pour envoyer des mail, etc.). Ils offrent 
chacun des interfaces et peuvent être inscrits dans un registre afin d'être 
récupérés facilement.
- Les <i>adapters</i> sont des composants qui permettent d'adapter un ou 
plusieurs objets à une interface pour laquelle ils n'ont pas été prévus. Ils 
permettent d'assembler et de réutiliser des objets même pour des cas non prévus, 
sans avoir même besoin de faire de l'héritage.

*La génération/vérification automatique de formulaires web*

L'idée est la suivante : si on retire à un formulaire web toute sa logique de 
traitement, on obtient  quelque chose de très proche d'une interface. Donc si un 
objet est décrit par une interface, il devient possible de l'afficher et de 
l'éditer facilement avec un formulaire web. Avec l'aide des modules zope.schema 
et zope.formlib, on peut créer facilement des modèles de données, générer 
automatiquement des formulaires web basés sur des widgets pour les 
ajouter/modifier, et mettre en place une vérification automatique des données 
entrées dans le formulaire. Tout ceci prend quelques lignes de code, évite de 
longs développements, et permet de sécuriser beaucoup plus facilement les 
applications web.

*Et de nombreux autres modules*

- Les sessions
- Les préférences utilisateurs
- Deux modules de workflow (wfmc et hurry.workflow)
- L'indexation
- une API de dépréciation
- L'introspection
- l'internationalisation (avec support Unicode)
- Et j'en oublie.
--------------------------------------------------------------