OpenACS: robust web development framework

Author: Rocael Hernández, roc@viaro.net 

Abstract:

 Openacs is a full featured web development framework to create scalable applications oriented to collaboration and online
 communities. Is in use by many big players such as greenpeace.org or the e-learning platform of the MIT Sloan School of
 Business. While the system is not trivial, here are explained some of the most interesting and still relatively simple
 facilities that the framework provides. Everything from templating, separating the code from the presentation, database
 interactions acording to the programming language, autodocumentation features, automated test engine,
 internationalization, and many more are written in TCL, which has shown to be an extremely powerful for writting the
 foundation logic and the application pages. 




What is OpenACS?
=================
 The Open Architecture Community System (OpenACS), is a web development framework that provides a very robust 
 infrastructure to create and / or expand applications.

 The OpenACS set components are: TCL, as the programming language; Database for storing the framework logic, postgres or
 oracle; Webserver, AOLserver; Operating System, Linux or any flavor of unix, also has been tested on windows.

 As some of the already existent web development frameworks in the open source world such as Ruby on Rails or ZOPE,  
 OpenACS  has similar characteristics like: templating for separating the logic from the presentation (MVC),
 internationalization  to present the user interfase on a customizable language, modular package system to create 
 applications, a role and permissioning system, a content repository to store any kind of content and maintain versioning,  etc.

 But from one perspective, among other web development frameworks, OpenACS is still unique, powerfull 
 and simple, and that's based on the programming advantages created within the OpenACS:

Declarative programming
=======================

Declarative programming is understood as the opposite of writting the logic of the program using the normal procedural 
programming, instead use an special declarative syntax to reflect how the program will perform, based on a possible entry, 
but not relied only on that. A side effect of writting in a declarative syntax, is that the programs usually is more 
robust in its behaivor and more readable by other developers, since the declartive syntax is standard and always more 
ordered.

As an example, for web form management, OpenACS has ad_form, this procedure implements a high-level, declarative syntax 
for the generation and handling of HTML forms. It includes special syntax for the handling of forms tied to database 
entries, including the automatic generation and handling of primary keys generated from sequences. You can declare code 
blocks to be executed when the form is submitted, new data is to be added, or existing data modified. You can declare form 
validation blocks, and more. Ilustrative examples will be provided with the full version of this paper.

Also, OpenACS brings a set of functionalities that can be used by any application, such as upgrade logic, web reports, 
application to application communication, workflow functionality, an attribute management system, etc., all of those can 
also be used by the programmer by writting a declarative syntax.

Callbacks
=========

The callbacks are an easy way to call procedures stored in each of the possible installed packages that a given OpenACS 
installation migh have. The objective is to give the core applications to invoke in non-core packages that may or may not 
be installed, but without cluttering core with code that belongs to other packages, making possible to have independence 
among packages.

The architecture work as

-> Core proc for removing user
   -> Invoke callbacks based on what's installed
      -> Package A logic for removing user
      -> Package B logic for removing user
      -> Package C logic for removing user
      ...
   -> Core logic for removing user

as opposed to this architecture

-> Package A proc for removing user
   -> Package A logic for removing user
   -> Call core proc for removing user

-> Package B proc for removing user
   -> Package B logic for removing user
   -> Call core proc for removing user

Callback implementations would be declared like this:

ad_proc -callback module::op -implementation implname  { ... }

Where ad_proc is a wrapper of the normal TCL proc, which mainly gives auto-documentation structure for any procedure.

Core uses tcl introspection to find which callbacks exist and invokes them. eg

foreach proc [info procs ::callback::module::op::impl::*] { 
  $proc $args
}

To invoke a callback you do this

callback [ -catch ] [ -impl impl ] callback [ args... ]

The callbacks is a great improvement in order to keep simple yet separated, coherent and modular a web framework that 
constantly evolves and grows. The larger goal is to promote reuse of standard pages and functions by removing the need to 
create per-package versions of these.

Conclusions
===========

OpenACS is a complete web development framework, which is based on TCL, and uses tools like tdom for xml parsing, 
tclwebtest for creating web test, etc. Also provides a set of functionalities to enhance the web development as mentioned 
in this paper. From that perspective, OpenACS becomes an excellent option to create a web community site of any kind or 
size.