Selected Institutes Description

About

The Apache Software Foundation exists to provide organizational, legal, and financial support for the Apache open-source software projects. Formerly known as the Apache Group, the Foundation has been incorporated as a membership-based, not-for-profit corporation in order to ensure that the Apache projects continue to exist beyond the participation of individual volunteers, to enable contributions of intellectual property and funds on a sound basis, and to provide a vehicle for limiting legal exposure while participating in open-source software projects.

The Apache Software Foundation is a membership-based, not-for-profit corporation. Individuals who have demonstrated a commitment to collaborative open-source software development, through sustained participation and contributions within the Foundation's projects, are eligible for membership in the ASF. An individual is awarded membership after nomination and approval by a majority of the existing ASF members. Thus, the ASF is governed by the community it most directly serves -- the people collaborating within its projects.

Projects

Two major projects of my interest are:

• XML: The Apache XML Project currently consists of seven sub- projects, each focused on a different aspect of XML:

  • Xerces - XML parsers in Java, C++ (with Perl and COM bindings)

  • Xalan - XSLT stylesheet processors, in Java and C++

  • Cocoon - XML-based web publishing, in Java

  • FOP - XSL formatting objects, in Java

  • Xang - Rapid development of dynamic server pages, in JavaScript

  • SOAP - Simple Object Access Protocol

  • Batik - A Java based toolkit for Scalable Vector Graphics (SVG)

  • Crimson - A Java XML parser derived from the Sun Project X Parser.

• Jakarta: The goal of the Jakarta Project is to provide commercial-quality server solutions based on the Java Platform that are developed in an open and cooperative fashion.

  Jakarta is the "overall" project for many subprojects. For example, Tomcat is the Servlet+JSP Engine which is a subproject of the Jakarta Project. Many people confuse Jakarta and Tomcat together even though the reality is that Jakarta is essentially just the website and Tomcat is a product on the website.

  The list of subprojects related to my research is:

  • Avalon: The Avalon project is an effort to create, design, develop and maintain a common framework and set of components for applications written using the Java language. This framework is not a stand-alone product, but allows existing and yet to be created applications to fit into a common platform and to share code, design and human resources.

  • ECS: The Element Construction Set is a Java API for generating elements for various markup languages it directly supports HTML 4.0 and XML, but can easily be extended to create tags for any markup language.

  • Slide: is a project composed of multiple modules tied together using WebDAV

  • Struts: The goal of this project is to provide an open source framework useful in building web applications with Java Servlet and JavaServer Pages (JSP) technology. Struts encourages application architectures based on the Model-View-Controller (MVC) design paradigm, colloquially known as Model 2 in discussions on various servlet and JSP related mailing lists.

  • Velocity: is a Java-based template engine. It permits anyone to use the simple yet powerful template language to reference objects defined in Java code.

Cocoon

Cocoon is a 100% pure Java publishing framework that relies on new W3C technologies (such as DOM, XML, and XSL) to provide web content.

The Cocoon project aims to change the way web information is created, rendered and served. The new Cocoon paradigm is based on the fact that document content, style and logic are often created by different individuals or working groups. Cocoon aims for a complete separation of the three layers, allowing the three layers to be independently designed, created and managed, reducing management overhead, increasing work reuse and reducing time to market.

Avalon

The Avalon project is an effort to create, design, develop and maintain a common framework and set of components for applications written using the Java language. This framework is not a stand-alone product, but allows existing and yet to be created applications to fit into a common platform and to share code, design and human resources.

There are several distinct sub-projects that together form the Avalon project:

• Framework: Framework provides a specification of design patterns and rules in the form of interfaces. Also provided are default implementations of those interfaces.

  The framework is not a product or an API set or a set of interfaces: it is a collection of code design patterns, rules, guidelines and suggestions on how to write software that "plugs" into the framework. The framework does not impose restrictions on the application that uses it, but rather precious guidelines to help the developers reuse as much work they can from other solutions.

• Excalibur: is a collection of often-needed reusable components. It includes tools for threading, pooling, data-sources, proxies and more.

• Phoenix: is a server orientated Application Server. Applications and Services that conform to the framework rules can be hosted in Phoenix. The Application server manages the applications classloader, security and logging needs. It also provides a JMX-based management facility.

• Cornerstone: is a repository for what we call blocks, which provide services vital to server applications. The blocks include blocks for services such as scheduling and socket management.

ECS

The Element Construction Set is a Java API for generating elements for various markup languages it directly supports HTML 4.0 and XML, but can easily be extended to create tags for any markup language. It is designed and implemented by Stephan Nagy and Jon S. Stevens.

What does it do? The Element Construction Set allows you to use Java Objects to generate markup code. Gone is the need for writing code such as sequence of "println" statements.

Slide

Slide is a project composed of multiple modules tied together using WebDAV (see below for more details about WebDAV).

It includes :

• content management system with a Java API

• servlet implementing the WebDAV protocol on top of the content management system

• Java WebDAV and HTTP client library

• WebDAV command line client

• WebDAV enabled Swing components

The Slide project main module is a Content Management and Integration System, which can be seen as a low-level content management framework. Conceptually, it provides a hierarchical organization of binary content which can be stored into arbitrary, heterogenous, distributed data stores. In addition, Slide integrates security, locking, versioning, as well as many other services.

It can integrate and manage data stored within external repositories, requiring only small abstraction layers to be written for each repository. That way, Slide can integrate the data from various physical locations in a hierarchical and unified way. Slide uses can range from managing intranet application content (such as the Exolab.org portal) to using it as a file server.

Slide also offers a WebDAV access module (implemented as a servlet). WebDAV is an IETF standard endorsed by companies like Microsoft, IBM, Novell, Adobe and many others. It makes Slide an ideal choice for web-based content management. All the data managed by Slide can be accessed through WebDAV, and enable remote administration and manipulation of the data managed by Slide using standard third party tools, along with the custom ones provided in the Slide distribution as additional tools.

Struts

The goal of this project is to provide an open source framework useful in building web applications with Java Servlet and JavaServer Pages (JSP) technology. Struts encourages application architectures based on the Model-View-Controller (MVC) design paradigm, colloquially known as Model 2 in discussions on various servlet and JSP related mailing lists.

Struts includes the following primary areas of functionality:

• A controller servlet that dispatches requests to appropriate Action classes provided by the application developer.

• JSP custom tag libraries, and associated support in the controller servlet, that assists developers in creating interactive form-based applications.

• Utility classes to support XML parsing, automatic population of JavaBeans properties based on the Java reflection APIs, and internationalization of prompts and messages.

Velocity

Velocity is a Java-based template engine. It permits anyone to use the simple yet powerful template language to reference objects defined in Java code.

When Velocity is used for web development, Web designers can work in parallel with Java programmers to develop web sites according to the Model-View-Controller (MVC) model, meaning that web page designers can focus solely on creating a site that looks good, and programmers can focus solely on writing top-notch code. Velocity separates Java code from the web pages, making the web site more maintainable over the long run and providing a viable alternative to Java Server Pages (JSPs) or PHP.

Velocity's capabilities reach well beyond the realm of web sites; for example, it can generate SQL and PostScript and XML (see Anakia for more information on XML transformations) from templates. It can be used either as a stand-alone utility for generating source code and reports, or as an integrated component of other systems. Velocity also provides template services for the Turbine web application framework. Velocity+Turbine provides a template service that will allow web applications to be developed according to a true MVC model.

Ninja

The Ninja project aims to develop a software infrastructure to support the next generation of Internet-based applications. Central to the Ninja approach is the concept of a service, an Internet-accessible application (or set of applications) which is scalable (able to support many thousands of concurrent users), fault-tolerant (able to mask faults in the underlying server hardware), and highly-available (resilient to network and hardware outages). Examples of current and future Ninja services include an Internet stock-trading system; a ``universal inbox'' used to access e-mail, voice mail, pages, and other personal correspondence; and the Ninja Jukebox, which provides real-time streaming audio data served from a collection of music CDs scattered about the network.

In some sense, the current World Wide Web is a service itself; Ninja intends to build upon and expand the notion of Web-based services by providing composability (the ability to automatically aggregate multiple services together into a single entity), customizability (the ability for users to inject code into the system to customize a service's behavior), and accessibility (the ability to access the service from a wide range of devices, including PCs, workstations, cellphones, and Personal Digital Assistants). The end goal of the Ninja project is to enable the development of a menagerie of Internet-based services which are interoperable and immediately accessible across the spectrum of user devices ranging from PCs and workstations to cellphones and Personal Digital Assistants. For example, one should be able to check one's e-mail simply by calling a special number from a cellphone, or equivalently by sitting down at any Internet-connected PC in the world.

The VINO Operating System

Design goals:

Reusability and modularity: We hope to build a system of components that can be assembled into a running system in a manner chosen by the end user. We additionally intend to permit application software to reuse system components, even kernel components. This reduces the amount of code that application developers need to write and makes it possible to have new applications running quickly.

Application-directed kernel policy: We believe that the kernel should provide mechanisms, not policy. Policies should be supplied by the system administrator, application programmer, or even the end user. VINO is designed to make all policies customizable as far down this list as possible, even "internal" policies like filesystem read-ahead. This permits applications to take maximum advantage of kernel services and eliminates the common need to reimplement parts of the kernel in application software.

Universal resource interface: It should not be necessary to use different interfaces to accomplish the same results just because the things being dealt with are different in irrelevant ways. Both the internal kernel interfaces and user-to-kernel interfaces have been designed to reduce duplication as much as possible. This reduces the load on application developers and reduces the need for shelves full of reference manuals.

Jump to no conclusions: The standard designs for operating systems and operating system components have evolved over the past forty years or so and have in many cases become so conventional that nobody even remembers any alternatives any longer. Sometimes this is because a truly optimal solution has been found. Sometimes, however, what was an optimal or at least good solution at some time in the past is no longer good or even halfway passable due to the changing nature of hardware and the changing nature of things people use computers for. In VINO we try to take none of these conventional solutions for granted. Where possible we attempt to develop new designs that handle current requirements better.

World Beyond the Web

Prof. Thomas E. Cheatham is developing the World Beyond the Web, which supplements the web and HTML with

• new information-storage system based on Java objects

• new shell language, which permits computations to be stored and searched for world-wide just like data