---
layout: default
title: Announcements 2005
---

<h1>Announcements - 2005</h1>

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


<h4 id="a20051218.1">18 Dec 2005 - New Struts Committer: Richard
  Feit</h4>
<p>
  Please join us in welcoming Rich Feit as a new Struts
  committer. Rich is
  a Beehive committer and PMC member. In addition to being a
  Struts user
  for years (Beehive is built on Struts), he has been pivotal in
  designing
  and coding Struts Ti, both the initial annotationed Beehive
  version and
  the current WebWork merger effort. His experience in Struts
  migration
  tools in particular will be key to making Struts Action a
  success. We
  look forward to his continued contributions as a committer.
</p>

<p>
  Welcome, Rich!
</p>
<p>
  PMC vote: 7 +1, non-binding committer votes: 3 +1
</p>
<hr/>

<h4 id="a20051214.4">14 Dec 2005 - Apache Struts to release Struts
  1.3.0
  as the "Action Framework"</h4>

<p>
  [Note: As of version 1.3.5, the "Action Framework" label
  was dropped, and Struts is just Struts again.]
</p>

<p>
  The Apache Struts flagship product,
  the leading web application framework for Java,
  is now known as the "Struts".
</p>

<p>
  To make the framework easier to maintain,
  Apache Struts subdivided the original monolithic distribution
  into several
  subprojects.
  Each subproject has its own website, documentation, and
  release cycle,
  and may be downloaded separately.
  For consistency, the original core framework component also
  has its own name
  now: "Struts".
  The JARs and external dependencies for the extensions to
  Struts
  are being bundled into a convenient distribution known as the
  "Struts Action
  Framework Library".
</p>

<p>
  The Struts 1.3.0 release will include several
  exciting new
  features, including:
</p>

<ul>
  <li>Composable Request Processor</li>
  <li>ActionDynaForm interfaces</li>
  <li>Arbitrary configuration properties</li>
  <li>Catalog and Command Elements</li>
  <li>Enhanced Global Exception Handlers</li>
  <li>Extends attribute for XML configurations</li>
  <li>"isCommitted" Exception Handling</li>
  <li>Postback Actions</li>
  <li>Wildcard ActionConfig properties</li>
</ul>

<p>
  The key change in this release is the "composable request
  processor".
  The request processor is the framework's "kernal".
  The request processor methods are now command objects in a
  flexible chain of
  commands.
  Rather than subclassing a monolithic object,
  developers can now just replace commands with their own
  implementations.
  Commands can also be inserted or removed, if needed,
  to extend or streamline the request processing gauntlet,
  to better meet the needs of different kinds of applications.
</p>

<p>
  The Struts 1.3.0 release,
  and other milestones on the Apache Struts roadmap,
  were discussed at ApacheCon on Tuesday, December 13, 2005, in
  a talk,
  entitled "Struts 2006: An Embarrassment of Riches".
  <a href="http://people.apache.org/~husted/apachecon-2005-action.pdf">
    Slides from the talk are available online</a>
  .
</p>
<hr/>

<h4 id="a20051214.3">14 Dec 2005 - Apache Struts and Open Symphony
  WebWork
  communities to merge</h4>
<p>
  Apache Struts,
  the leading web application framework for Java, and Open
  Symphony WebWork,
  a leader in technical innovation, are working to merge their
  communities
  and codebases.
</p>

<p>
  "A merger is an elegant approach to evolution of existing
  applications
  based on action-oriented frameworks,"
  said Craig McClanahan, founder of the Struts project.
</p>

<p>
  The merger seems like a win-win for the frameworks.
  "The technical benefit is that WebWork has already done most
  everything
  that is on the Struts Action roadmap," noted Ted Husted, a
  Struts committer.
  "This is a way that [Struts] shops can use incremental
  integration to take
  advantage of new technologies that are already part of
  WebWork, such as Spring."
</p>

<p>
  "My hope is to take advantage of a larger community (Struts)
  to allow
  all of us to do a bit less individual effort."
  said Patrick Lightbody of WebWork.
  "I would expect moving to Struts lets us focus on our families
  and day
  jobs a bit more."
</p>

<p>
  Apache projects help developers balance day jobs with
  volunteer work
  through the practice of collaborative developement.
  Decisions are made jointly by the core community,
  rather than by one or two key individuals.
  The projects are organized so that individual developers can
  focus on
  other matters for a time,
  and then return to the development community as schedules
  allow.
</p>

<p>
  Over the past few months,
  Apache Struts has more than doubled its number of active
  committers.
  With the addition of two WebWork developers,
  there are about fifteen active volunteers.
  Right now, about half of the committers are working on the
  original Struts
  Action Framework and half are working on the new Struts Shale
  Framework,
  which utilizes JavaServer Faces.
  Several volunteers are now working with both frameworks.
</p>

<p>
  The merger and other milestones on the Apache Struts roadmap
  were discussed
  in a talk at ApacheCon on Tuesday, December 13, 2005, entitled
  <a href="http://people.apache.org/~husted/apachecon-2005-action.pdf">"Struts 2006:
    An Embarrassment of Riches".</a>
  The talk will be presented by Lightbody, Husted, and Don
  Brown, another
  Struts Committer.
  The Struts Shale framework is being discussed at a second
  talk,
  presented by McClanahan, entitled "Shale: The Next Struts??"
  <a href="http://people.apache.org/~craigmcc/apachecon-2005-shale.pdf">
    Slides from the talk are available online</a>
  .
</p>
<hr/>

<h4 id="a20051214.2">14 Dec 2005 - Apache Struts offers "Shale"
  for JSF</h4>

<p>[Note: <a href="http://shale.apache.org/">
  Shale is now a top-level ASF project.</a>]
</p>

<p>
  To give JavaServer Faces developers a head start on building
  scalable
  web applications for the enterprise,
  Apache Struts now offers the Shale Framework.
  Like the original "Struts",
  Shale provides developers with a front controller,
  and several other components,
  to provide the "invisible underpinnings that hold an
  application together".
</p>

<p>
  "When JavaServer Faces arrived,"
  explains the Struts website,
  "our development community chose to 'make new friends but keep
  the old'.
  Some of us want (or need) to stick with the original
  request-based
  framework.
  Others are ready to switch to an component-based framework
  that builds on
  JavaServer Faces.
  We offer both frameworks because we have volunteers to create
  and maintain
  both frameworks."
</p>

<p>
  Shale is based on the recently standardized JavaServer Faces
  APIs,
  and focuses on adding value,
  rather than redundantly implementing features that JSF already
  provides.
  Shale will run on any compliant JSF implementation,
  including the one being developed by the Apache MyFaces
  project.
  It also includes many features that Struts users appreciate,
  such as supporting client side validation and the Tiles
  framework.
</p>

<p>
  Struts Shale was discussed by Craig McClanahan in a talk at
  ApacheCon on
  Tuesday, December 13, 2005, entitled "Shale: The Next
  Struts??".
  <a href="http://people.apache.org/~craigmcc/apachecon-2005-shale.pdf">
    Slides
    from the talk are available online</a>
  .
</p>
<hr/>

<h4 id="a20051214.1">14 Dec 2005 - Apache Struts to release
  "standalone" Tiles</h4>
<p>
  Apache Struts introduced Tiles as a integral component of its
  Struts 1.1
  release in June 2003.
  Since then, several other projects have been using Tiles,
  even though it was embedded in the Struts JAR.
  Soon, it will be much easier to use Tiles with products like
  Jakarta Velocity,
  Apache MyFaces, and Struts Shale.
</p>

<p>
  Tiles is a templating framework that can be used to create a
  common look and
  feel for a web site or application and to create reusable view
  components.
  A key aspect of Tiles is that it can be configured from a XML
  configuration file.
  A Tile definition can "extend" another definition,
  giving the component an object-oriented feel.
  Tile developers can create a base Tile (or screen layout),
  and then indicate only how other Tiles differ from the base.
  Changes made to a base Tile "cascade" to Tiles that extend
  that base.
  Significant changes can be made to the layout of a website
  just by changing a single Tile definition.
</p>
<hr/>

<h4 id="a20051125">25 Nov 2005 - Struts 1.2.8 (General
  Availability)</h4>
<p>
  The Struts team is pleased to announce the release of Struts
  1.2.8 for
  General Availability. This release is primarily to fix a Cross
  Site
  Scripting (XSS) vulnerability identified in Struts by
  www.hacktics.com and
  supersedes the earlier 1.2.7 version as the latest official
  release of
  Struts from The Apache Software Foundation.
</p>
<p>
  For more information on the XSS Vulnerability and solutions
  please see the
  following pages:
  <a href="http://wiki.apache.org/struts/StrutsXssVulnerability">
    http://wiki.apache.org/struts/StrutsXssVulnerability</a>
  and
  <a href="http://www.hacktics.com/AdvStrutsNov05.html">
    http://www.hacktics.com/AdvStrutsNov05.html</a>
</p>
<p>
  The binary, source and library distributions are available
  from the Struts
  download page:
  <a href="http://struts.apache.org/download.cgi">
    http://struts.apache.org/download.cgi</a>
</p>
<p>
  The Release Notes are available on the Struts web site at:
  <a href="http://struts.apache.org/1.2.8/userGuide/release-notes.html">
    http://struts.apache.org/1.2.8/userGuide/release-notes.html</a>
</p>
<p>
  Please check the wiki for the latest information on upgrading:
  <a href="http://wiki.apache.org/struts/StrutsUpgrade">
    http://wiki.apache.org/struts/StrutsUpgrade</a>
</p>
<hr/>

<h4 id="a20051023.2">23 Oct 2005 - New Struts Committer: Laurie
  Harper</h4>
<p>
  Please join us in welcoming Laurie Harper as a new Struts
  committer. Over
  the last few months, he has made hundreds of helpful posts to
  our lists.
  Laurie is the author of the very cool
  <a href="http://www.zotechsoftware.com/products/struts-sidebar">
    Struts Sidebar</a>
  ,
  and he has contributed several patches to Struts Classic,
  including fixes to our unit tests (a thankless job).
</p>
<p>
  Welcome, Laurie! .. We're looking forward to many more green
  bars!
</p>
<p>
  PMC vote: 7 +1 (binding), 1 +1 (non-binding)
</p>
<hr/>

<h4 id="a20051023.1">23 Oct 2005 - New Struts Committer: Sean
  Schofield</h4>
<p>
  Please join us in welcoming Sean Schofield as a Struts
  committer. Sean is an
  Apache MyFaces committer who also been been working on Struts
  Shale.
</p>
<p>
  Welcome, Sean! .. Now you can apply your own patches!
</p>
<p>
  PMC vote: 5 +1, 1 +0
</p>
<hr/>

<h4 id="a20051023.0">23 Oct 2005 - New Struts Committer: Greg
  Reddin</h4>
<p>
  Please join us in welcoming Greg Reddin as a Struts committer.
  Greg has been
  an active Struts contributor for a long time now, and has been
  helping us
  move Tiles towards a standalone subproject.
</p>
<p>
  Welcome, Greg! .. We look forward to rapid progress on
  Standalone Tiles!
</p>
<p>
  PMC vote: 6 +1
</p>
<hr/>

<h4 id="a20050821">21 Aug 2005 - New Struts Committer: Gary
  vanMatre</h4>

<p>
  Please join us in welcoming Gary vanMatre as a new Struts
  committer.
  Gary has been quite busy proposing code for the "Clay" plug-in
  on Shale,
  and has also been supportive on the dev and user mailing lists
  (for both Struts and MyFaces).
  We look forward to his energy being available to the entire
  Struts project as well.
</p>
<p>
  Welcome, Gary! .. And now you can process some of your own
  outstanding code diffs :-).
</p>
<p>
  PMC vote: 5 +1
</p>
<hr/>

<h4 id="a20050715">15 Jul 2005 - New Struts Committer: Wendy
  Smoak</h4>
<p>
  Please join me in welcoming Wendy Smoak as a new Struts
  committer.
  Wendy has been a tremendous asset to the Struts community for
  several years now,
  providing unflagging support to the user base as well as
  invaluable input and feedback to the development team.
  We look forward to her continued contributions as a committer.
</p>
<p>
  Welcome, Wendy!
</p>
<p>
  PMC vote: 7 +1, 2 +0.
</p>
<hr/>

<h4 id="a20050526">26 May 2005 - Struts 1.2.7 (General
  Availability)</h4>
<p>
  The Struts team is pleased to announce the release of Struts
  1.2.7 for
  General Availability. This release includes new
  functionality, as well as numerous fixes for bugs which were
  reported
  against the previous release, and supersedes the earlier 1.2.4
  version
  as the latest official release of Struts from The Apache
  Software
  Foundation.
</p>
<p>
  The binary, source and library distributions are available
  from the
  <a href="http://struts.apache.org/download.cgi">Struts
    download page</a>
  .
  The
  <a href="http://struts.apache.org/userGuide/release-notes.html">
    Release Notes</a>
  are available on the Struts web site.
</p>
<hr/>
<h4 id="a20050331">31 March 2005 - New Struts PMC Chair</h4>
<p>
  <a href="http://struts.apache.org/dev/volunteers.html#martinc">
    Martin Cooper</a>
  has been appointed
  <strong>Struts PMC Chair</strong>
  by the ASF Board at their
  <strong>February 2005</strong>
  meeting.
</p>
<p>
  <a href="http://struts.apache.org/dev/volunteers.html#craigmcc">
    Craig McClanahan</a>
  stepped down
  as the Struts PMC Chair in February 2005. In Craig's words "I
  will continue to be active, but it's time
  for someone else to take the administrative
  responsibilities.".
</p>
<p>
  The Struts PMC nominated Martin Cooper as their preferred
  choice for the Struts PMC
  Chair to the ASF Board which was approved unanimously. Minutes
  of the ASF Board meeting should
  be available
  <a href="http://www.apache.org/foundation/board/calendar.html">
    here</a>
  in due course.
</p>
<hr/>

<h4 id="a20050225">25 Feb 2005 - New Struts Committer: Hubert
  Rabago</h4>
<p>

  We are pleased to announce that Hubert Rabago has accepted an
  invitation to join the
  Struts development community as a committer. We were impressed
  by Hubert's sustained
  participation in both the user and dev mailing lists, where he
  has demonstrated
  knowledge and respect for the community. He has clearly put
  considerable energy into
  how Struts works, both from a code perspective as well as a
  community perspective.
</p>
<p>
  So, we've begun the formalities to get his account set up and
  such, and we look forward
  to the day when we can tell him to commit his own darn
  patches.

</p>
<hr/>

<h4 id="a20050217">17 Feb 2005 - New Struts subproject: Struts
  Flow</h4>
<p>
  The Apache Struts team is pleased to announce the adoption of
  its latest
  subproject, Struts Flow, a continuations-based approach to
  complex web
  workflows. Struts Flow orginated at the struts.sf.net project
  and has
  been formally adopted now as a Struts subproject. Struts Flow
  is a port
  of Apache Cocoon's Control Flow to Struts to allow complex
  workflow,
  like multi-form wizards, to be easily implemented using
  continuations-capable Javascript and eventually Java.
</p>
<p>
  Today, Struts is comprised of nine subprojects: Core, Taglib,
  Tiles, El,
  Faces, Scripting, Applications, Shale, and (now) Flow. Struts
  Flow is
  different from Struts Scripting/BSF as where scripting brings
  any
  BSF-supported scripting language to Struts Actions, Struts
  Flow works on
  redefining the traditional Model 2 state-driven workflow into
  simplified
  scripots whos eexecute spans multiple requests. Currently, the
  Rhino
  engine, a Javascript implementation, is used to provide
  continuations
  support, but with the maturation of
  <a href="http://jakarta.apache.org/commons/sandbox/javaflow/">
    Commans Javaflow</a>
  - a Java-based continuations implementation,
  Java will soon be supported as well.
</p>
<p>
  For more information, visit the
  <a href="http://struts.apache.org/flow/index.html">
    Struts Flow website</a>
  .
</p>
<hr/>


<h4 id="a20050123">23 Jan 2005 - New Struts subproject: Shale</h4>
<p>
  The Apache Struts team is pleased to announce the adoption of
  its latest
  subproject, Struts Shale, a JSF-based framework. The Shale
  codebase was
  initiated by Craig McClanahan in the Struts sandbox, and
  development
  traffic regarding Shale has steadily increased. As the product
  is heading
  towards an initial release, the Struts PMC felt it time to
  formally adopt
  Struts Shale as a subproject.
</p>
<p>
  Today, Struts is comprised of eight subprojects: Core, Taglib,
  Tiles, El,
  Faces, Scripting, Applications, and (now) Shale. An initiative
  is underway
  to extract the Struts Tiles code into a standalone product.
  Several Struts
  developers plan to apply to the ASF to incubate
  <a href="http://wiki.apache.org/struts/TilesTopLevel">Tiles as
    a toplevel
    project</a>
  .
</p>
<p>
  For more about the Struts Shale subproject, see the
  <a href="http://struts.apache.org/kickstart.html">Kickstart
    FAQ</a>
  .
</p>

<p class="pull-right">
  <strong>Next:</strong>
  <a href="announce-2004.html">Announcements - 2004</a>
</p>

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