The Prototype JavaScript Framework is a JavaScript framework created by Sam Stephenson which provides an Ajax framework and other utilities. It is implemented as a single file of JavaScript code, usually named prototype.js. Prototype is distributed standalone, but also as part of larger projects, such as Ruby on Rails, script.aculo.us and Rico.

Features

Prototype provides various functions for developing JavaScript applications. The features range from programming shortcuts to major functions for dealing with XMLHttpRequest.

Prototype also provides library functions to support classes and class-based objects, something the JavaScript language does not have. In JavaScript, object creation is prototype-based instead: an object creating function can have a prototype property, and any object assigned to that property will be used as a prototype for the objects created with that function. The Prototype framework is not to be confused with this language feature.

Sample utility functions
The $() function

The dollar function, $(), can be used as shorthand for the getElementById function. To refer to an element in the DOM of an HTML page, the usual function identifying an element is:

document.getElementById(”id_of_element”).style.color = “#ffffff”;

The $() function reduces the code to:

$(”id_of_element”).setStyle({color: ‘#ffffff’});

The $() function can also receives an element as parameter and will return, as in the previous example, a prototype extended object.

var element_js = document.getElementById(”id_of_element”); // usual object reference returned
var element_pt = $(element_js); // prototype extended object reference

Note: Like the underscore (_), the $ character is a legal “word character” in JavaScript identifiers, and has no other significance in the language. It was added to the language at the same time as support for regular expressions, so that the Perl-like matching variables could be emulated, such as $` and $’.

The $F() function

Building on the $() function: the $F() function returns the value of the requested form element. For a ‘text’ input, the function will return the data contained in the element. For a ’select’ input element, the function will return the currently selected value.

$F(”id_of_input_element”)

The $$() function

The dollar dollar function is Prototype’s CSS Selector Engine. It returns all matching elements, following the same rules as a selector in a CSS stylesheet. For example, if you want to get all tags with the class “pulsate”, you would use the following:

var url = “http://www.example.com/path/server_script”;

var myAjax = new Ajax.Request(url, {
parameters: {
value1: $F(”name_of_id_1″),
value2: $F(”name_of_id_2″)
},
onSuccess: showResponse,
onFailure: showError
});

Object-oriented programming

Prototype also adds support for more traditional object-oriented programming. The Class.create() method is used to create a new class. A class is then assigned a prototype which acts as a blueprint for instances of the class.

var FirstClass = Class.create( {
// The initialize method serves as a constructor
initialize: function () {
this.data = “Hello World”;
}
});

Extending another class:

Ajax.Request= Class.create( Ajax.Base, {
//Overwrite the initialize method
initialize: function(url, options) {
this.transport = Ajax.getTransport();
this.setOptions(options);
this.request(url);
},
// …more methods add …
});

The framework function Object.extend(dest, src) takes two objects as parameters and copies the properties of the second object to the first one simulating inheritance. The combined object is also returned as a result from the function. As in the example above, the first parameter usually creates the base object, while the second is an anonymous object used solely for defining additional properties. The entire sub-class declaration happens within the parentheses of the function call.

Source

Prototype JavaScript Framework is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

Sitemap

The sitemap is at the core of Cocoon. It’s here that the web site developer configures the different Cocoon components, and defines the Client/Server interactions in what Cocoon refers to as the Pipelines.

Components

The components within Cocoon are grouped by function.

Matchers

Matchers are used to match user requests such as URLs or cookies against wildcard or regular expression patterns. Each user request is tested against matchers in the sitemap until a match is made. It is within a matcher that the response to a particular request is specified.

Generators

Generators create a stream of data for further processing. This stream can be generated from an existing XML document or there are generators that can create XML from scratch to represent something on the server, such as a directory structure or image data.

XSP Pages

One type of generator is an XML Server Page (XSP page ), an XML document containing tag-based directives that specify how to generate dynamic content at request time. Upon Cocoon processing, these directives are replaced by generated content so that the resulting, augmented XML document can be subject to further processing (typically an XSLT transformation). XSP pages are transformed into Cocoon producers, typically as Java classes, though any scripting language for which a Java-based processor exists could also be used.

Directives can be either built-in (”XSP”) or user-defined processing tags, both of which are defined in logicsheets. Tags are defined using XSLT templates that describe how the tags (represented as XML nodes) are transformed into other XML nodes or into procedural code such as Java. The tags are used to embed procedural logic, substitute expressions, retrieve information from the web server environment, and other operations.

Note that XSP is deprecated in recent releases of Cocoon.

Transformers

Transformers take a stream of data and change it in some way. The most common transformations are performed with XSLT to change one xml format into another. But there are also transformers that take other forms of data (SQL commands for example).

Serializers

A serializer turns an XML event stream into a sequence of bytes (such as HTML) that can be returned to the client. There are serializers that allow you to send the data in many different formats including HTML, XHTML, PDF, RTF, SVG, WML and plain text, for example.

Selectors

Selectors offer the same capabilities as a switch statement. They are able to select particular elements of a request and choose the correct pipeline part to use.

Views

Views are mainly used for testing. A view is an exit point in a pipeline. You can put out the XML-Stream which is produced till this point. So you can see if the application is working right.

Readers

Publish content without parsing it (no XML processing). Used for images and such.

Actions

Actions are Java classes that execute some business logic or manage new content production.

The Pipeline

A pipeline is used to specify how the different Cocoon components interact with a given request to produce a response. A typical pipeline consists of a generator, followed by zero or more transformers, and finally a serializer.

See also XProc models and standardization.

Source

Apache Cocoon is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

A set of APIs for representing user interface (UI) components and managing their state, handling events and input validation, converting values, defining page navigation, and supporting internationalization and accessibilityA default set of UI componentsTwo JavaServer Pages (JSP) custom tag libraries for expressing a JavaServer Faces interface within a JSP page.A server-side event modelState managementManaged Beans (JavaBeans created with dependency injection)Unified Expression Language for both JSP 2.0 and JSF 1.2

The JSF specification was developed under the Java Community Process as JSR 127, which defined JSF 1.0 and 1.1, and JSR 252 which defined JSF 1.2. Upcoming JSF 2.0 is being developed as JSR 314.

JSF Versions

JSF 1.0 (2004-03-11) — the initial release of the JSF specification.JSF 1.1 (2004-05-27) — bug fix release. There were no spec or HTML renderkit changes.JSF 1.2 (2006-05-11) — latest release.provide XML Schema for the config files, instead of using DTDenhancements to allow faces applications to handle multi-frame, or multi-window UI designsenhancements to the f: tag library for improved TCK coverage, f:view lifetime events, and other small featuresenhancements to the decorator support for API objectssecurity enhancements for client side state savingsolve the “duplicate button press” problem (pressing a button twice to cause 2 submissions)re-organize the spec into normative, and non-normative sections, to make implementation easierportlet related bug-fixesbug fixes that require minimal specification changesJSF 2.0 (expected in 2009) - major revision of the specification under development. Planned to coincide with Java EE 6.

JSF and Ajax

JSF is often mentioned together with Ajax, a Rich Internet application technology. Ajax is a combination of technologies that makes it possible to create richer user interfaces. The user interface components in Mojarra (the JSF reference implementation) and MyFaces were originally developed in HTML. Because JSF supports multiple output formats, Ajax-enabled components can easily be added to enrich JSF-based user interfaces. The JSF 2.0 specification intends to improve support for Ajax by allowing UI logic to run partly on the client and not only on the server, and by providing support for graceful degradation when JavaScript is disabled in the browser.

Ajax-enabled JSF components and frameworks

The following companies and projects offer Ajax-based JSF implementations or blueprints or component libraries:

Oracle ADF Faces Rich Client, Oracle Application Development FrameworkBackbase Enterprise Ajax — JSF Edition, Ajax frameworkICEfaces, open-source, Java JSF extension framework and rich components, Ajax without JavaScriptjBoss RichFaces and Ajax4jsf, Ajax-enabled JSF ComponentsMyFaces, JSF Implementation with Ajax ComponentsSun Java BluePrints AJAX ComponentsZK Ajax framework with JSF componentsPrimeFacesOpenFaces Ajax-powered JSF components, an Ajax framework and a client-side validation frameworkMojarra Scales

Comparison to other Web-GUI Frameworks

Struts

Struts is a popular MVC framework from the Apache Software Foundation. It provides page-at-a-time MVC and does not have a component model in the style of JSF. Pages are mapped to models with a dispatch servlet (controller) piping input to actions. Struts applications use JSPs to render views and are amenable to mix-and-match jsp taglib use. (See also Apache Beehive)

WebObjects / Wotonomy

WebObjects is an early web-application framework that was originally developed by NeXT Software, Inc. then acquired by Apple Computer when it acquired NeXT. It contains an MVC architecture with a component and event model and lifecycle similar to JSF. It is deployable without J2EE (its original configuration), or can be deployed in a servlet container — its dispatcher object acting as the entry-point of a J2EE web application. Unlike JSF’s default case, components are not defined in JSP files but are in .wo directories containing any or all of html/xml/wml template files, a .wod file to map fields and actions to Java code, and a .java class. A template file provides the rendering/layout and may include other WebObjects components, rather than the delegated RenderKit approach used by default in JSF. It is a halfway-point between the delegated and directly-rendered approaches used in JSF.

WebObjects also includes a layered architecture with one of the earliest Object-Relational Mapping frameworks, Enterprise Objects Framework.

Wotonomy is a clean-room, open-source re-implementation of the WebObjects frameworks licensed under LGPL. It attempts to implement all parts of WebObjects, and has implemented the whole MVC web-GUI stack. As a clone of WebObjects, it differs from JSF in identical ways, except where it is incomplete.

Apache Tapestry

Tapestry is an open-source framework for creating dynamic, robust, scalable web applications in Java. Tapestry builds upon the standard Java Servlet API, and so it works in any servlet container or application server. Unlike JSF, Tapestry does not use JSP as the default view technology — instead preferring an alternate templating engine that allows for easy HTML preview and editing (similar to the JSF-based Facelets).

Microsoft ASP.NET

The JSF request/response life cycle was initially designed for JSP compatibility, so renders before the object graph has been built on initial page load. This means that JSF cannot handle Get requests. ASP.Net has always built an object model before performing rendering, and thus does not have this and related complications.

JSF features a component based approach to WebApplication development similar to ASP.NET from Microsoft. In ASP.NET v1, component rendering code was bundled with the UI component, unlike JSF, where rendering and component interfaces can be separated, thus allowing for customization of the renderer. ASP.NET v2 introduced the control adapter framework allowing the default rendering to be overridden by third-party code.

Business code is connected to the UI components by subscribing to events generated by the components and stored in a separate file (”code behind”). Thus a typical ASP.NET page consists of a (HTML) file describing the visual page layout (design), and a file with the page logic (code). Both files are treated as one single entity by Visual Studio.

According to the author of the book Core JSF, JSF offers a means for Java to compete with ASP.Net/Visual Studio in the area of Rapid application development (RAD).

Latest Developments

In the latest still unreleased public draft for JEE6, Facelets (which was designed specifically for Java Server Faces) will be adopted as the official view technology for JSF 2.0. This will eliminate the well-known life-cycle conflicts that existed with JSP forcing workarounds by Java developers. Facelets will also allow easier tag creation using markup instead of Java code, the chief complaint against JSF.

The new JSF developments will also see the usage of Java EE5 style annotations such as @ManagedBean and @ManagedProperty which will lead to a reduction in the size of the faces-config.xml config file. However, navigation still needs to be done in the configuration file.

There will also be changes to the JSF lifecycle to account for AJAX which will make AJAX development using JSF feel more natural.

The latest JSF release will also have built-in capability to handle resources like images, CSS and Javascript and refer to them using logical names and also grouping resources into libraries and versioning.

JSF 2.0 also includes a number of other changes like adding support for events, RAILS_ENV style development stages and significantly expanding the standard set of components.

Popular Extensions and Libraries

• Apache Trinidad (Robust component library)
• ICEFaces (Component library and AJAX framework)
• OcpSoft PrettyFaces (Bookmarkable URLs, Url Rewriting, and Page-load actions)
• Exadel Fiji (Flex-based Charts and Graphs)
• Spring Framework Integration (Dependency Injection Extensions)

Source

JavaServer Faces is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

History

Orinoco Framework was conceived in early 2007 by Ryan Yonzon and released as open source in August 2008. Orinoco Framework was then a part of an internal development in developing small and medium scale websites and web applications but then extracted for general purpose MVC web framework and later released as an open source project.

Features

Very lightweight.Full-stack framework (Model, View and Controller).Integrated Object-relational mapping (ORM).Supports multiple table join.Clean and Elegant URL scheme.Pure PHP configuration.Customizable route and URLs.Can work with various AJAX libraries.

Technical overview

Like any other web frameworks, Orinoco Framework follows and encourages the use of the Model-View-Controller architectural pattern. But unlike other frameworks, it doesn’t provide any generators for auto constructing skeletal PHP modules or templates (such as scaffolding, CRUD UI, login system, etc.). But it provides an easy to configure PHP config files (database connection, route and application specific configs).

Orinoco Framework provides a full-stack solution for developers by integrating ORM modules and CRUD functionalities.

Orinoco Framework relies on Apache server to run and MySQL for its RDMS (future release will include support for SQLite, PostgreSQL and other open source RDMS). It is also tested to work with JQuery, Prototype and Script.aculo.us for Ajax.

Source

Orinoco Framework is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

History

CakePHP started in 2005, when Ruby on Rails was gaining popularity. The community has since grown and spawned several sub-projects. CakePHP is not a port of Ruby on Rails to PHP, but appropriates many of its useful concepts.

Features of CakePHP

Like Rails, CakePHP makes it easier for the user to interface with the database with the Active record pattern. It also encourages use of the model-view-controller architectural pattern. It’s features include:

• Compatible with versions 4 and 5 of PHP
• Integrated CRUD for datasource interaction
• Application scaffolding
• MVC architecture
• Built-in validation, Data sanitization, and Internationalization and localization
• Various Behaviors, Components and Helpers to minimize development time
• Unit testing using the SimpleTest framework, available in CakePHP version 1.2

Console Applications

CakePHP offers a CLI accessed by the “cake” command. There are several core console applications available in the library, among them:

“acl” for the management of Access Control Lists”bake” for the generation of models, controllers and views”i18n” for application internationalization”schema” for database schema creation and migration.”testsuite” for running unit tests

Developers can also create their own “shells” and shared functionality across these shells called “tasks” (in CakePHP’s parlance). The scripts have access to the application’s models and controllers. An example use-case for this would be the scheduled update of the application’s data from an RSS or other data feed, with the full power of the application logic and data relationships created with CakePHP.

Source

CakePHP is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

Zenphoto is an online photo gallery application designed to be “a simpler web photo album.” It includes dynamic image processing, folder-based albums, editable titles and descriptions powered by AJAX, comments, themes, online uploads, and simple image management.

History

Zenphoto was started from scratch by Tristan Harward in May 2005 after several articles were posted on weblogs citing the need for a better solution than those already existing. Development of the first version moved swiftly and was driven by user comments on Harward’s weblog at trisweb.com. The first available version was 0.8, released on September 15, 2005.

Zenphoto is now a team based application including many active developers. The team released the first major ZenPhoto upgrade in 8 months on November 3, 2007, version 1.1.

Technical description

One of zenphoto’s most unusual features is the image processor, which routes all image requests through a single dynamic program. Based on the parameters given, the image processor resizes and crops the image and returns the result. This results in the ability to request any permutation of an image within a theme or web page.

In general, Zenphoto uses a technical philosophy of simplicity and efficiency. Data are not retrieved until requested (lazy evaluation) and algorithms are optimized to be fast for their intended purpose.

Source

Zenphoto is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

History

FUSE was developed in response to the need for a powerful but simple framework for PHP that included concepts from the increasingly popular MVC framework Ruby on Rails. FUSE endeavors to be adaptable and scalable while still providing minimal barrier of entry for PHP developers looking for an introduction to MVC development.

Features

• Object Relational Mapping / ActiveRecordFully featured templating systemBuiltin
• User object with granular ACL capabilities
• URI Router removes the need for ugly URIs and often eliminates the need for query strings
• Database abstraction layer (FuseDB) allows for portability among different database systems
• FuseBRIJ object allows PHP functions to be executed directly from Javascript, providing AJAX functionality
• Photo Album object allows simple management of photos alongside data
• Configuration manager for easily deploying separate environments (development, staging, production)

Source

Fuse Framework is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

The TinyWebGallery (TWG) is a photo album / gallery released under the Open Source license GPL. It is a server based gallery script for images which uses Ajax, PHP, XML and the graphic library Gdlib / ImageMagick.

History

TinyWebGallery is written by Michael Dempfle and was first released on the 24th February 2005. It is based on a small image script that was developed from Rainer Hungershausen and Mogh. In April 2006 the project moved to the current domain and is right now listed as 3rd most popular php script on hotscripts.com.

Currently the project is developed by Michael Dempfle and supported by ~40 translators and an active community.

The TinyWebGallery has also released a standalone version of Flash Uploader on the 15th August 2006 as ‘TWG Flash Uploader’. This uploader is also available as Joomla component since the 1st August 2007 for Joomla 1.0.x and 1.5.x.

The latest current release version is 1.7.7.2 (15th May 2009).

Overview

The user interface offers different Ajax and Html modes and can be customized by skins or an integrated color manager. The image gallery can be configured by an administration area and it is possible to customize each individual album by text files. Files can be upload with the integrated freeware TWG Flash Uploader.

TinyWebGallery includes the follow features

* Ajax + Flash navigation with sliding thumbnails
* XML based - no database needed
* Password protected administration area
* User and rights management
* Keyboard navigation (arrow keys)
* Rate, comments, counter functionality
* 4 different slideshow types
* Protected galleries
* Supported image formats JPG, GIF, PNG
* Text and image watermarks
* Video/Audio support like avi, mov, mp3, mpg, swf, Videos from Youtube and Myvideo
* Upload by TWG Flash Uploader or FTP
* Fullscreen mode
* Remote picture support
* Display of IPTC and Exif data of the images
* Multilingualism

Source

TinyWebGallery is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

Symfony should not be confused with Symphony CMS, the Open Source XML/XSLT content management system.

Goal

Symfony aims to speed up the creation and maintenance of web applications and to replace repetitive coding tasks. It requires a few prerequisites for installation: Unix, Linux, Mac OS or Microsoft Windows with a web server and PHP 5 installed. It is currently compatible with the following Object-relational mappings: Propel and Doctrine.

Symfony has low performance overheads when dealing with an environment that supports a PHP accelerator. It should be noted however, that in typical shared hosting environments where a PHP accelerator is not available, Symfony suffers from a relatively high performance overhead.

Symfony is aimed at building robust applications in an enterprise context, and aims to give developers full control over the configuration: from the directory structure to the foreign libraries, almost everything can be customized. To match enterprise development guidelines, Symfony is bundled with additional tools to help developers test, debug and document projects.

Technical

Symfony makes use of many common and well understood enterprise design patterns, such as Model-View-Controller. Symfony was heavily inspired by other Web Application Frameworks such as Ruby On Rails.

Symfony makes heavy use of existing PHP open source projects as part of the framework, such as:

Propel or Doctrine, as Object Relational Mapping layerCreole, Database abstraction layer (v 1.0 and 1.1, with Propel)PDO Database abstraction layer (1.1, with Doctrine and Propel 1.3)PRADO, an event-driven PHP web application framework, for Internationalization supportSpyc, a YAML parser (v 1.2)Pake, command-line helper (v 1.0)

It also includes a number of Open Source Javascript frameworks and libraries:

Prototype or jQuery, as javascript framework (v 1.0 and 1.1)script.aculo.us, for visual effects (v 1.0 and 1.1)Dynarch.com, for the DHTML Calendar (v 1.0 and 1.1)TinyMCE, for Rich Text Editing (v 1.0)FCKeditor, for Rich Text EditingTCPDF library for generating PDF documents

As of Symfony release 1.2, no Javascript framework is selected as the default, leaving inclusion and implementation of a Javascript library to the developers.

Sponsors

Symfony is sponsored by Sensio, a French web agency. The first name was Sensio Framework, and all classes were prefixed with sf. Later on when it was decided to launch it as open source framework, the brainstorming resulted in the name Symfony, the name which depicts the theme and class name prefixes.

Real-world usage

Symfony is used by the open-source Q&A service Askeet and many more applications, including Delicious and the 20 million users of Yahoo! Bookmarks. As of February 2009, Dailymotion has ported part of its code to use Symfony, and is continuing the transition.

Development Roadmap

The upcoming new release version of Symfony will include new features such as:

• A new form generation framework, first introduced in version 1.2
• A new admin generator (referred to as scaffolding in Rails) which makes use of the new form framework’ and is no longer implemented as a helper.
• Object relationship mapping declared in a separate plugin, rather than being integrated into the ORM
• Choice of ORM (Doctrine or Propel, or a combination of the two)
• Classes re-factored for looser coupling between objects, allowing for more user flexibility in using objects and fewer dependencies (similar in principle to the Zend Framework).
• Routing rules and route objects more closely follow REST design principals.

Source

Symfony is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.

Piwigo (formerly PhpWebGallery) is a web standards compliant photo-gallery licensed under the GPL. It is written in PHP and utilizes a MySQL database.

History

PhpWebGallery was originally written by Pierrick Le Gall as a personal project, unaware that other projects like it existed. On April 15, 2002, the first version of PhpWebGallery was released.

In order to allow non-programmers to use PhpWebGallery, the software was restructured, this time utilizing templates. This allowed users to change the look of the gallery with only HTML and CSS.

Later versions allowed for images to be stored in any arbitrary location as well as any arbitrary category. The latter was eventually dubbed a “virtual category”).

Creator Pierrick Le Gall announced the pending name change from PhpWebGallery to Piwigo on his personal website on September 24, 2008. The stated reasons for the change in name were:

* shorter : easier to remind
* unique : a search engine request on “Piwigo” will bring you to the Piwigo project pages
* no PHP in the name : I now find it odd to make the technology obvious in the application name
* keeps the PWG letters

Today, Piwigo is supported by 14 developers and a thriving community.

Main Features

Virtual categories
Each image is bound to one or more virtual categories. By associating images to multiple virtual categories, albums can be displayed in multiple, arbitrary groupings depending on the target audience.

Templates
The appearance of the photo album is defined from a template. There are various templates provided by the development community.

Navigation
Users are able to navigate using five different modes: category, date (using a calendar), recent images, and tags.

Access control
Access control is handled by the user manager, restricting and granting varying levels of access to images and albums.

Notification system
Users can be alerted of changes and updates through RSS feeds and E-mail

Plugins
Plugins expand capabilities of PhpWebGallery. Plugins exist that integrate Google Video, Dailymotion, YouTube, Google Maps, Google Earth, as well as implementing a Sitemap.

Other features are listed on the project’s homepage.

Source

Piwigo is posted on Content Management Systems Blog.
Please read our reviews on Joomla books and Drupal Books.