<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8"/>
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <meta name="Date-Revision-yyyymmdd" content="20140918"/>
  <meta http-equiv="Content-Language" content="en"/>
  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

  <title>Announcements 2007</title>

  <link href="//fonts.googleapis.com/css?family=Source+Sans+Pro:300,400,600,700,400italic,600italic,700italic" rel="stylesheet" type="text/css">
  <link href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">
  <link href="/css/main.css" rel="stylesheet">
  <link href="/css/custom.css" rel="stylesheet">
  <link href="/highlighter/github-theme.css" rel="stylesheet">

  <script src="//code.jquery.com/jquery-1.11.0.min.js"></script>
  <script type="text/javascript" src="/bootstrap/js/bootstrap.js"></script>
  <script type="text/javascript" src="/js/community.js"></script>
</head>
<body>

<a href="http://github.com/apache/struts" class="github-ribbon">
  <img style="position: absolute; right: 0; border: 0;" src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png" alt="Fork me on GitHub">
</a>

<header>
  <nav>
    <div role="navigation" class="navbar navbar-default navbar-fixed-top">
      <div class="container">
        <div class="navbar-header">
          <button type="button" data-toggle="collapse" data-target="#struts-menu" class="navbar-toggle">
            Menu
            <span class="sr-only">Toggle navigation</span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
            <span class="icon-bar"></span>
          </button>
          <a href="/index.html" class="navbar-brand logo"><img src="/img/struts-logo.svg"></a>
        </div>
        <div id="struts-menu" class="navbar-collapse collapse">
          <ul class="nav navbar-nav">
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Home<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/index.html">Welcome</a></li>
                <li><a href="/download.cgi">Download</a></li>
                <li><a href="/releases.html">Releases</a></li>
                <li><a href="/announce-2021.html">Announcements</a></li>
                <li><a href="http://www.apache.org/licenses/">License</a></li>
                <li><a href="https://www.apache.org/foundation/thanks.html">Thanks!</a></li>
                <li><a href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a></li>
              </ul>
            </li>
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Support<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/mail.html">User Mailing List</a></li>
                <li><a href="https://issues.apache.org/jira/browse/WW">Issue Tracker</a></li>
                <li><a href="/security.html">Reporting Security Issues</a></li>
                <li class="divider"></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Migration+Guide">Version Notes</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Security+Bulletins">Security Bulletins</a></li>
                <li class="divider"></li>
                <li><a href="/maven/project-info.html">Maven Project Info</a></li>
                <li><a href="/maven/struts2-core/dependencies.html">Struts Core Dependencies</a></li>
                <li><a href="/maven/struts2-plugins/modules.html">Plugin Dependencies</a></li>
              </ul>
            </li>
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Documentation<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/birdseye.html">Birds Eye</a></li>
                <li><a href="/primer.html">Key Technologies</a></li>
                <li><a href="/kickstart.html">Kickstart FAQ</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Home">Wiki</a></li>
                <li class="divider"></li>
                <li><a href="/getting-started/">Getting Started</a></li>
                <li><a href="/security/">Security Guide</a></li>
                <li><a href="/core-developers/">Core Developers Guide</a></li>
                <li><a href="/tag-developers/">Tag Developers Guide</a></li>
                <li><a href="/maven-archetypes/">Maven Archetypes</a></li>
                <li><a href="/plugins/">Plugins</a></li>
                <li><a href="/maven/struts2-core/apidocs/index.html">Struts Core API</a></li>
                <li><a href="/tag-developers/tag-reference.html">Tag reference</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/FAQs">FAQs</a></li>
                <li><a href="http://cwiki.apache.org/S2PLUGINS/home.html">Plugin registry</a></li>
              </ul>
            </li>
            <li class="dropdown">
              <a data-toggle="dropdown" href="#" class="dropdown-toggle">
                Contributing<b class="caret"></b>
              </a>
              <ul class="dropdown-menu">
                <li><a href="/youatstruts.html">You at Struts</a></li>
                <li><a href="/helping.html">How to Help FAQ</a></li>
                <li><a href="/dev-mail.html">Development Lists</a></li>
                <li><a href="/contributors/">Contributors Guide</a></li>
                <li class="divider"></li>
                <li><a href="/submitting-patches.html">Submitting patches</a></li>
                <li><a href="/builds.html">Source Code and Builds</a></li>
                <li><a href="/coding-standards.html">Coding standards</a></li>
                <li><a href="https://cwiki.apache.org/confluence/display/WW/Contributors+Guide">Contributors Guide</a></li>
                <li class="divider"></li>
                <li><a href="/release-guidelines.html">Release Guidelines</a></li>
                <li><a href="/bylaws.html">PMC Charter</a></li>
                <li><a href="/volunteers.html">Volunteers</a></li>
                <li><a href="https://gitbox.apache.org/repos/asf?p=struts.git">Source Repository</a></li>
                <li><a href="/updating-website.html">Updating the website</a></li>
              </ul>
            </li>
            <li class="apache"><a href="http://www.apache.org/"><img src="/img/apache.png"></a></li>
          </ul>
        </div>
      </div>
    </div>
  </nav>
</header>


<article class="container">
  <section class="col-md-12">
    <a class="edit-on-gh" href="https://github.com/apache/struts-site/edit/master/source/announce-2007.html" title="Edit this page on GitHub">Edit on GitHub</a>
    
    <h1>Announcements - 2007</h1>

<p class="pull-right">
  Skip to: <a href="announce-2006.html">Announcements - 2006</a>
</p>

<h4 id="a20071023">23 October 2007 - Struts 2.0.11 General Availability Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 2.0.11 is
  available as a "General Availability" release. The GA designation is
  our highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for creating
  enterprise-ready Java web applications. The framework is designed to
  streamline the full development cycle, from building, to deploying, to
  maintaining applications over time.
</p>
<p>
  This release includes a number of fixes and improvements since the
  2.0.9 GA release. Struts 2.0.11 is available in a full distribution,
  or as separate library, source, example and documentation
  distributions, from the
  <a href="http://struts.apache.org/download.cgi#struts2011">releases page</a>.
  The release is also available through the central Maven repository under Group ID
  "org.apache.struts". The
  <a href="http://struts.apache.org/2.0.11/docs/release-notes-2011.html">release notes</a>
  are available online.
</p>
<p>
  The 2.0.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API 2.4,
  JSP API 2.0, Java 5, Backported Java 4 JARs are also available.
</p>
<p>
  Should any issues arise with your use of any version of the Struts
  framework, please post your comments to the user list, and, if
  appropriate, file a
  <a href="https://issues.apache.org/struts/secure/Dashboard.jspa">tracking ticket</a>.
</p>


<h4 id="a20071012b">12 October 2007 - New Struts Committer -- Dave Newton</h4>
<p>
  Please join us in welcoming Dave Newton as a new Struts committer.
</p>
<p>
  Dave's been doing "yeoman work" on the user list for some time now,
  filing issues, and helping with the documentation. It's likely that
  he's edited the most documentation pages of any non-committer.
</p>
<p>
  Welcome, Dave, now you can update the JavaDocs to better match the
  Confluence pages!
</p>
<p>
  PMC vote: 5 +1.
</p>

<h4 id="a20071012">12 October 2007 - New Struts Committer -- Brian Pontarelli </h4>
<p>
  Please join us in welcoming Brian Pontarelli as a new Struts committer.
</p>
<p>
  Brian developed the SmartURLs plugin, which is being merged with the
  CodeBehind plugin for bundling with Struts 2.1. The original
  CodeBehind plugin and Zero-Configuration code, developed by Don Brown,
  was loosely based on the ASP.NET approach. Brian's SmartURLs plugin
  gives the original approach a more Struts-like spin and adds SEO URIs.
</p>
<p>
  Welcome, Brian, I think we're all looking forward to an agile, XML-free future!
</p>
<p>
  PMC vote: 4 +1; 1 +0.
</p>

<h4 id="a200709022">22 September 2007 - New Struts Committer -- Matt Raible</h4>
<p>
  Please join us in welcoming Matt Raible as a new Struts committer.
</p>
<p>
  Over many years, Matt Raible has been one the most involved members of
  our community, for Struts 1, Struts 2, and WebWork. He's also a member
  of the Apache Roller project, which recently migrated from Struts 1 to
  Struts 2. Though sometimes critical, his comments are always meant to
  be constructive. He's participated in over fifty JIRA tickets, and
  over a hundred threads on struts-user and struts-dev. Of course, many
  of us have also met Matt, since he frequently attends ApacheCon and
  other conventions.
</p>
<p>
  Welcome, Matt ... BTW, have you heard that our invalid property error
  reporting sucks^g^g^g^g needs work?
</p>
<p>
  PMC vote: 12 +1. (Could be a record!)
</p>

<h4 id="a20070801">01 August 2007 - Struts v1.3.9 Beta Release</h4>

<p>
  The Apache Struts group is pleased to announce that Struts 1.3.9
  is available as a "Beta" release.
</p>

<p>
  Struts 1.3.9 is available in a full distribution, or as separate
  library, source, example and documentation distributions.
</p>

<p>
  <a href="http://struts.apache.org/download.cgi#struts139">
    http://struts.apache.org/download.cgi#struts139</a>
</p>

<p>
  It is also available in the central Maven repository under Group ID
  ID "org.apache.struts".
</p>

<h4 id="a20070724">24 July 2007 - Struts 2.0.9 General Availability Release with Important Security Fix</h4>
<p>
  <strong><a href="http://struts.apache.org/download.cgi#struts209">Apache Struts 2.0.9</a>
    includes an important security fix regarding <a href="http://struts.apache.org/docs/s2-001.html">a remote code
      exploit.</a></strong>
  ALL STRUTS 2 DEVELOPERS ARE STRONGLY ADVISED TO UPDATE TO STRUTS 2.0.9 IMMEDIATELY!
</p>
<p>
  <em>PLEASE NOTE that this bulletin DOES NOT apply to Struts 1.x!</em>
</p>

<p>
  For other changes included in Struts 2.0.9,
  see the <a href="http://struts.apache.org/2.0.9/docs/release-notes-209.html">release notes</a>.
</p>

<h4 id="a20070708">8 July 2007 - Struts Downloads Skyrocket in 2007</h4>

<p>
  Since its release in June 2001, Apache Struts
  (struts.apache.org) has become the most popular web framework
  for Java. Six years later, by any objective measure, Struts is
  still Java's most popular web framework.
</p>
<p>
  In February and March 2007, the group released both Struts 1.3.8
  and Struts 2.0.6 to the general public, and Struts downloads
  zoomed to over 340,000 a month from the Apache site alone [1].
  And this is just the tip of the iceberg. Most copies of Struts
  are downloaded from an network of mirrors or obtained from Maven
  repositories. Meanwhile, monthly page Views for the Struts
  website soared to over 2.1 million, up from levels of about 1.3
  million page views in June 2004. Subscriptions to the Struts
  mailing lists hold steady at about 3,000 accounts, not counting
  people who use services like Nabble and GMane.
</p>
<p>
  Since the framework's debut, well over twenty books about Apache
  Struts have been published [2], along with hundreds of online
  articles, and dozens of third-party extensions [3]. Books and
  articles devoted to Struts 2 are already appearing. InfoQ has
  released "Starting with Struts2" both as a free PDF and as a
  hardcopy book via LuLu.com [4]. Mark Menard has started a Struts
  2 cookbook [5], and sites like Rose India and ArcTech are
  offering extensive Struts 2 tutorials [6]. Many teams are
  already moving Struts 1 applications to Struts 2, including the
  popular Apache Roller blogging application [7].
</p>
<p>
  An exciting feature of Struts 2 is configuration-free plugins.
  Third-party components can be added to the framework just by
  putting a JAR on the Java classpath. In fact, many of the
  framework's advanced features are provided by plugins that ship
  with Struts 2. A plugin repository site is open to the public
  [8], and several plugins are already available, including
  plugins for JSON, WebFlow, Google Web Toolkit, and Guice.
</p>
<p>
  While there is no lack of choice in the Java framework space,
  the clear winner with grassroots developers is still Apache
  Struts. With first-class support for Ajax, JSF, unit testing,
  and dependency injection, Struts 2 is an excellent choice for
  teams that want to step forward, without stepping away.
</p>
<p>
  Links:
</p>
<ul>
  <li>
    [1] - <a href="http://people.apache.org/~vgritsenko/stats/projects/struts#Downloads-N1008F">Apache Stats</a>
  </li>
  <li>
    [2] - <a href="http://opensource.atlassian.com/confluence/oss/display/BOOKS/Books+about+Struts">Apache Bookstore</a>
  </li>
  <li>
    [3] - <a href="http://husted.com/central/">Struts Central</a>
  </li>
  <li>
    [4] - <a href="http://www.lulu.com/content/813300">Starting Struts 2</a>
  </li>
  <li>
    [5] - <a href="http://www.vitarara.org/cms/struts2cookbook">Struts 2 Cookbook</a>
  </li>
  <li>
    [6] - <a href="http://www.roseindia.net/struts/struts2/index.shtml">Rose India Struts 2 Tutorial</a> and
    <a href="https://www.arctechsoftware.com/tutorial/tutorial.do?subcatId=4">ArchTech Struts 2 Tutorial</a>
  </li>
  <li>
    [7] - <a href="http://cwiki.apache.org/confluence/display/ROLLER/What%27s+New+in+Roller+4.0">Apache Roller</a>
  </li>
  <li>
    [8] - <a href="http://cwiki.apache.org/S2PLUGINS/home.html">Struts Plugins</a>
  </li>
</ul>

<h4 id="a20070612">12 June 2007 - Struts v2.0.8 GA Release</h4>

<p>
  The Apache Struts group is pleased to announce that Struts 2.0.8
  is available as a "General Availability" release. The GA
  designation is our highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for
  creating enterprise-ready Java web applications. The framework
  is designed to streamline the full development cycle, from
  building, to deploying, to maintaining applications over time.
</p>
<p>
  Apache Struts 2 was originally known as WebWork 2. After working
  independently for several years, the WebWork and Struts
  communities joined forces to create Struts2. This new version of
  Struts is simpler to use and closer to how Struts was always
  meant to be.
</p>
<ul>
  <li>
    <em>Build!</em>
    <ul>
      <li>
        <strong>Easy startup</strong> - Jumpstart new projects with our bootstrap tutorial and template application or
        Maven archetype.
      </li>
      <li>
        <strong>Improved Design</strong> - Code clean against HTTP-independent framework interfaces.
      </li>
      <li>
        <strong>Enhanced Tags</strong> - Code less with stylesheet-driven form tags that provide their own markup.
      </li>
      <li>
        <strong>Stateful Checkboxes</strong> - Avoid special handling with smart checkboxes that know when they are
        toggled.
      </li>
      <li>
        <strong>Flexible Cancel Buttons</strong> - Go directly to a different action on cancel.
      </li>
      <li>
        <strong>First-class AJAX support</strong> - Add interactivity and flexibility with AJAX tags that look and feel
        just like standard Struts tags.
      </li>
      <li>
        <strong>Easy Spring integration</strong> - Inject dependencies into Actions using Spring without glue code or
        red tape. (Plexus support also available.)
      </li>
      <li>
        <strong>Enhanced Results</strong> - Do more with specialty results for JasperReports, JFreeChart, Action
        chaining, and file downloading.
      </li>
      <li>
        <strong>POJO forms</strong> - No more ActionForms! Use any JavaBean to capture form input or
        put properties directly on an Action class. Use both binary and String properties!
      </li>
      <li>
        <strong>POJO Actions</strong> - Use any class as an Action class -- even the
        interface is optional!
      </li>
    </ul>
  </li>

  <li>
    <em>Deploy!</em>
    <ul>
      <li>
        <strong>Easy plugins</strong> - Add framework extensions by dropping in a JAR.
        No manual configuration required! Bundled plugins add support for JavaServer Faces,
        JasperReports, JFreeChart, Tiles, and more ...
      </li>
      <li>
        <strong>Integrated profiling</strong> - Peek inside Struts<sup>2</sup> to find where the cycles are going!
      </li>
      <li>
        <strong>Precise Error Reporting</strong> - Flip directly to the location and line of an error.
      </li>
    </ul>
  </li>
  <li>
    <em>Maintain!</em>
    <ul>
      <li>
        <strong>Easy-to-test Actions</strong> - Test Struts<sup>2</sup> Actions directly,
        without resorting to mock HTTP objects.
      </li>
      <li>
        <strong>Intelligent Defaults</strong> - Skip obvious and redundant settings. Most framework configuration
        elements have a default value that we can set and forget. Say it once!
      </li>
      <li>
        <strong>Easy-to-customize controller</strong> - Customize the request handling
        per action, if desired. Struts<sup>2</sup> only does what you want it to do!
      </li>
      <li>
        <strong>Integrating Debugging</strong> - Research problem reports with built-in
        debugging tools.
      </li>
      <li>
        <strong>Easy-to-tweak tags</strong> - Customize tag markup by editing a FreeMarker
        template. No need to grok the taglib API!
        <em>JSP, FreeMarker, and Velocity tags are fully supported.</em>
      </li>
    </ul>
  </li>
</ul>

<p>
  This release has over 60 bug fixes and improvements since 2.0.6!
  New Features include:
</p>
<ul>
  <li>
    <strong>Cookie Interceptor</strong><br/>
    Inject cookie with a certain configurable name / value into action.
  </li>
  <li>
    <strong>Restful2ActionMapper</strong><br/>
    Allow automatic id setting from Restful2ActionMapper.
  </li>
</ul>
<p>
  Struts 2.0.8 is available in a full distribution, or as separate
  library, source, example and documentation distributions, from
  the <a href="http://struts.apache.org/download.cgi#struts208">
  releases page.</a>
  The release is also available through the central Maven repository
  under Group ID "org.apache.struts".
  The release notes are
  <a href="http://struts.apache.org/2.0.8/docs/release-notes-208.html">
    available online</a>.
</p>
<p>
  The 2.0.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API
  2.4, JSP API 2.0, Java 5, Backported Java 4 JARs
  are also available.
</p>
<p>
  Should any issues arise with your use of any version of the
  Struts framework, please post your comments to the user list,
  and, if appropriate, file a ticket with JIRA.
</p>

<h4 id="a20070310">10 March 2007 - Struts v1.3.8 GA Release</h4>
<p>
  The Apache Struts group is pleased to announce that Struts 1.3.8
  is available as a "General Availability" release. The GA
  designation is our highest quality grade.
</p>

<p>
  This release has over 40 bug fixes and improvements since 1.3.5!
  New Features include:
</p>

<ul>
  <li>
    <strong>Action ID</strong><br/>
    New <code>actionId</code> attribute to uniquely identify action mappings
    within a module. Just as the TilesRequestProcessor could recognize a tile
    definition and resolve it to the intended JSP, so does Struts now have
    built-in recognition for URIs that begin with an actionId and will
    automatically translate forwards.
  </li>
  <li>
    <strong>I18N Properties</strong><br/>
    Tag libraries now include the HTML I18N properties. This allows sites
    that specialize in internationalization to specify both bi-directional
    text and language at the tag level.
  </li>
  <li>
    <strong>Dynamic Link Parameters</strong><br/>
    The Struts &lt;html:link&gt;, &lt;html:frame&gt;, &lt;html:rewrite&gt; tag
    libraries now allow their bodies to nest the new &lt;html:param&gt; tag.
  </li>
  <li>
    <strong>Property MessageResources Modes</strong><br/>
    Compatibility mode option which allows message resources to operate in
    modes compatible with either JSTL or PropertyResourceBundle.
  </li>
</ul>

<p>
  Struts 1.3.8 is available in a full distribution, or as separate
  library, source, example and documentation distributions.
</p>

<p>
  <a href="http://struts.apache.org/download.cgi#struts138">
    http://struts.apache.org/download.cgi#struts138</a>
</p>

<p>
  It is also available in the central Maven repository under Group ID
  ID "org.apache.struts".
</p>


<h4 id="a20070223">22 Feb 2007 - Struts v2.0.6 GA Release</h4>

<p>
  The Apache Struts group is pleased to announce that Struts 2.0.6
  is available as a "General Availability" release. The GA
  designation is our highest quality grade.
</p>
<p>
  Apache Struts 2 is an elegant, extensible framework for
  creating enterprise-ready Java web applications. The framework
  is designed to streamline the full development cycle, from
  building, to deploying, to maintaining applications over time.
</p>
<p>
  Apache Struts 2 was originally known as WebWork 2. After working
  independently for several years, the WebWork and Struts
  communities joined forces to create Struts2. This new version of
  Struts is simpler to use and closer to how Struts was always
  meant to be.
</p>
<ul>
  <li>
    <em>Build!</em>
    <ul>
      <li>
        <strong>Easy startup</strong> - Jumpstart new projects with our bootstrap tutorial and template application or
        Maven archetype.
      </li>
      <li>
        <strong>Improved Design</strong> - Code clean against HTTP-independent framework interfaces.
      </li>
      <li>
        <strong>Enhanced Tags</strong> - Code less with stylesheet-driven form tags that provide their own markup.
      </li>
      <li>
        <strong>Stateful Checkboxes</strong> - Avoid special handling with smart checkboxes that know when they are
        toggled.
      </li>
      <li>
        <strong>Flexible Cancel Buttons</strong> - Go directly to a different action on cancel.
      </li>
      <li>
        <strong>First-class AJAX support</strong> - Add interactivity and flexibility with AJAX tags that look and feel
        just like standard Struts tags.
      </li>
      <li>
        <strong>Easy Spring integration</strong> - Inject dependencies into Actions using Spring without glue code or
        red tape. (Plexus support also available.)
      </li>
      <li>
        <strong>Enhanced Results</strong> - Do more with specialty results for JasperReports, JFreeChart, Action
        chaining, and file downloading.
      </li>
      <li>
        <strong>POJO forms</strong> - No more ActionForms! Use any JavaBean to capture form input or
        put properties directly on an Action class. Use both binary and String properties!
      </li>
      <li>
        <strong>POJO Actions</strong> - Use any class as an Action class -- even the
        interface is optional!
      </li>
    </ul>
  </li>

  <li>
    <em>Deploy!</em>
    <ul>
      <li>
        <strong>Easy plugins</strong> - Add framework extensions by dropping in a JAR.
        No manual configuration required! Bundled plugins add support for JavaServer Faces,
        JasperReports, JFreeChart, Tiles, and more ...
      </li>
      <li>
        <strong>Integrated profiling</strong> - Peek inside Struts<sup>2</sup> to find where the cycles are going!
      </li>
      <li>
        <strong>Precise Error Reporting</strong> - Flip directly to the location and line of an error.
      </li>
    </ul>
  </li>
  <li>
    <em>Maintain!</em>
    <ul>
      <li>
        <strong>Easy-to-test Actions</strong> - Test Struts<sup>2</sup> Actions directly,
        without resorting to mock HTTP objects.
      </li>
      <li>
        <strong>Intelligent Defaults</strong> - Skip obvious and redundant settings. Most framework configuration
        elements have a default value that we can set and forget. Say it once!
      </li>
      <li>
        <strong>Easy-to-customize controller</strong> - Customize the request handling
        per action, if desired. Struts<sup>2</sup> only does what you want it to do!
      </li>
      <li>
        <strong>Integrating Debugging</strong> - Research problem reports with built-in
        debugging tools.
      </li>
      <li>
        <strong>Easy-to-tweak tags</strong> - Customize tag markup by editing a FreeMarker
        template. No need to grok the taglib API!
        <em>JSP, FreeMarker, and Velocity tags are fully supported.</em>
      </li>
    </ul>
  </li>
</ul>
<p>
  Struts 2.0.6 is available in a full distribution, or as separate
  library, source, example and documentation distributions, from
  the <a href="http://struts.apache.org/download.cgi#struts2006">
  releases page.</a>
  The release is also available through the central Maven repository
  under Group ID "org.apache.struts".
  The release notes are
  <a href="http://struts.apache.org/2.0.6/docs/release-notes-206.html">
    available online</a>.
</p>
<p>
  The 2.0.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions: Servlet API
  2.4, JSP API 2.0, Java 5, Backported Java 4 JARs
  are also available.
</p>
<p>
  Should any issues arise with your use of any version of the
  Struts framework, please post your comments to the user list,
  and, if appropriate, file a ticket with JIRA.
</p>

<h4 id="a20070209">09 Feb 2007 - Struts v2.0.5 BETA Release</h4>

<p>
  The Apache Struts project is pleased to announce the release
  of Struts 2.0.5 BETA
</p>

<p>
  Struts 2.0.5 is available in a full distribution, or as
  separate library, source, example and documentation
  distributions from the
  <a href="http://struts.apache.org/download.cgi?struts205">
    Releases page.</a>
</p>

<p>
  It is also available in the central Maven repository under
  Group ID "org.apache.struts".
</p>

<p>
  The 2.0.x series of the Apache Struts framework has a minimum
  requirement of the following specification versions:
  Servlet API 2.4, JSP API 2.0, Java 5, Backported Java 4 JARs
  are also available.
</p>
<p>
  The release notes are
  <a href="http://struts.apache.org/2.0.5/docs/release-notes-205.html">
    available online</a>.
</p>
<hr/>

<h4 id="a20070129-1">29 Jan 2007 - New Struts Committer -- Philip Luppens </h4>
<p>
  Phil, as he is generally known, is the most active member of the WebWork
  user community, as judged by their forum/mailing list with over 1400
  posts. He has also been listed a WebWork developer, contributing ideas,
  code, and documentation for several years and is a highly respected
  member as the WebWork developers can attest.
</p>
<p>
  Phil has also been actively involved in the Struts 2 project,
  helping to keep the WebWork 2 tickets in sync as well as participating
  in Struts developer discussions.
</p>
<p>
  Welcome aboard, Phil, keep those syncronizations coming!
</p>

<h4 id="a20070129-2">29 Jan 2007 - New Struts Committer -- Tom Schneider</h4>
<p>
  Tom has been around the Struts and WebWork communities for several
  months in the Struts and WebWork [2] user and developer forums. He has
  opened several JIRA tickets with high quality patches. He is
  also the author of several Struts 2 plugins, and Tom has recently
  been helping with defining plugins that provide tag libraries,
  abstracting OGNL from XWork, and optimizing OGNL within the tags. He
  has also been active in the Struts user mailing list providing users
  with help with basic issues encountered when transitioning to Struts 2.
</p>
<p>
  Welcome aboard, Tom, keep those optimizations coming!
</p>

<h4 id="a20070129-3">29 Jan 2007 - New Struts Committer -- Musachy Barrosso</h4>
<p>
  Please join us in welcoming Musachy Barrosso as a new Struts committer.
</p>
<p>
  Musachy has only been active in Struts since late October,
  but since that time he has participated in hundreds of list
  postings, filed a dozen JIRA tickets, and provided patches
  for several others.
</p>
<p>
  Welcome aboard, Musachy, we appreciate your help in
  keeping the Ajax code clean!
</p>

<p class="pull-right">
  Skip to: <a href="announce-2006.html">Announcements - 2006</a>
</p>

<p class="pull-left">
  <strong>Next:</strong>
  <a href="kickstart.html">Kickstart FAQ</a>
</p>

  </section>
</article>


<footer class="container">
  <div class="col-md-12">
    Copyright &copy; 2000-2018 <a href="http://www.apache.org/">The Apache Software Foundation </a>.
    All Rights Reserved.
  </div>
  <div class="col-md-12">
    Apache Struts, Struts, Apache, the Apache feather logo, and the Apache Struts project logos are
    trademarks of The Apache Software Foundation.
  </div>
  <div class="col-md-12">Logo and website design donated by <a href="https://softwaremill.com/">SoftwareMill</a>.</div>
</footer>

<script>!function (d, s, id) {
  var js, fjs = d.getElementsByTagName(s)[0];
  if (!d.getElementById(id)) {
    js = d.createElement(s);
    js.id = id;
    js.src = "//platform.twitter.com/widgets.js";
    fjs.parentNode.insertBefore(js, fjs);
  }
}(document, "script", "twitter-wjs");</script>
<script src="https://apis.google.com/js/platform.js" async="async" defer="defer"></script>

<div id="fb-root"></div>

<script>(function (d, s, id) {
  var js, fjs = d.getElementsByTagName(s)[0];
  if (d.getElementById(id)) return;
  js = d.createElement(s);
  js.id = id;
  js.src = "//connect.facebook.net/en_GB/all.js#xfbml=1";
  fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));</script>


</body>
</html>
