• WebApplicationFrameworks

Web application framework notes

This page collects links and notes for tools and frameworks to construct web applications.

Contents:

1. Traditional Java frameworks and components

• http://tomcat.apache.org/: Apache Tomcat - Web application server and JSP templating.

• http://struts.apache.org/: Struts - MVC framework for web applications.

• http://www.jboss.com/products/jbossas: JBoss application server; application server with focus on J2EE.

• http://www.springframework.org/: Spring "full-stack Java/J2EE application framework". Uses "dependency injection" [1] to make it easier to construct web applications using POJO [2] code.

(And many other packages, some commercial, including WebSphere, WebLogic, JavaServer Faces, ... )

2. Rapid web application development

This list is far from complete; it consists of frameworks I've given (barely) more than passing consideration for performing rapid web application development, and notes features that I felt were significant -- GrahamKlyne

• http://www.rubyonrails.org/: Ruby and Rails. A "full-stack" framework using the Ruby language; lightweight to use; focuses on web-front-ending relational databases (but I think alternative model components could be integrated with some learning and development effort). A pervading mantra for developers is "Don't Repeat Yourself" (DRY). Compared with some other frameworks I've looked at, the Model-View-Controller (MVC) framework in Rails is quite tightly coupled to the Object-Relational Mapper component.

• http://www.zope.org/: Zope: A web framework that focuses somewhat on content management. Currently undergoing a major redesign (Zope 2 to Zope 3); version 3 focuses more on the core framework, but developer documentation is patchy. Not as lightweight to use as Rails or the Python alternatives noted below.

• http://www.webwareforpython.org/: Webware for Python; a comprehensive framework with a high Google ranking and a well-presented web site, but not obviously having an active, broadly-based user community.

• http://www.cherrypy.org/: CherryPy, a very light web application framework for Python. Very quick to use, maps Python objects into web site URI structure. Does not include templating or other components but can be used with other packages (see also TurboGears below)

• http://www.cheetahtemplate.org/: Cheetah - Python templating engine.

• http://kid.lesscode.org/: Kid - Python templating framework used by Turbogears. Very Python-esque in style and works neatly with Python ideas; templates are compiled to Python byte-codes, and can embed Python expressions (like Java in Java Server Pages) - but in practice, this isn't recommended and doesn't seem to be required.

• http://www.mochikit.com/: MochiKit - Javascript library for the browser-side element of Ajax programming. Also used as part of the TurboGears package. Incorporates the "deferred" class idea from Twisted, and makes extensive use of functional programming idioms which work particularly well when manipulating displayed DOM models. An interesting illustration of Javascript capabilities supporting elegant forms of program expression.

• http://www.turbogears.org/: TurboGears - a "full-stack" web application framework for Python. Uses CherryPy, Kid and MochiKit, with SQLObject providing a pythonic interface to relational database back-ends. One advantage of this approach is that the interface between the MVC 'controller' and 'model' is out in the open, making it very much easier to use a non-relational-databse back end for the model part of an application.

• http://twistedmatrix.com/ Twisted - an event-driven networking framework written in Python. A central idea is the "deferred" class which provides a uniform framework for handling asynchronous procedure completion.

See also:

• http://wiki.python.org/moin/WebProgramming

• http://pyre.third-bit.com/pyweb/index.html

• http://www.groovie.org/articles/2005/10/13/python-web-framework-niches - some debate about the variety of frameworks for Python.

2.1. Lightweight framework comparisons

2.1.1. Python/TurboGears and Ruby/Rails

• http://wildmanshore.blogspot.com/2006/01/turbogears-vs-rails.html - Makes a point which was one of my own reasons for choosing Turbogears: "RoR does make for more readable code. However, there is a caveat: when things go wrong, or when you want to do something different, it's a lot more work..."

• http://blog.curthibbs.us/articles/2006/01/20/turbogears-vs-ruby-on-rails

2.1.2. Python frameworks

• http://groups.google.com/group/turbogears/browse_frm/thread/7e23ff3e32ab9147/06648a43241453bb - a comparison of two Python application frameworks, Django and TurboGears (with a passing nod to Rails).

2.2. Notes from using specific frameworks

• TurboGearsWithSqlite - some additional notes for setting up and working through the TurboGears tutorial.

3. Continuation-based web application framework links

(Acknowledgement: the initial list is copied here from a posting by Alistair Bayley to the Haskell-cafe discussion list.)

• http://cocoon.apache.org/ - Cocoon (Java + Javascript)

• http://borges.rubyforge.org/ - Borges (Ruby)

• http://www.ntecs.de/blog/Wee - Wee (Ruby)

• http://www.informatik.uni-freiburg.de/~thiemann/haskell/WASH/ - WASH (Haskell)

• http://www.seaside.st/ - Seaside (Smalltalk)

• http://www.plt-scheme.org/ - PLT Scheme (Scheme) (can't find the actual library)

• http://siscweb.sourceforge.net/ - Siscweb (Scheme)

• http://common-lisp.net/project/ucw/ - Uncommon Web (Common Lisp)

• http://rifers.org - Rife (Java)

One of the first people (but not the only, I think) to recognise that continuations were a good way of modelling web interations was Christian Queinnec:

• http://www-spi.lip6.fr/~queinnec/PDF/www.pdf

• http://www-spi.lip6.fr/~queinnec/Papers/webcont.ps.gz

Probably the best-known such framework is Seaside (ironic, as Smalltalk doesn't natively support continuations, AFAIK):

• http://www.seaside.st/

Phil Wadler is also doing something along these lines in Links, I believe:

• http://homepages.inf.ed.ac.uk/wadler/links/

Excellent summary of problems with REST and continuations (Dave Roberts):

• http://www.findinglisp.com/blog/2004/11/web-application-design-rest-of-story.html

IBM article, mainly about Cocoon - a Java + Javascript framework:

• http://www-128.ibm.com/developerworks/java/library/j-contin.html

More hype:

• http://phirate.exorsus.net/wiki/doku.php?id=web_development_in_2005

• http://phirate.exorsus.net/wiki/doku.php?id=further_discussion_of_continuations_and_sessions

• http://phirate.exorsus.net/wiki/doku.php?id=sessions_and_state

Bill Clementson's postings (he's a Lisper):

• http://bc.tech.coop/blog/041229.html

4. Other references and links

1. Dependency Injection is a design pattern in which linkage between software components is managed by framework code outside those components, rather than by the components themselves. See also: http://en.wikipedia.org/wiki/Dependency_injection, http://www.theserverside.com/articles/article.tss?l=IOCBeginners, http://www.martinfowler.com/articles/injection.html.

2. POJO: Plain Old Java Object. See also: http://www.martinfowler.com/bliki/POJO.html, http://www.onjava.com/pub/a/onjava/2005/06/29/spring-ejb3.html

---

-- GrahamKlyne 2006-07-25 15:10:17

The content of this wiki is licensed under the Creative Commons Attribution-ShareAlike 2.0 England & Wales Licence.

OSS Watch is funded by the Joint Information Systems Committee (JISC) and is situated within the Research Technologies Service (RTS) of the University of Oxford.