Neptune is a build tool with similar scope as Ant. There are two major differences between Neptune and Ant:

1. Neptune is based on command pattern. The Command interface allows an Object as return value, while Ant Task has no return value. The only way in Ant for a Task to communicate with other Task or the execution engine is through system property values, which are essentially string-only global variables.

2. Neptune is currently supported by the Jaskell scripting language, which allows flexible combinations of Neptune Command objects. Function, higher-order funciton, monadic combinators can all be used to reuse code and combine Command objects. While Ant is based on XML, which is not an ideal language for expressing logic.

Neptune currently delegates to Ant for most atomic tasks. All Ant core and optional tasks are adapted as Neptune commands with exactly the same set of properties and sub-elements as in Ant.

This means knowledge of Ant tasks can be reused in Neptune. All one has to do in order to call an Ant task in Neptune is:
1. check out the Ant manual for the supported properties and sub-elements.
2. call the ant task from within neptune with a different syntax. (not xml, but a neptune script)

A shell is provided to allow executing Neptune commands and Ant tasks interactively.

Please refer to http://jaskell.codehaus.org/Using+Neptune for details.

Jparsec is a higher order parser combinator framework written in Java.

It is not a parser generator like YACC or ANTLR. No extra grammar file is required. Grammar is written in native Java language, which also means you can utilize all the utilities in the Java community to get your parser fancy.

JParsec is best in senarios where a dynamic grammar or a context sensitive grammar is needed.

Feature highlights.

* operator precendence grammar.
* dynamic grammar.
* context sensitive grammar.
* Allow both traditional scan/parse approach and ad-hoc approach with 2-way communication between scanner and parser.
* accurate positioning of parse error.
* rich set of pre-defined reusable combinator functions.
* declarative API that resembles BNF.

JParsec can be downloaded at:
http://jparsec.codehaus.org

Yan Container (Yet Another Nonintrusive IOC Container) v0.2 is released.

Yan features open structure, declarative API, flexible component combination and totally pluggable life-cycle management.

Yan has no restriction on dependency injection method. Business object design is free to choose among public constructor, java bean getter/setter, regular java method and any variant and any combination of the above.

The Milyn Project has released Smooks v0.4 on the haus (milyn.codehaus.org). Smooks is a Component Framework that allows fine (or course) grained manipulation (transformation) of web content in a browser-aware manner. This means Smooks can be used to help build server-side solutions to:
1. Inter-browser incompatibilities.
2. Mobilise web content i.e. help make web content accessible on mobile browsers in a practical manner.

Where do you think the future of this framework lies? Is it a good or bad idea?

See milyn.codehaus.org.

The MevenIDE team is pleased to announce the MevenIDE for IDEA 0.1 release!

The MevenIDE for IDEA project aims to integrate Maven into the popular IntelliJ IDEA IDE.
This is the first release - your comments, suggestions, ideas and bug reports are welcome!

Features:

• A graphical Project Object Model (POM) editor. The editor includes a standard text editor, as well as an intuitive user interface for editing the various aspects of a project.
• Full synchronization between the POM text editor and the graphical POM editor, as well as with POM modifications outside the IntelliJ IDE.
• Automatic discovery of POM files (project.xml and maven.xml) for each IntelliJ module. The plugin will detect if you create one of these files either from inside the IDE or from outside, and will respond appropriately.
• A special Maven side pane (also called a Tool Window) displaying the available Maven goals for the project. The pane shows goals defined in the module's maven.xml file, and common goals, marked as "favorites" in the module settings dialog.
• Execution of selected goal(s) in a dedicated execution console which supports stop, pause, and re-run. The console supports copying the Maven output into the clipboard or into a text file.
• Compilation errors reported by Maven in the execution console are displayed as links, which open the appropriate source code file at the appropriate location.
• Auto-detection of your Maven home (via the MAVEN_HOME environment variable), and support for specifying a different Maven home (does not modify the environment variable).
• Easy installation via the IntelliJ IDEA plugins manager.
• Support for assigning shortcut keys (hot-keys) for specific goals for a specific module in the IDE (no need to find the goal in the Goals tool window).

Have fun!
-The MevenIDE team.

OpenEJB moved into the haus over the past month or so, basically unnoticed. So, notice it now!

OpenEJB is an open source, modular, configurable, and extendable EJB Container System and EJB Server.

jMock - A Lightweight Mock Object Library for Java was silently ushered under the umbrella of The Codehaus over the past month or three. Just doing the formal announcement so everyone can come mock us.

jMock is a library for testing Java code using mock objects.

Mock objects help you design and test the interactions between the objects in your programs.

Shocks has joined the haus. We're still in the process of migrating everything to our infrastructure, but we'd like to welcome N. Alex Rupp and his Shocks web framework.

Shocks is a departure from previous servlet framework technologies. It is conceptually unique in that it does not attempt to implement the "MVC" design pattern or any derivative thereof. It uses a next-generation architecture which cleanly separates the roles of its internal components. This makes the framework more flexible and modular.

The core of the Shocks project is a lightweight workflow engine. One of our goals is to support application workflows which span over more than one Action and/or Presentation component. Another goal is to support JSR-94--business rules based workflow processing (a la Drools).

The Haus would like to welcome GeoTools to the hacienda. We're supporting them with Jira at this point.

There's a bouncing new baby project at the Codehaus.

XStream is a simple library to serialize objects to XML and back again.

XStream requires minimal (if any at all) configuration for custom objects.

The XML produced is clean and concise and never duplicates any information that can be obtained via reflection.

XStream has a clean design, is simple to use, boasts impressive speed and is not coupled to any particular XML library.

http://xstream.codehaus.org/

Loom is a new start of development upon the Apache Avalon Phoenix codebase. Loom's forthcoming 1.0 release builds upon the unreleased Phoenix 4.1 development branch. It will provide a seamless migration for developers currently building solutions upon Phoenix

The development team is currently working towards a 1.0 release, and make it generally available before the end of August. In the meantime, please feel free to grab a copy of the CVS version and assist us in making the initial release the best it can be.

About Loom

Loom is a micro-kernel designed and implemented on top of the Apache Avalon Framework. Loom provides a number of facilities to manage the environment of Server Applications. Such facilities include log management, classloading, thread management and security. In the future it will conditionally support extra facilities such as central server management, server pools, and other facilities aimed at reducing the time to market. The API defines a standard method of piecing together server components and creating a server.

About JContainer.org

JContainer.org aims to become the first place Java programmers look for information on component oriented and container-driven development. Its goals include providing a clearinghouse of design and research papers on container architecture as well as a detailed listing of the various Java containers available today.

ivory-dev has been created to support discussion, probably mostly between Ryan and Dan, about ivory, the magical SOAP exposer.

Jonas Boner has moved AspectWerkz to Codehaus.

AspectWerkz is a wicked-cool AOP framework.