<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
       "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
<head>
  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
  <title>Welcome to Apache Axis2-C home page</title>
  <meta name="generator" content="amaya 9.4, see http://www.w3.org/Amaya/" />
</head>

<body xml:lang="en">
<h1>Welcome to Apache Axis2/C</h1>

<p>Axis2/C is an effort to implement <a
href="http://ws.apache.org/axis2/0_93/Axis2ArchitectureGuide.html">Axis2
architecture</a>, in C. Axis2/C can be used to provide and consume Web
Services.</p>

<h2>Background and Motivation</h2>

<p>While Axis 2 Java is moving closer to 1.0, this implementation provides
another language option to consume and provide web services. Performance
being its forte, Axis2/C is looking at broadening its horizan by providing
extensions to popular open source scripting languages and web browsers. </p>

<h2>Latest Release</h2>

<p><b>Milestone Release 0.5 - (9th March 2006) (<a
href="http://www.apache.org/dyn/closer.cgi/ws/axis2/c/M0.5/">Download
M-0.5</a>)</b></p>

<h4>Key Features</h4>
<ol type="1">
  <li>AXIOM, an XML object model working on StAX (Streaming API for XML)
    parsing optimized for SOAP 1.1/1.2 Messages.</li>
  <li>Support for Request Response Messaging (In-Out)</li>
  <li>Module Architecture, mechanism to extend the SOAP Processing Model</li>
  <li>Directory based deployment model</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>Improved and user friendly Client API</li>
  <li>Transports supports: HTTP
    <ul>
      <li>Axis2/C server</li>
      <li>Apache integration module</li>
    </ul>
  </li>
  <li>Raw XML providers</li>
  <li>Numerous bug fixes since last release</li>
</ol>

<h4>Major Changes Since the Last Release</h4>
<ol type="1">
  <li>Improving code quality by fixing memory leaks and reviewing the
  code.</li>
  <li>Apache2 integration.</li>
  <li>More samples and tests(Including Plugfest testing code to interoperate
    with Microsoft services)</li>
  <li>Initial documentations(User Guide, Developer Guide, Installation
  Guide)</li>
</ol>

<h4>What's Still To Do?</h4>

<p>See list of what we think needs to be done, and consider helping out if
you're interested &amp; able!</p>
<ol type="1">
  <li>Management Interface for Axis2/C</li>
  <li>Implementation of other Transports.</li>
  <li>Code generation and Dynamic Invocation</li>
  <li>Hot Deployment of Services</li>
  <li>Completion of interop tests</li>
  <li>Support for MTOM/ MIME/ SwA</li>
  <li>Axis Data Binding - ADB (Framework and Schema Compiler)</li>
  <li>REST (REpresentational State Transfer) Support</li>
</ol>
</body>
</html>
