Hi Michi thanks for your insights. There are several issues here and I'm still trying to sort them out ;)
1. Design principles Do I understand correctly: your resource objects say which interfaces, in which version, they implement. Does that mean that you store this information along with the contents? If so, is it in XML, or serialized Java objects, or ... (just being curious ;) ) So next step, you read a resource and the controller knows which version of which interface this resource implements. If you keep the "old" code in your controller to support the older versions of the interfaces, you can handle them. 2. Consequences I understand how this would simplify backwards compatibility, since the old code is still in the program and still works. But why would this result in less releases being necessary? 3. Relevancy to Lenya Do you see an incompatibility between this approach and what Lenya is doing? Is there something inherent in Lenya's design which would prohibit versioned interfaces? At the moment, an argument that comes to my mind would be that the interfaces in Lenya are too complex and would make the implementation of versioned interfaces too hard to maintain - is this the main problem in your eyes, or something else? Thanks in advance for any further input! Wolfgang >>> (...) >>> The main reasons I have started Yanel and use it today successfully >>> (and >>> not using Lenya anymore) are >>> >>> - backwards compatibility/upgradeability >>> - scalability/performance >>> (...) >>> >>> With Yanel we do not need releases anymore (except from a marketing >>> point of view), but can continuously upgrade at any time and it handles >>> arbitrary amount of content without a problem >>> >> >> Hi Michi >> IIUC you are saying that Yanel has design principles ensuring >> upgradeability. This sounds interesting, can you elaborate a bit? >> > > it's all about versioned interfaces > > http://yanel.wyona.org/javadoc/org/wyona/yanel/core/api/attributes/package-summary.html > > Yanel is at the core a framework with interfaces (with content > management characteristics) in order to build on. > > Interfaces/contracts/protocols have a good and bad side. Your > implementations break when they are being changed, but > you want them to break. So how to get out of this dilemma? > > The answer is "versioned interfaces" (just as some protocols also have a > version) > > So the basic element/unit of Yanel is a so-called "resource" (or > "resource type"), which acts as controller, but has no capabilities in > the first place. Each request is mapped onto such a resource type > instance (similar as in Cocoon each request is mapped onto a pipeline). > > Now a resource type can become some life by applying some interfaces, > such as for example, viewable, modifiable, etc. > > These interfaces are versioned and the core of Yanel checks the versions > and handles them accordingly. > > Very simple and it works great :-) > > This way you can upgrade at any time without a problem. > > HTH > > Michael >> TIA >> Wolfgang >> >> >> --------------------------------------------------------------------- >> To unsubscribe, e-mail: [email protected] >> For additional commands, e-mail: [email protected] >> >> > > > --------------------------------------------------------------------- > To unsubscribe, e-mail: [email protected] > For additional commands, e-mail: [email protected] > > > --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
