<html>

<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" href="../default_style.css" type="text/css">
<title>Eclipse Web Tools Platform Project Charter</title>
<style type="text/css"></style>
</head>

<body text="#000000" bgcolor="#ffffff" link="#0000ee" vlink="#551a8b" alink="#ff0000">
<table BORDER=0 CELLSPACING=5 CELLPADDING=2 WIDTH="100%" >
  <tr> 
    <td ALIGN=LEFT VALIGN=TOP COLSPAN="2" BGCOLOR="#0080C0"><b>
    <font face="Arial,Helvetica" color="#FFFFFF">Eclipse Web Tools Platform 
    Project Charter - v1.7</font></b></td>
  </tr>
  <tr> 
    <td> 
    <b>Overview</b><br>
    The Eclipse Web Tools Platform Top-Level Project is an open source 
    collaborative software development project dedicated to providing a generic, 
    extensible, standards-based tool platform for producing Web-centric 
    technologies.
    <p>This document describes the composition and organization of the project, 
    roles and responsibilities of the participants, and development process for 
    the project. </p>
    <p><b>Mission</b><br>
    The mission of the Web Tools Platform Project is to build useful tools and a 
    generic, extensible, standards-based tool platform upon which software 
    providers can create specialized, differentiated offerings for producing 
    Web-enabled applications. </p>
    <p><b>Scope</b><br>
    The Web Tools Platform Project encompasses a common foundation of frameworks 
    and services for Web tooling products. The project scope also includes Web 
    tooling products themselves for exemplary purposes and/or to validate the 
    underlying platform.<br>
    <img border="0" src="images/subprojects.gif"></p>
    <p></p>
    <p>The project will be further limited to providing infrastructure for 
    tooling proper, in contrast to infrastructure related to the application 
    run-time. We will typically use a simple litmus test to set the boundary 
    between tooling and run-time. Application artifacts, once developed, have no 
    execution dependencies on the relevant tooling framework, while the converse 
    would be true for run-time frameworks. In keeping with our objective of 
    maximizing vendor-neutrality, where multiple frameworks exist in the market 
    for a given functional domain, we will develop tooling based on a common 
    abstraction (or superset) to the extent feasible. </p>
    <p>The ultimate objective of the project is to provide highly reusable and 
    extensible tooling that allows developers to produce applications with 
    increasing development efficiency. The tooling foundation the project will 
    deliver will support these values by enforcing appropriate separations of 
    concern in application architecture, raising the level of technical 
    abstraction in application development and enabling repeatability in 
    development processes. These values, however, will be achieved incrementally 
    over time. Early deliverables will focus on an extensible foundation 
    supporting the most widely used Web and Java standards and technologies. </p>
    <p>In addition, we expect the Web Tools Platform Project to produce 
    functional requirements that are more appropriately satisfied through the 
    Eclipse Project or other Eclipse foundational projects. Areas in which we 
    might expect to see these elaborated requirements would be in working with 
    components, or supporting complex project layouts. In such case, the Web 
    Tools Platform Project PMC will coordinate the corresponding Project PMCs 
    the design and implementation of the corresponding contribution. </p>
    <p>The project initially has two projects: Web Standard Tools and J2EE 
    Standard Tools. These two projects will focus on infrastructure for tools 
    used to build applications for standards-based Web and Java runtime 
    environments. Outside the scope of the project is support for 
    vendor-specific application architectures, such as ASP.Net and ColdFusion, 
    and Java extensions not backed by the JCP.
    Additional projects will be created as per the then-current Eclipse
    Development Process within the overall Scope where resources and interest
    allow.
    </p>
    <p><i>Web Standard Tools</i><br>
    The Web Standard Tools project aims to provide common infrastructure 
    available to any Eclipse-based development environment targeting multi-tier 
    Web-enabled applications. Within scope will be tools for the development of 
    three-tier (presentation, business logic, and data) and server publication of 
    corresponding system artifacts. Outside of scope will be tools for Java 
    language or Web framework specific technology, which will be left to other 
    projects like the J2EE Standard Tools project. Tools provided will include 
    editors, validators and document generators for artifacts developed in a 
    wide range of standard languages (for example, HTML, CSS, Web services, etc.)
    Supporting infrastructure will likely comprise a 
    specialized workbench supporting actions such as publish, run, start and 
    stop of Web application code across target server environments. Web 
    artifacts will be first class citizens with respect to the capabilities that 
    Eclipse users expect. </p>
    <p>The Web Standard Tools Project includes server tools which extend the 
    Eclipse platform with servers as first-class execution environments. Server 
    tools provide an extension point for generic servers to be added to the 
    workspace, and to be configured and controlled. For example, generic servers 
    may be assigned port numbers, and may be started and stopped. The Web 
    Standard Tools Project will define an extension for Web servers, which 
    builds on the generic server extension point, and will include exemplary 
    adapters for popular commercial and Open Source Web servers, e.g. the Apache 
    Web Server. Server vendors are encouraged to develop adapters for their Web 
    servers. The Web Standard Tool Project will also include a TCP/IP Monitor 
    server for debugging HTTP traffic, especially SOAP messages generated by Web 
    Services. The generic server extension point is intended to be used for 
    other types of server, for example J2EE application servers and databases, 
    but these are outside the scope of the Web Standard Tools project. </p>
    <p><i>J2EE Standard Tools</i><br>
    The initial scope of the J2EE Standard Tools project will be to provide a 
    basic Eclipse plug-in for developing applications based on standards-based 
    application servers, as well as a generic tooling infrastructure for other 
    Eclipse-based development products. Within scope will be a workbench 
    providing a framework for developing, deploying, testing and debugging J2EE 
    applications on JCP-compliant server environments, as well as an exemplary 
    implementation of a plug-in for at least one JSR-88 compliant J2EE Server. 
    Included will be a range of tools simplifying development with J2EE APIs 
    including EJB, Servlet, JSP, JCA, JDBC, JTA, JMS, JMX, JNDI, and Web 
    Services. This infrastructure will be architected for extensibility for 
    higher-level development constructs providing architectural separations of 
    concern and technical abstraction above the level of the J2EE specifications
    </p>
    <p>The J2EE Standard Tools Project will build on the Server Tools provided 
    by the Web Standard Tools Project to provide support for application 
    servers, including both servlet engines and EJB containers. The scope of the 
    J2EE Standard Tools Project includes exemplary adapters for popular 
    commercial and open source J2EE servers, e.g. Apache Tomcat, Apache 
    Geronimo, and ObjectWeb Jonas. Server vendors are encouraged to develop 
    adapters for their products. Support of frameworks not covered by the J2EE 
    specification (e.g., Struts, Hibernate, XMLC) are outside the scope of 
    this project, although such projects could find a home in an Eclipse 
    Technology project. J2SE standards (for example,
    JAX-RPC 2.0) may be implemented by JST to enable Web or J2EE application development
    when those standards are not addressed by the Eclipse Platform Project.</p>
    <p>Although the scope of the Web and J2EE Standard Tools projects includes 
    the development of exemplary adapters for popular commercial and Open Source 
    servers, these are not necessarily intended to be the definitive adapters. 
    Instead, they are intended to serve two purposes. First, they are intended 
    to enable users to immediately use these servers, although possibly with not 
    exploiting all their features. Second, they are intended to serve as 
    examples to both commercial and Open Source developers who want to integrate 
    servers into Eclipse. It is consistent with the goals of this project that 
    the exemplary adapters become superseded by more complete implementations 
    provided by third parties, both commercial and open source.</p>
    
    <p>
    WTP may implement a draft standard at the time that the relevant standards body
    requests public review or feedback based on implementation experience, e.g. a W3C
    Candidate Recommendation, provided that the domain of the standard is within the
    scope of WTP as defined by this Charter and that the relevant standards body has
    published the draft standard under licence terms that allow it to be implemented
    in a manner consistent with a transparent Open Source project and the EPL. 
    </p>

    <p>
    Data and database management tools are within the purview of the
    Data Tools Project (DTP), and as such are outside the scope of WTP, although
    both projects cooperate in areas where data modeling and
    application development overlap.
    </p>

    <p><b>Other Terms<br></b>
    This Charter inherits all terms not otherwise defined herein from the
    &quot;<a href='http://www.eclipse.org/org/processes/Eclipse_Standard_TopLevel_Charter_v1.0.html'>Eclipse Standard Charter v1.0</a>&quot;.
    This includes, but is not limited to, sections on the Program Management Committee, Roles,
    Project Organization, The Development Process, and Licensing.
    </p>
  </tr>
</table>
</body>
</html>
