But on the other side, i really think some part of webware should be left out. Look at the standard webware packages:

• CGIWrapper
• WebKit
• WebUtils
• MiscUtils
• COMKit
• MiddleKit
• PSP
• TaskKit
• UserKit

Only CGIWrapper / WebKit / WebUtils are used in Webware core. (+ TaskKit) All other stuff are not webware centric, even if they are usually working only by webware developpers:
- COMKit is win32 COM object related (nothing to do w/ webware core)
- MiddleKit is a DB abstraction layer
- PSP is a template language
- UserKit is a user framework ..( someone ever used it ???)

I really think we should provide only a simple package w/ webware core, and find a way to install third parties code as ‘Products’. This is definitly the main feature of Zope.

The recent post of Ian on the webware-discuss mailing list show that we shall write webware component like Wiki .. or AuthModule .. and provide them to the community.

I worked on Zope for about 2 years.. and right now when i want to build a simple website for the lab. Webware never come to my mind simply because it enforce me to rewrite the wheel for everything. In common web project we need some core components like auth, or photo gallery .. things that are really simple and provided w/ simple Zope Products. but for webware we only provide some _unusefull_ / _unmaintained_ Kit.

This is not a contestation post! but a open letter to the webware community.

The current webware package try to enforce developper to use some tools (like PSP / MiddleKit) but this is the wrong way. I never used PSP (i hate this syntax).. and MiddleKit has serious competitor, right now. I usually use SQLObject and ZPTPage. But there is no place on the web where a newbie can find that you can write ZPT in webware .. Webware really need a clean way to build Products and a website that present all this stuff to users.

• Zope alone
• Zope + CMF
• Plone
• Webware + Cheetah or PSP
• Webware + Modeling + ZPT ..

And my conclusions right now is: SQLObject is really a kool SQL Api since you can use it very easily. For the template i really think that ZPT is the best one. Despite XML parsing is really slow, and ZPT performance isn’t really good, you can edit the template without too much pain.

Another great thing, is that i can use this tools in Webware (of course) but in a simple python (mod_python for example) CGI. And SQLObject really feat nicely w/ webware, because it’s thread safe. (I discover severals troubles in Modeling w/ thread)

The next step is to find a good way to build ‘slots’, to have a cross site layout. ZPTPage doesn’t support all METAL tags (macros..) so this isn’t done by default .. and calling a lot of ‘structure’ include is a bad way because this will call the ‘slot’ rendering too much times.

The main key is : Keep it simple.

Some bugs still remain, i was unable to do cut/paste and there is a bug in guess_contenttype too, but not really a big deal i think.

After looking this a night, the system is really light ( don’t use a couple of CMF products or other things like DC workflow), si it have some limitation but it should be enought to do a good bloging system ( i’m still need to give up about this MT ). but it don’t use reST and this is a bad news.

Another thing that i found usefull is that it use EPoz for html editing and this is pretty kool .

import os,time

from ZPTPage import ZPTPage

class A:
    def __init__(self):
        self.a = 'B' * 50
        self.willChange()

    def getA(self):
        self.willRead()
        return self.a

    def setA(self,value):
        self.a=value
        self.willChange()

    def willRead(self):
        #print "Read %s" % self
        pass

    def willChange(self):
        self.lastChange = time.time()

class HereProxy(dict):
     def __init__(self,orig):
        print "New Here"
        self.orig = orig

     def __getitem__(self,key):
         result=getattr(self.orig,key)
         print "*** %-10s : %s " % ( key,result)
         cache = self.orig.application().cache[self.orig.hashCache()]

         if result not in cache:
             cache.update( {result:result.lastChange })
         return result

class Main(ZPTPage):
    def __init__(self):
        self.a = A()
        ZPTPage.__init__(self)
        self.here = HereProxy(self)
        self.validCache = False

    def writeHTML(self):
        if self.request().hasField('A'):
            self.a.setA(self.request().value('A') )

        cachedFileName=os.path.join('/tmp/w/',self.hashCache() +'.html')
        try:
            cache = self.application().cache[self.hashCache()]
        except KeyError:
            self.application().cache[self.hashCache()] = {}
            cache = self.application().cache[self.hashCache()]

        needUpdate = 0

        #import pdb;pdb.set_trace()
        for obj in cache.keys():
            try:
                print obj.lastChange
                if obj.lastChange !=  cache[obj]:
                    needUpdate = 1
                    break
            except AttributeError:
                needUpdate = 1
                break

        if needUpdate == 0:
            print "*** Serving cache %s ***"  % self.hashCache()
            try:
                data = open(cachedFileName,'r').read()
            except IOError:
                needUpdate = 1

        if needUpdate:
            print "*** Regerating %s ***"  % self.hashCache()
            self.buildContext()
            data = self.template.render()
            open(cachedFileName,'w').write(data)
        self.response().setHeader('Content-type', 'text/html; charset=UTF-8')
        self.writeln(data)

    def buildContext(self):
        self.updateContext('text','Toto')

    def getTime(self):
        import time
        return time.time()

    def getHere(self):
        #return {'a':A()}
        return self.here

    def sleep(self,context):
        print self.application().cache
        ZPTPage.sleep(self,context)

    ### cache ###
    def hashCache(self):
        return "MainTemplate"