Personal tools
You are here: Home About Components

Components

The Zope community, for years now, has focused on building components. Components are powerful, pluggable building blocks you can use to build your application.

When you use Grok to build an application, all these components are available to you. Here are some components to help you to do a lot of things:

  • auto-generate forms from schemas, with a wide selection of widgets. (zope.formlib, built into Grok. z3c.form is another approach)
  • create vocabularies (for drop-down lists in forms, and other lists in applications) (zc.sourcefactory).
  • application skinning (built into Grok).
  • create part-of-page views, per context object, per view, per area on page, per skin (viewlets). (built into Grok)
  • display data-driven HTML tables (zc.table).
  • integrate with ORMs (Storm, SQLAlchemy).
  • sessions (built into Grok).
  • authentication: basic auth, session-based auth, pluggable user databases supporting LDAP, relational databases, etc. (pluggable authentication architecture built into Grok).
  • authorization: users, groups, per-user/per-object permissions and roles. (buit into Grok).
  • REST, JSON, XMLRPC (built into Grok)
  • WebDAV support. (z3c.dav)
  • declarative Ajax using KSS.
  • i18n, localization of things like date/time, country names, etc. (built into Grok)
  • freezing objects. (zc.freeze)
  • sending, queuing mail. (zope.sendmail)
  • workflow. (hurry.workflow, zope.wfmc)
  • XML-export and import of schema-driven content. (z3c.schema2xml)
  • object indexing and search. (built into Grok, and hurry.query)
  • Lucene, Xapian indexing integration. (z3c.indexing.xapian, z3ext.lucene)
  • relation indexing (zc.relation, z3c.relationfield).
  • making objects appear in multiple places at once in the traversal hierarchy, including generating correct URLs for them and the URLs of sub-objects (zc.shortcut).
  • versioning objects in a version control system (zc.vault).
  • caching, support for protocols like ICP (zope.app.cache, zope.cachedescriptors, lovely.memcached, lovely.responsecache, lovely.viewcache, zc.icp)
  • unit testing, doc testing, functional testing, fake browser doc testing, driving Selenium from browser doc testing, driving a real browser from browser doc testing, and so on. (built into Grok, zc.testbrowser)
  • application flash messages (z3c.flashmessage, built into Grok).
  • an extensible application buildout system that can install a lot more than just Python packages (zc.buildout).

And that's just a grab-bag list. These components offer an integrated experience: they are packaged as eggs, define explicit APIs (using interfaces), and are typically doctested (frequently extensively so).

All these Zope Toolkit components, and many more, can be used with Grok, as Grok uses the same underlying architecture. But with Grok, we consider the existence of a component the half-way-point; now that it's there, we should make it easier. We focus on the developer experience. We do this in three ways:

  • Improve the documentation for the use of individual components. We want to lower the entry barrier by providing straightforward documentation.
  • Continue to work on making individual components more easy to use. By integrating a particular component with Grok and providing sensible defaults, we can make that component more accessible to developers. We are continuously working on this - a task that likely never will end given the creativity and productivity of the Zope Toolkit component developers.
  • Configuration (glueing) of components, for instance glueing a view to a content object, has been harder than it should be with Zope 3. With Grok we introduce a much easier, uniform mechanism to glue things together, in Python code. Since all Zope Toolkit components make use of the same component system, all these components become easier to configure if you use Grok.

We don't claim we can make all complexity go away in software development. If you are going to do hard stuff, you are going to have to try to understand the various Zope Toolkit components you want to do hard stuff with, or build a new one yourself. This is an inescapable fact of software development. What we try to do is push the boundaries of what is actually hard. Zope Toolkit components do this by offering new features and building abstraction layers. With Grok we add easier assembly of components, and pre-assembly.