Log in
Forgot your password?
Comparison of ACS and Zope
By Kevin Dangoor. Initial Draft: April 18,
2000. Current revision: May 1, 2000
�
This document is a comparison between Zope and the arsDigita
Community System (ACS). It should be considered a work-in-progress, and feedback
on it can be sent to [email protected] . Change history can
be found at the end of this document.
�
It is also worth noting that I did not actually install ACS, which looks to
be a fairly big job if you're not already running Oracle. This information is
based upon my first hand experience with Zope, and what I have read in the ACS
documentation and discussion groups.
�
Finally, this comparison is based upon things that matter to me. Some of
these things might not matter to you.
Introduction
Zope and ACS are quite different in how they approach the
problem of making dynamic websites. Zope includes an object oriented database,
and makes every object available for direct access through the web via a URL.
ACS uses a more traditional relational database platform. Both are Open Source,
though ACS requires the commercial Oracle DB. There is a group called OpenACS
(http://www.openacs.org) that is porting
ACS to PostgreSQL. ArsDigita is providing some support to this group, but
OpenACS will generally lag behind the main ACS code.
Scalability
ACS: ACS is built on top of AOLServer and Oracle. According to
Ars Digita people, AOLServer is used in about 3% of the heaviest trafficked
websites. AOL itself uses AOLServer, Sybase and IRIX as its platform, which
serves up 28,000 hits per second. AOLServer can be extended using a built in TCL
interpreter, and this is how much of ACS is built. The TCL interpreter is thread
safe, so a long, computationally intensive job can run while requests continue
to get processed. Oracle is reportedly used in many of the busiest websites
(Amazon, etc). ACS has a server clustering module which will transparently
maintain state between multiple servers http://www.arsdigita.com/doc/server-cluster.html.
As I understand it, the TCL interpreter is considerably (possibly an order of
magnitude) slower than the Python interpreter. ACS has a fairly complicated
table structure. I'm sure Oracle has some fine-tuned code for handling
complicated queries, but those will doubtless slow dynamic page
generation.
�
Zope: Zope is typically run behind Apache, these days using
FastCGI. Zope is written in Python. Zope and Python are designed for
multithreaded operation, so running requests should not prevent other requests
from getting through. Zope is used in some medium-traffic environments, but no
one has stepped forward as having a truly high traffic site. Benchmarks that
people have run seem to show that an inexpensive server machine with a
moderately dynamic page can probably churn out 1M hits per day, and bigger
hardware should certainly handle more. In May, Zope Enterprise Objects (ZEO)
goes Open Source. ZEO allows you to replicate the Zope Object Database (ZODB)
onto multiple machines, providing a relatively straightforward mechanism for
handling higher volumes of trafffic. Additionally, some maintenance or reporting
tasks could be farmed out to other machines that are not taking production
traffic. Zope's object caching (and SQL query caching for database applications)
can do a lot to improve performance. Additionally, it is my feeling that the
FileSystem Storage probably has a lot less overhead than pulling in data from an
RDBMS over a socket. I do believe that Zope provides many ways to get creative
to handle the load as needed... these ways are just not pre-established and
well-tested.
Other considerations: If we're doing lots of writes to the
ZODB, we will run into issues with the current ZODB implementation.
- Data.fs file will grow dramatically
- Too many simultaneous writes to a single object could lead to ConflictErrors.
- Too many objects in a single ObjectManager will lead to performance degradation
Good application design can get around any of these
issues.
�
Advantage: Tie. AOLServer and Oracle have
proven themselves as scalable systems, whereas Zope is a bit greener. Zope, on
the other hand, provides many not difficult ways to tackle load issues, and ZEO
will provide replication capability to handle major load. I'll call it a tie,
because while the ACS architecture has proven it can handle really large traffic
volumes, I believe Zope provides ways to scale that are less expensive (even
including development time). A part of a Zope site with heavy concurrent write
volume could be problematic for the ZODB, but one could always bring in Oracle
to tackle that then.
Platform
ACS: As previously mentioned, ACS is built on top of Oracle.
Applications are built as a combination of TCL scripts with SQL calls, web pages
with embedded TCL, and a new template system which helps build pages. You store
HTML and image files in your filesystem as you would in a traditional web
setting. The database uses many relational tables to store the "dynamic"
information such as product info, customer records, etc.
�
Zope: In Zope, everything can be stored in the object
database. Zope has the ability to talk to different relational databases, but I
have never used this capability. New developments (Philip Eby's RIPP model and
using ZClasses as Pluggable Brains) allow you to use SQL databases as needed
without the Zope applications being aware that they are not pulling their data
from the ZODB. Everything on the site (web pages, image files, animation files)
can be stored in the object database. Zope's OO model is very pleasant to work
with and overall quite consistent.
�
Advantage: Zope. I could be biased because
I'm more familiar with Zope. I don't think so, however. Once you understand
Zope's workings, it has a very clean model... everything is an object. You don't
have to deal with the conceptual divide caused by having some information in the
database, and some in files on the disk. In fact, you can use RDBMSes as
appropriate and not have to deal with that divide in your apps.
Development Tools
ACS: Because ACS stores its files in a traditional, file
system-based manner, it is easy to use any of the standard programming tools.
You can "grep" through your code to find a specific routine. You can use CVS for
version control. You can use whatever editor you like.
�
Zope: You can develop code for Zope via standard Python
classes in the file system, or through the web. I prefer the through the web
model, because the Python Product model requires you to restart Zope to test
changes to your product. Additionally, when you develop through the web, all of
your programming is the ZODB. That means that your *entire site* is in the
Data.fs file. This is convenient for backup and moving the site from one
installation to another. You can access Zope objects via FTP, though this is
imperfect. FTP access allows people to use Emacs and other FTP capable
editors.
�
Advantage: ACS. I'll give a slight edge to
ACS in this category. Through the web development in Zope is very convenient,
but the standard web browser text editor is not very good. If you're working on
a fairly big project with multiple developers, something like CVS is a big win.
Perhaps if we use Python Products more, we'll be in better shape. With a few
small scripts, we could probably create a decent environment for managing
through-the-web projects using CVS as well. The Zope Mozilla initiative should
also help provide a better environment for developers of through the web
products. I think Zope would have the edge here if you didn't have to restart
Zope to play with your code changes in Python Products.
E-Commerce
ACS: ArsDigita has developed an e-commerce module that does
many of the things that Amazon.com does! Professional and customer reviews, gift
certificates, discounts for certain groups of users, discounts for users with a
coupon code and more. Plus, they have customer service management (an email
handler that makes it easy to track email), and order management. The e-commerce
module does not handle payment by check, but this should be relatively
straightforward to code.
�
Zope: There is a product called EMarket, but it is not fully
featured. We have our own home grown code. This code does, IMHO, a good job of
product display. Zope doesn't (yet) have good, standardized support for
members/users. This is coming very soon, though.
�
Advantage: ACS. There's no comparison in this
category. ACS has great commerce features out of the box.
Personalization
ACS: ACS provides data models and code for keeping track of
things that interest a user, and recognizes the need to be able to correlate
people's browsing and shopping habits. It has a module for tracking customer
relationships over time, allowing you to reward regular customers, or try to get
past customers back.
�
Zope: Zope has a new membership system, called LoginManager.
The current version does not come with the ability to store information about
the user, however. This code is expected within the next week or
two.
�
Advantage: ACS. Again, ACS is the clear
winner because of its prepackaged ability to tackle much of the personalization
problem.
Cost
ACS: A group has been porting ACS to PostgreSQL, a free, Open
Source database. However, this port is not complete, and ArsDigita is not
actively supporting anything but the Oracle ACS. We might be able to
get a system up and running on PostgreSQL, but we would probably want to go with
Oracle longer term. Oracle 8i requires at least 128MB of RAM (I'm sure we would
want more than the minimum) and costs $6,800 as part of an internet development
suite. There may be a cheaper way to get it standalone. As our needs increase,
the Oracle add-ons to handle those needs become quite pricey. Additionally, we
would have to use a dedicated server from the get-go. We can probably expect to
pay about $400/month for a beefy enough dedicated server to handle our
needs.
�
Zope: Everything we need for Zope is free. Zope does not
require as beefy a server, and (until our traffic is high enough) we can
continue to use a shared server.
�
Advantage: Zope. ACS is really tied to Oracle
at this point, and that is a bit of added cost that we wouldn't want right now.
Oracle installations get more and more pricey as you scale up, whereas we can
probably continue to scale Zope with free software. There's really not much of a
comparison in this category.
Localization
ACS: ACS' template system has standardized hooks for using
localized content. I can't find a reference to it at the moment, but I believe
the servers are fine with unicode, as well. A lot of ACS' messages are embedded
in the individual TCL scripts... that is not quite so local language
friendly.
�
Zope: There is a Zope Internationalization Project. I'm not
sure how far along they are, but there appears to be quite a bit of work to do.
I believe the current version of Python does not support strings with two byte
characters.
�
Advantage ACS. Relevancy for us now: None.
ACS is farther along, but people have come up with creative ways to
serve up local content with Zope. It will be a while before we start
aggressively looking to serve up content for other countries, and I think the
solutions will be in place by the time we get there. (I think I've read about
Python 1.6 supporting unicode).
Content Management
ACS: There is a lot of work going on at ArsDigita on the
content management/separation of power in ACS. http://www.arsdigita.com/doc/templating-etc.html
gives an idea of some of the work. Specific info about the templating is here:
http://karl.arsdigita.com/projects/template/doc/
Karl's template system looks to be a decent abstraction and
appears to be available in beta code. All of this work is in addition to the
time-tested templating system http://www.arsdigita.com/doc/style.html
that is very similar to the one in use at AOL today.
�
Zope: Zope has excellent content management tools. Acquisition
allows for easy inclusion of other objects in a page, and DTML is a powerful
template language, especially with its construct. It is very easy to
create new types of documents using ZClasses, and numerous, not very difficult
ways to implement templates such that designers can work on a full-page view
have been suggested. DC desires to make Zope very, very strong in this
area.
�
Advantage: Zope. I think Zope already has a
lead here, and that lead will grow. One thing worth mentioning: by storing
content in individual files on the disk, ACS makes it possible to use tools like
CVS on your content. Currently, Zope provides no built in mechanism to do
something similar.
Ad Management
ACS: ACS includes tools to display, rotate and count banner
ads and click throughs. It supports "ad groups", so that certain ads will be
shown while the user browses certain pages.
�
Zope: Bill has a released a Banner System that provides for
local and remote banners as well as banner weighting and random selection. It
keeps track of its info in the ZODB, so the Data.fs file will grow with each
hit.
�
Advantage: ACS. ACS' ad tools are more
advanced, and the Oracle database will handle the writes better.
Site Search
ACS: Obviously, Oracle will handle basic search tasks just
fine. ACS has created interfaces for serving up "new stuff" regardless of where
in the database it sits. It appears that full-text search is handled through
some Oracle thing called "Intermedia", and that Intermedia is a real beast to
set up (an opinion expressed by people who have already gotten over the learning
curves associated with bringing up Oracle).
�
Zope: ZCatalog is a breeze to use and is quite flexible and
speedy.
�
Advantage: Zope. I love
ZCatalog.
Other Tools
ACS: AOLServer has a built in scheduler to run tasks. ACS has
a "Spam" module for sending out email (even large amounts). Web-based system
monitoring tool http://arsdigita.com/free-tools/cassandrix.html
�
Zope: PTK has been coming along been has recently run into a
personnel issue. I think PTK has too much momentum behind it to really slow
down, however. ZClasses are a way to develop reusable components easily.
Numerous contributed products, but not many that can stand up to the ACS
modules.
�
Advantage: ACS. Lots of modules for doing all
sorts of things... and plenty of extra tools and docs that show that these guys
have definitely put together some big sites.
Replication of Components
ACS: By setting up a separate web root, you can get multiple
sites running on one box, each with its own AOLServer instance. ACS also allows
subdomaining through its user group system, allowing you to use one database for
data from multiple sites.
�
Zope: Zope's object oriented nature is very good for breaking
out components, both in terms of the data and the code. Zope also has existing
capabilities for handling multiple sites gracefully.
�
Advantage: Zope. Zope has only a slight edge
in this area. ACS does provide an easy way to run multiple sites on a single
box. However, Zope applications are built�with objects, so you can subclass
components to add additional features, or build instance customization features
into the components. This provides an easy, consistent interface for
customization from site to site, while allowing you to drop in updates to the
base code as needed.
Conclusion
Zope is the better choice of the two for me. I had good reason for
choosing Zope in the beginning. Though ACS offers many components that Zope does
not (yet) have, Zope's object model provides a platform for much faster
development. Since no canned app will fully do what we need to do, this is a
very important consideration.
�
We do need to be concerned about the scalability of our
application. We have to design it to work well in the Zope environment. Our
particular application may be perfect for taking advantage of Zope's strengths
and playing down its weaknesses.
�
As of this writing, I believe that additional research into
ACS along the way will be useful. ArsDigita's system incorporates many elements
that were clearly gained through hard-won experience. For someone who
is looking for quite a bit of out of the box functionality,
ACS is a clear choice.
Combining the Two?
Someone is working on embedding Python in AOLServer. If it
were possible to embed Zope in AOLServer, then you would have access to Zope
services and TCL-based services like ACS. Is this desirable? I'm not sure. While
it's nice to think of plugging in modules from different systems to get more
functionality, the reality is that ACS and Zope are so very different in
architecture that it might just be painful. We'd probably just end up with the
pain and limitations of both systems, instead of the power of
both.
Changes
5/1/2000 - Updated the "Replication of Components" and "Content Management" sections
based on feedback from Tracy Adams at aD.
8/28/2000 - Updated the conclusion a bit to reflect that Zope is the right choice based upon *my* needs. ACS is the winner for out of the box functionality.