Open Source Java Community and OpenJDK Resources. Latest News, podcasts, Updates, downloads.

What is Sun announcing?

Fulfilling its promise to the world exactly one year later, Sun is releasing a fully buildable implementation of the JDK in the OpenJDK Community.

Specifically:

* Sun proudly announces that almost all of the JDK is now available under the GPL 6.5 million lines of code, one of the largest and most important contributions to the Free Software community in history.
* In conjunction with the NetBeans 6 preview release, Sun has created pre-built Netbeans projects to make it easy and intuitive to dive into the OpenJDK code base, making NetBeans and Sun Studio the gateways to participation in the OpenJDK project.
* Sun announces the formation of the OpenJDK Interim Governance Board with the charter to write and gain ratification for a Constitution for the OpenJDK Community, based on transparency and an open, meritocratic process. The IGB will invite active participation in this process, with the goal that OpenJDK governance will be representative of a broad and inclusive consensus reflecting the will of the whole community.
* Sun is creating a clear process for OpenJDK-based implementations of Java SE to test for compatibility starting with implementations of Java SE 6, and once certified, to brand their implementations "Java Compatible" while still meeting all of their obligations under the GPL. This process will advance the "Write Once, Run Anywhere" promise of Java Compatibility into the Free and Open Source software world, and guarantee that the innovations made possible by OpenJDK remain forever available to all.
* Sun announces a one year roadmap for the OpenJDK initiative, including clearing the remaining encumbrances, open sourcing an implementation of Java SE 6 and associated deployment code, implementation of the compatibility testing and branding program, and establishment of the governance and contribution model for the community.

Following on to Sun's November 13, 2006 announcement six months ago of the creation of the OpenJDK project and community, and the widely acclaimed choice of GPL v2 as the license for Sun's open-source JDK initiative, Sun is delivering in only one year on substantially all of its promises to the industry. Building on this momentum, Sun has solidified its position as the pre-eminent contributor to the F/OSS ecosystem.

What is the significance of this announcement to the industry?

This announcement takes open-source, compatible Java from a long-standing dream of developers worldwide, to concrete reality. With the open sourcing of the code base for one of the industry's most significant and pervasive software platforms, the groundwork has been established to foster adoption in new markets, to build broader communities, and fuel even more innovation. With over 5.4 billion Java technology enabled devices, Java technology has already demonstrated explosive growth, appearing in volume nearly everywhere. Now, as free software, the Java platform can address new markets and be the engine of innovation for the next generation of networked applications.

What is the OpenJDK Community?

Sun has established the OpenJDK Community for the ongoing development of Sun's open-source implementation of Java SE. The OpenJDK Community is where developers gather to collaborate on the open-source JDK code base and related projects. The OpenJDK project in which the open-source code base lives is part of this community. Through the OpenJDK project, developers can directly influence the future of the JDK implementation, participate with their peers in an open community and help take Java technology where it hasn't been before. Sun evolved the earlier JDK Community, where developers worked on the source code the two years prior to open-sourcing the JDK, into a site where Sun and non-Sun developers alike can collaborate together on the implementation. The OpenJDK Community can be found at http://openjdk.java.net

What components of the JDK software are you open sourcing today?

In November 2006, Sun open sourced the Java programming language compiler ("javac"), and the Java HotSpot virtual machine. In addition, Sun open sourced the JavaHelp 2.0 extensible help system, Sun's reference implementation of JSR 97. Now Sun is open sourcing most of the remaining components of the JDK, with the exception of a few encumbered components that we hope, with the community's help, can be re-implemented so that 100% of the OpenJDK code commons is available as free software.

Specifically, which components of the JDK are being added today to the OpenJDK project's code base?

The following components are newly open sourced under GPL version 2 plus the Classpath Exception:

* Core libraries
* Networking libraries
* Security libraries
* Serviceability libraries
* Internationalization libraries
* 2D graphics subsystem
* AWT, the Abstract Windowing Toolkit
* Swing GUI toolkit
* Sound subsystem
* Various tools, including JConsole and javadoc

Is the entire OpenJDK code base under the GPL?

Yes, much of the OpenJDK code is licensed under the GPL version 2 with the Classpath exception. The Java Hotspot virtual machine source code is licensed under the GPL version 2 only. All of Sun's Java platform implementations are or will be licensed under the GPL version 2, or GPL version 2 with the Classpath exception. The GPL is endorsed by the Free Software Foundation, and is the license used by the GNU/Linux operating system.

When will you finish clearing encumbrances? What is the timeline?

With the community's help, we hope that encumbered code can be re-implemented over the next 6 to 12 months, balancing this critical engineering task with other priorities, and depending on the level of community participation in speeding this effort.

Will Sun continue distributing its commercial implementation of the JDK?

Yes. For people who want the benefits of commercial support, and predictability, they may choose to use Sun's commercial distribution of the JDK or JRE. The free commercial implementation of the JDK may be found at http://java.sun.com/javase/downloads/index.jsp. Similarly, Sun's free JRE may be downloaded from http://java.com. To learn more about development and deployment support options, visit http://sun.com/javasupport.

Will Sun's commercial JDK releases be built from the open-source code?

Yes, for the most part. Since there's some encumbered code in the JDK, Sun will continue to use that code in commercial releases until it's replaced by fully-functional open-source alternatives. In addition, Sun may deliver more differentiated commercial JDK products that address specific market needs in the future with these variants still built from the open-source code.

Are you open sourcing the Java language or the Java SE platform specifications?

Since both of these are documents and not source code, there is no source to open! Thus, while we are open sourcing Sun's implementations of both, we cannot "open source" the Java programming language, nor the platform APIs and specifications, which are governed by the JCP.

Which version of the JDK do these components come from? Are you open sourcing the latest code?

We're open-sourcing these components from an early build of JDK 7. JDK 6 is the current shipping production release, and is stable. Hence we're releasing these components from the JDK 7 tree. At this stage, the only significant differences between the JDK 6 and 7 versions of these components are minor bug fixes and enhancements that have already been integrated into the JDK 7 tree. JDK 7 is the next feature release where all the action will be for innovation and new capabilities.

Didn't you promise to open source both JDK 6 and JDK 7 last November? What happened to JDK 6?

Sun did make that promise, and we plan to keep it. But in the six months since the November 2006 announcement, it has become clear that doing this is far more complex than just changing the license and publishing the source code. JDK 6 is a stable, production release that millions of developers and users depend on. Sun's Java platform release engineering processes have evolved over 12 years to insure this stability, based on very tight control over changes. We don't yet know how to open source a stable release in a way that maintains the robust quality and compatibility characteristics consistent with this tight control, while creating a community that attracts innovation and participation. We have some ideas on solving this problem based on the inherent differences between established APIs and new platform directions. We're looking forward to working with the community to adjust the release cycle and processes to solve this problem.

The OpenJDK code base is huge! How do I know what each component does, and where to begin?

Hacking on the OpenJDK project can be daunting for those just starting out. Even the most experienced Sun engineers who've been working on this code base since the first line of code was written find it necessary to specialize and focus on specific modules. A solid grounding in the language and platform are a must for working on this project, but for the aspiring systems programmer or experienced Java developer there are many interesting opportunities in such a large body of code. Find the elements that interest you most, study the APIs and javadocs, then dive into the code to see how these APIs are implemented, search the bug database for interesting problems to solve, and get going! It might be tough going at first but you can join the community discussions and get some help and advice, and enjoy the satisfaction of working on one of the most widely used programs in all of computing. We will be providing a list of suggested "starter bugs" on our community site, to give you some ideas where you can get started.

Where do developers go to participate in implementing these JDK components?

Developers can gain immediate access to these components under the open-source license by visiting https://openjdk.java.net. NOTE: The URL has changed and been simplified with this announcement!

How can I get involved?

Visit the OpenJDK Community at http://openjdk.java.net and check out the projects, mailing lists, pointers to blogs, and other opportunities to participate. Sun, and indeed the whole Java technology ecosystem, welcomes any and all suggestions, bug fixes, and contributions of code, ideas, and energy.

With this announcement, how is the governance model for the OpenJDK projects evolving?

Sun is pleased to announce the formation of an Interim Governing Board for OpenJDK, and a charter for this board to create the new, community focused governance model for OpenJDK featuring transparency and an open, meritocratic process. The IGB will invite the community to join in discussing and debating its own structure and rules, and the resulting model will reflect the will of the OpenJDK community. For more details on the IGB, the charter, and the roadmap to establishing the steady-state governance model for OpenJDK, please see the Governance section of this FAQ. In the interim, Sun will establish the needed processes and governance criteria (as required) for community interaction and projects to operate effectively.

With the JDK nearly completely available under the GPL, and working implementations based on OpenJDK code on the horizon, both the promise and peril to compatibility of an open-source Java platform are upon us. How will Sun make the JCK (the Java SE TCK) available, and provide access to the "Java Compatible" brand?

Sun understands the importance of compatibility. In fact, most users, developers, source licensees, open-source contributors and leaders indeed most of the Java technology world all agree that compatibility is essential to the value of the Java SE platform. For that reason, Sun will establish a clear process for the Java SE TCK (JCK) to be available to developers who need to verify the compatibility of OpenJDK-based implementations. Please see the TCK section of this FAQ for more information.

What is the Mobile & Embedded Community?

The Mobile & Embedded community establishes a central location for the open-source development of Java ME technologies and applications. This community has been launched on java.net and can be found at the following URL: http://community.java.net/mobileandembedded. It currently includes the phoneME project, the cqME project, and the application developer project. In the future we anticipate that this community will grow by adding additional Java technology and application projects.

What license did you choose for Java ME?

The phoneME project is where Sun is releasing its phone implementations for Java ME. It has a single repository that consists of various active development modules including CLDC, CDC, MIDP, and various JSR implementations.

What is the cqME project?

Java ME code is licensed under GPL v2, as are all of our Java implementations.

What parts of Java ME has Sun open-sourced?

Sun has open-sourced its implementations of Java ME. Available since November 13, 2006, are the source code for Sun's feature phone implementation called the Sun Java Wireless Client (based on the Connected Limited Device Configuration, CLDC), and the advanced OS phone implementation (based on the Connected Device Configuration (CDC) specification). The Java Wireless Client is the next generation version of the platform that currently enables rich mobile data services in over 1.5 billion handsets.

Sun has also open-sourced its compatibility and quality testing tool frameworks. This includes the source code for the Java ME TCK Framework, the foundation for Sun's Java ME compatibility tests. We believe this project can help to standardize the industry on a single framework to simplify the testing process. In addition, Sun has open-sourced the Java Device Test Framework, the foundation for the quality and function tests. This project enables developers to create new tests, reducing implementation variation and enabling their applications to run across multiple devices.

What is the feature phone implementation?

The feature phone implementation is a Java runtime designed to run on today's mass-market handsets.

What is the Advanced OS phone implementation?

What is the Advanced OS phone implementation? A: The Advanced OS phone implementation is a Java runtime designed to run on operating systems targeting advanced mobile devices like smartphones, set-top boxes, etc.

Will Sun's implementation be built from open-source code?

Will Sun's implementation be built from open-source code? A: Yes, Sun's implementations for feature phones and advanced OS phones will be based on the open-source code base.

What can a developer do immediately with the CDC and CLDC code bases?

A developer is able to build both the feature phone and the advanced OS phone code bases now that these are open-sourced. Developers have the opportunity to download, evaluate, and play with the source code, and help in its ongoing development.

Will Sun continue to ship commercial implementations?

Yes, Sun will continue to ship commercial implementations for feature phones and advanced OS handsets under Sun's commercial licenses.

What is the difference between the open-source and the commercial code bases?

The differences include encumbrances and some minor modifications to the source code such as splash screen, logos, license, header files, etc.

What can a developer do with the framework code bases?

A developer can use these frameworks to drive testing of compatibility tests for new mobile JSRs, and create tests to improve the quality of implementations.

Where do developers go to participate in the Java ME projects?

The Mobile & Embedded community has been created to enable platform developers and application developers to participate. Visit http://community.java.net/mobileandembedded for more information.

What is the phoneME project?

The cqME project (compatibility and quality) is where Sun has released the source code and is doing the active development on the Java ME TCK Framework. In the future, Sun will release into this project the source code and engage in the active development of the Java Device Test Framework.

What is the Application Developer project?

The Application Developer project provides resources to developers and a place to engage in the development of open-source Java ME applications. The project is the home for the new developer guidelines that were created in partnership with Orange. These guidelines will help developers minimize porting efforts. This project is also a home to open-source Java ME application projects.

How can developers use the NetBeans IDE to get started in working with this code?

In conjunction with the NetBeans 6 Preview Release, Sun has created pre-built NetBeans projects and incorporated this project metadata directly into the newly open-sourced OpenJDK code base. This NetBeans integration makes it intuitive and easy to use NetBeans and also Sun Studio to dive into the OpenJDK source code and begin working on the platform right away. Once you've inspected the code and made changes, the NetBeans "Build Project" command lets you easily build modules. For more information and a step-by-step tutorial, please visit http://nb-openjdk.netbeans.org

Why is Sun open sourcing its Java implementations now?

The Java platform is 12+ years in the making. When it was first released it was a radical departure for commercial software, including full source code under a novel license. Sun and the Java ecosystem have been extremely successful at establishing and growing a very large and dynamic market in this time. The Java platform retained its own licensing model even as the open-source model proliferated, because the Java licensing model successfully created a large and open market with many compatible choices. We now see an opportunity to encourage even more possibilities for adoption in places the Java platform hasn't gone before, where Free licensing and open-source development approaches are a prerequisite for consideration.

At the same time, the Free software and open-source communities are now saying that compatibility is a given for any Java implementation. And there is a new spirit of innovation with Web 2.0, SOA and collaboration/participation technologies, and the Java platform is the perfect foundation platform on which to innovate - and open-source can help accelerate this innovation.

What influenced this decision?

Key Free software and open-source communities have stated that they believe that only Java technology implementation that are completely compatible with the specification can succeed in the market. These communities, which provide thought leadership for the open-source Java world, are now focused on delivering only compatible implementations. In addition, Sun has gained experience in community development with the Project GlassFish open-source implementation of Java EE, with OpenSolaris, with OpenOffice.org and NetBeans, and with the JDK Community on java.net. This experience makes us confident that when we open-source Sun's Java implementations, the platform will benefit, and we can better balance the needs of community with those of customers, end users, and licensees.

Overall, we feel that caution is appropriate for a technology that affects the lives and livelihoods of tens of millions of people around the world. After much reflection we feel now is the perfect time to take the next step with the Java platform.

Why is this good for Java SE developers?

Because volume wins. Open sourcing Sun's Java SE implementation will lower barriers to adoption in markets where open-source software leads. As new markets adopt Java technology, developers will discover new opportunities. More applications. Innovations that leverage the industrial strength foundation of Java to deliver valuable new products and services. And developers will be able to directly influence the future of the JDK implementation, participating with their peers in an open community. Taking Java where it hasn't been before, and helping to ensure that Java technology remains a central unifying standard for the Internet.

How does this benefit Java SE customers and users?

Your investment is safe, with multiple independent implementations of Java SE, and the reference implementation from Sun available under an open-source license. An open-source JDK provides peace of mind, plain and simple:

* You can adopt Sun's Java technologies with full confidence. Java SE will be freely available - subject to the market forces that drive competition, reduce price and speed innovation.
* Whether you value Free and open-source software for philosophical or economic reasons, want more flexibility, appreciate the quality that transparency brings, or want to know you have ultimate control over your investment, you can adopt the JDK knowing that you'll gain these advantages.
* With the rock-solid, high performance JDK implementation from Sun under the same open-source license used by GNU/Linux distributions, you can expect Java technology to find its way onto new platforms, be leveraged for new applications and infrastructure, and be the foundation of tomorrow's most exciting new products and web technologies.

Your investment in Java technology will become even more valuable as open-source speeds innovation, spreads adoption, and carries the platform to places it couldn't previously go.

What markets do you believe this initiative will open up for the JDK?

Several markets are likely to find the JDK to be more suitable for use once it is under an open-source license:

* Government, educational, and research markets where open-source software is either mandated, or highly desired.
* Enterprises that mandate open-source infrastructure to retain maximum flexibility and drive competitive procurement.
* Enterprises and organizations that have selected OS distributions based on GNU/Linux and OpenSolaris as preferred OSs for deployment.

In order to gain the benefits of commercial support, and predictability, these customers may choose to use Sun's commercial distribution of the JDK or JRE in conjunction with a support contract. However, they might not consider the commercial product if the open-source version were not available.

What impact will this move have on the adoption of the Java SE platform?

The Java platform has been very widely adopted already - it is one of the most important and widely used components of modern web-based infrastructure. But there remain un-tapped or under-served markets. In particular, Java technology is not always included in open-source web infrastructure stacks that are commonly distributed and deployed alongside and included with GNU/Linux distributions. Those that do include Java technology often do not include an up-to-date, compatible runtime and development environment. We continue to work with the GNU/Linux distributions to get the JDK included as part of the free software repositories commonly included with these open-source operating system distros. Once the JDK is easily obtained and installed with these platforms, we expect to see more widespread adoption of Java technology especially outside of North America and Western Europe, as well as in cutting edge web infrastructure deployments worldwide. Since the GPL is a very widely used open-source license (in fact it's the same license used by GNU/Linux), distributing the JDK under the GPL with GNU/Linux distributions should be a good match, making it easier to adopt by those looking for open-source alternatives.

What are your goals in open sourcing Sun's Java ME implementations?

To remain the number one mobile application development platform*, Java ME needs to grow and evolve. This means engaged developers, accelerated innovation, and a more consistent implementation across devices.

Who benefits from open sourcing Java ME?

Everyone in the Java ME ecosystem benefits from open sourcing Java ME. Benefits include:

* simplified evaluations,
* transparent development,
* opportunities to directly influence the future of the platform

By open sourcing these implementations, handset manufacturers can leverage the common code base to reduce their development costs. The result will be less variation across devices P in other words, Write Once, Run Anywhere taken to the next level.

Both application developers and operators will benefit from the accelerated innovation, enabling developers to continue to create compelling applications and services, which in turn help drive revenue. Operators and handset manufacturers will benefit from lower porting, testing and maintenance costs.

What does Sun mean by "compatibility?"

Compatibility for a Java technology means the implementation of that technology meets the associated compatibility requirements of its Technology Compatibility Kit or TCK. For Java SE this means passing the TCK tests and other requirements defined in the Java SE TCK, known as the JCK.

Do you think anyone will fork the JDK?

We expect great new ideas and valuable research to come from adaptations (i.e, forks) of the platform. Sun encourages compatible forks where the code is ported to additional hardware and software platforms. Such ports extend the breadth of Java SE to places currently not supported by any vendor. Broad distribution of incompatible forks is potentially a danger since such forks could damage the "Write Once, Run Anywhere" compatibility value of the Java platform.

So, what about compatibility? How will Java technology remain "Write Once, Run Anywhere" since Sun's Java platform implementations are open sourced?

The Java technology compatibility promise is so central to the value of the platform that it has been the single most important influence in driving the detailed planning and decisions for this initiative. Sun is making a number of key decisions and commitments to the community that we believe will help foster compatibility:

* License: GPL makes proprietary forks less likely, as all changes must be published.
*
* Branding: the Java trademark and logos are for compatible implementations only.
* TCKs: Sun will make TCKs available to OpenJDK-based implementations for testing compatibility.
* JCP: the JCP's role as the governing body for Java standards and evolution is not changed by this move.
Community Development: Sun's experience in building strong communities means developers will likely find the governance and infrastructure to their liking.

In addition to the specific steps that we're taking to help foster compatibility, we are convinced that the market will demand compatible implementations, and that incompatible ones won't gain traction. With the billions of dollars of Java applications in the installed base, the community has recognized that a Java implementation that doesn't run the installed base of code won't get very far. That is why both the GNU/Classpath and Apache Harmony projects have stated unequivocally that they're working to build fully compatible implementations of Java SE.

We have experience in the Java EE world to back this up: there are four compatible, open-source Java EE implementations in the market including Sun's GlassFish Application Server, and no incompatible variants have achieved any market penetration. We expect the same dynamic to happen with both Java SE and Java ME platforms.

What do Java SE customers buy from Sun?

The JRE and JDK binaries themselves will remain zero cost downloads. End-user customers can buy subscriptions and one-time engagements for enterprise-class support from Sun for Java SE, including:

* High quality, optimized performance binaries released on a predictable schedule.
* Packaged updates, patches, and security fixes.
* Break/fix support including customer-specific bug fixes delivered out of cycle.
* Branding: Access to trademark and logo licenses including "Java Powered".
* Installation, custom engineering services.
* Training, education.
* Developer support.

Commercial source code licensees may optionally buy additional services and gain additional rights, including:

* The right to ship binaries derived from custom modified source code.
* The right to make modifications to the source code without putting those modifications back into the open-source code commons.
* The right to use the "Java Compatible" logo for compliant custom implementations.
* Porting services.
* Custom development and engineering support services.
* Upgrades and updates to the source.
* Performance tuning services.
* Binary support.
* Testing services, including TCK testing.
* Training.

In addition, some customers needing specialized versions of Java SE for embedded and real-time applications may purchase licenses to these added-value implementations. We're also investigating support services that could be offered optionally to customers who prefer to "do it themselves" using the open-source code base, but need a bit of additional help.

Why purchase these added value services and implementations from Sun?

Sun, the only systems vendor to have open-sourced nearly its entire software portfolio, enables customers to leverage a number of unique advantages that only it can offer, including:

* The economic advantages of the open-source business model through a larger range of the stack.
* Recognized "gold standard" Java SE and Java ME implementations on which the open-source communities are eager to innovate.
* Choice of GPL license that maximizes the value of the open-source code commons and maximizes incentives for compatibility, while creating an opportunity to monetize commercial licenses and support services for licensees.
* The ability to tap many of the key architects and creators of Java technology, including for support and tuning services.
* Systems optimized to run Java applications with superior throughput, power, and space characteristics.
* Development tools including NetBeans and Sun Studio that deliver increased productivity for developers.

In addition, Sun brings unique expertise and knowledge of both Java technology and open-source best practices to the table. This combination will help Sun establish OpenJDK as the most compelling open-source community for innovation, allowing Sun to gain maximum benefit from the open-source initiative. Some of these advantages include:

* Experience at both understanding and balancing the needs of the diverse and complex Java ecosystem.
* Unmatched developer outreach and community development expertise.
* World-class ability to combine rigorous, enterprise-class development processes and open-source transparency, bringing together the best of community development with top-quality, on-time delivery of commercial products.
* Proven success at delivering scalable community infrastructure that manages the largest open-source projects on earth.
* Vision and commitment to participation, transparency, open development, and collaboration.
* Deep understanding of F/OSS community concerns and aspirations, and a practical perspective on balancing the needs of community with the interests of customers.
* Best practice policies and procedures for taking large code bases open source, balancing concerns and monetizing adoption and ubiquity, all while respecting intellectual property rights.

How will Sun's Java ME business be affected?

Sun is confident that licensees will continue to leverage Java ME commercial products and services that help them deliver an exciting and compelling mobile internet experience to consumers. As a result, we expect our business opportunities to multiply based on the improved economics that easy access to source code will bring.

What license did you choose for the open-source JDK components?

GPL v2 for almost all of the virtual machine, and GPL v2 + the Classpath exception for the class libraries and those parts of the virtual machine that expose public APIs.

What license did you choose for implementations of Java ME and the Java ME frameworks?

GPL v2 was chosen for all components related to Java ME.

What is the Classpath exception?

The Classpath exception was developed by the Free Software Foundation's GNU/Classpath Project (see http://www.gnu.org/software/classpath/license.html). It allows you to link an application available under any license to a library that is part of software licensed under GPL v2, without that application being subject to the GPL's requirement to be itself offered to the public under the GPL.

Why do you need the Classpath exception?

If an application is distributed with an implementation of Java such as the JDK under GPL v2, that application could be subject to the requirements of the GPL that all code that is shipped as part of a "work based on the [GPL] program" also be GPL licensed. Accordingly, a GPL license exception is needed that specifically excludes from this licensing requirement any application that links to the GPL implementation. The Classpath exception accomplishes this. Without the Classpath exception, a Java SE implementation licensed under GPL v2 could not practically be distributed with non-GPL licensed Java applications. This could present a serious barrier to adoption, for example by OpenSolaris or GNU/Linux distributions if left unaddressed.

Why did you choose this licensing method?

This is the licensing paradigm in common use within Free software communities such as GNU/Classpath and Kaffe for the components of a Java technology implementation including the virtual machine and class libraries. We consciously chose the same licensing method so that there would be no temptation to second guess Sun's intention to make its Java SE implementation available under a genuinely Free and open license and to allow easy collaboration with these existing communities.

Are you licensing the entire JDK under this method?

Yes. Note that some of the code included in the OpenJDK project is not part of the Java Runtime Environment, but rather is part of the tools and documentation that let developers use the JDK to create and test code, as well as some demo and sample application code. See below for specifics on how each of these modules is licensed.

What about source code in the JDK that originated outside of Sun and is incorporated into the JDK under its own license? Can you relicense this code under the GPL?

Where such licenses are compatible with the GPL, then this code is licensed under the GPL in the OpenJDK code base. There are some code modules that Sun may not have the right to release under the GPL. We're still investigating some of the license compatibility issues and hope to resolve them as quickly as possible. In the mean time this code will be released only as binaries if the source is proprietary or as source under its original open source license.

How can you ship the JDK with binary-only elements then? You said there were encumbrances.

Well spotted! Because there are encumbered components that must be shipped without source. The Software Freedom Law Center and the Free Software Foundation have helped us craft a special exception to the GPL, called the Assembly exception, to allow the full JDK to be built. This exception will be applied temporarily until the encumbrances are removed to these binary plugs. We would welcome your help to make this happen as soon as possible. In addition, the Assembly exception is needed to allow Sun to combine in a single collected work components under both GPL, and GPL plus the Classpath exception. Without the Assembly exception, the entire OpenJDK code base would have to be licensed under GPL without the Classpath exception.

What are the advantages of GPL v2?

As well as fulfilling its original purpose of promoting Free software, the GPL v2 is designed to help advance projects and code commons by requiring innovation sharing with the commons. By design, it minimizes proprietary forks by requiring any modifications be shared with the project. GPL v2 is the right license to preserve Java's trademark "Write Once, Run Anywhere" value proposition.

What rights do developers have under GPL v2 + Classpath exception?

The best source for answering this question is the license itself . In addition, there have been numerous analyses of the GPL license and its terms, not least by the license stewards, the Free Software Foundation . Sun recommends studying these interpretations, and consulting legal counsel as necessary to understand your rights under this license.

What must I do to call my software based on code from the OpenJDK or phoneME projects "Java"?

The requirements for the use of the "Java" trademark and name have not changed with the open sourcing of the JDK and Java ME source code. The GPL v2 does not include a trademark license - no OSI-approved open-source licenses do. Sun does not currently have a licensing program that permits the use of the "Java" mark in your product or company name. You can use a truthful "tagline" however associating your product or company with Java technology, according to Sun's standard terms for use for trademarks. Please see http://www.sun.com/policies/trademarks/ for more details.

How are the regression tests you have released as part of the buildable OpenJDK code base licensed?

GPL v2 only. There are a small number of files that have no license in the file itself. These files are all licensed under GPL v2 only, as the entire combined work constituting the OpenJDK code base is under GPL v2. These files are mostly data files used in certain tests, for which no provision has been made for comments, and thus which cannot be modified to include the GPL v2 header.

What about GPL v3? Have you considered using that license?

While Sun has been working with the Free Software Foundation as an active participant in the development and review of the GPL v3 license, and while the license is in a late review phase, it is not yet complete. It is Sun's strong desire to advance the open sourcing of its Java technology implementations in a timely manner, so we made the decision to use an existing, established license paradigm rather than wait for GPL v3 to be completed. Using GPL v2 does not indicate anything negative about GPL v3. Sun continues to be very actively and positively involved in this new license's development.

What do you mean by "encumbered code"?

Some parts of the JDK and Java ME implementations include code to which Sun may not hold sufficient rights to release under a license that allows third parties to create unlimited sublicensable derivative works. These rights are necessary to allow release of these implementations under the GPL v2. Those parts of the code for which we don't have these rights are said to be "encumbered".

What do you mean when you say that you are now shipping a "fully buildable" JDK?

We have released as much of the source code as possible under the GPL. However, there are encumbered modules in the first buildable release of the OpenJDK code base. In the short term we are providing a separate bundle of binaries compiled from these sources that can be combined with builds of the GPL'd sources to yield a complete, working JDK. We hope to rewrite these components to remove the closed-source code - and we welcome your help!

What are the encumbered components in the JDK?

The larger encumbered components requiring binary files for a full build include the font rasterizer, the graphics rasterizer, and the sound engine. Smaller components include some cryptographic algorithms, some SNMP code, and some of the imaging APIs.

How will the encumbered binaries be licensed? Will I be able to redistribute a JDK built from the GPL'd sources and the encumbered binaries?

The Assembly exception allows downstream redistribution of such a JDK. For more on this subject see "Licensing".

I'd like to help clear the encumbrances in the OpenJDK code base. How do I get started?

We're opening sub-projects under the OpenJDK project on java.net focused on the major encumbrances that need to be addressed so that OpenJDK can be 100% free software. These projects and their URLs are:

* Java 2D Font Rasterizer
* Sound Engine

And we will soon launch another project to cover Java 2D Graphics Rasterizer.

Will everything in the Java ME feature phone and advanced OS phone implementations be available in open source?

No, there are several encumbrances in these phone implementations. These encumbrances include support for specific phone hardware, graphics engine, sound engine, etc. All of these components and any other encumbered code will not be included in the open source code base.

How will encumbered code in the Java ME code base be managed?

Sun is actively negotiating with Intellectual Property (IP) owners to gain the rights to add the encumbered code, if any, to the open source code base. We will try to clear encumbrances with open-source or other reasonable alternatives. Implementations including encumbered components will continue to be made available via commercial license.

Its great that the community has access to the source code now, but what about documentation? What are your plans for providing developers and publishers access to documentation that enables the openness and sharing that are the goals of the open-source Java initiative?

Sun recognizes that restrictions on how documentation can be created and disseminated would limit many beneficial activities such as training programs and materials, and added-value third party websites. We are re-examining our Java platform documentation policies with community development in mind and will implement a new policy in keeping with the spirit and enabling the opportunities made possible by Java as free software.

Given that the Javadoc content is embedded in the newly GPL'ed OpenJDK code, and the Javadocs can be generated by running the javadoc tool, aren't the Javadocs now also under GPL?

Yes. The documentation that can be generated by running the javadoc tool over the open-source code base is a derivative work of this code base and as such, must also be licensed under the GPL.

So then, is the Java SE Platform Specification now GPL'ed as well?

No. Although the Javadocs are the primary documentation for application developers, they form only a small portion of the Platform Specification, which includes several other important, normative documents (prescriptive parts of the standard) including the Java Language Specification, the Java Virtual Machine Specification, and other ancillary specification documents that are referenced from the Javadocs. It is important that there be a single, definitive specification for the Java Platform, and for this reason the complete Platform Specification is not being open-sourced. It remains under the auspices of the JCP.

Where can I see the complete Platform Specification? Under what license is it available?

Sun is in the process of finalizing a Platform Specification for Java SE 6. Once complete, it will be endorsed through a JCP maintenance review of Java SE 6, and then published. The Platform Specification is made available under the Java Specification License. The Java SE 6 version of this license can be found at http://java.sun.com/javase/6/docs/legal/license.html.

How will Sun promote redistribution of documentation in ways that foster adoption, while respecting and protecting the Java Specification?

As the earlier answer explained, there will always be a single, definitive version of the Platform Specification. However, we plan to create a new "Developer Documentation" bundle that can be licensed for redistribution. Initially this will contain only the Javadocs, but we hope to add other materials such as tutorials and guides later. Links from the Javadocs to other documentation will point back to the relevant documents on the java.sun.com website.

Under what license will this Developer Documentation bundle be offered?

The bundle will be available under two different licenses.

* A commercial license that permits redistribution, but does not allow for modification or creation of derivative works. This license will be most useful for publishers who are seeking to include the bundle with other material as a combined work, and who would prefer not to offer the entire work under the GPL.
* The GPL, as mandated by the inclusion of the Javadocs in the GPL'ed OpenJDK code base. We expect a GPL-licensed Developer Documentation bundle will be most attractive to distributors offering an OpenJDK-based implementation.

You will be able to select whichever license you prefer.

Why not use the GNU Free Documentation License (GFDL) or a Creative Commons License? Wouldn't one of these licenses, designed specifically for documentation and written works be more appropriate than the GPL?

Since we expect that most redistributions of the Developer Documentation bundle will be incorporated into products that also include source code, we felt that the GPL rather than a documentation-only license would be more appropriate.

Now that the Javadocs will be available under the GPL, how can developers collaborate on improving them?

Sun intends to build a new dynamic documentation portal on java.sun.com to bring the power of collaborative development to Java developer documentation. While the specific plans for this portal have not been finalized, we expect it will include features such as:

* Annotations
* Code samples
* Discussion forums
* Translations
* Links to external references

This will be a significant new resource for the entire Java community to use and an exciting new way for developers to participate.

Roller is the open source blog server that drives Sun Microsystem's blogs.sun.com employee blogging site, IBM DeveloperWorks blogs, thousands of internal blogs at IBM Blog Central, the Javalobby's 10,000 user strong JRoller Java community site, and hundreds of other blogs world-wide. Read more about Roller on the About page.

Roller supports all of the latest-and-greatest weblogging features such as group blogging, RSS and Atom newsfeeds, rich-text editing, customizable page templates, comments, trackbacks, referrers, blogroll management (with OPML) and provides an XML-RPC interface for blogging clients such as Ecto, MarsEdit and w:bloggar.

The Roller project is in the process of moving to the Apache Software Foundation (ASF) and is currently part of the Apache Incubator program. The ASF incubation process is designed to ensure that projects entering Apache have a strong and diverse community, have Apache compatible licensing and work according to the ASF's philosophy and guidelines for collaborative development.

For more information on Roller, see the Roller WIKI

Project Home Page

http://rollerweblogger.org/project/

Downloads

http://cwiki.apache.org/confluence/display/ROLLER/Roller+Downloads

Documentation:
http://cwiki.apache.org/confluence/display/ROLLER/Roller+Install+Guides

A Java-based, full-featured, multi-blog, multi-user software package.
The software behind Apple's Mac OS X Tiger Server Weblog Server.

A lightweight blog package written in Java that is inspired by blosxom. blojsom aims to retain the simplicity in design of its Perl-based "relative" while adding user flexibility in areas such as the flavors, templating, plugins, and the ability to run a multi-user blog with a single blojsom installation.

Features:

blojsom is a full-featured, multi-user, multi-blog package written in Java. blojsom aims for simplicity in its design while adding flexibility in areas such as the flavors, templating, plugins, and the ability to run a multi-user blog with a single blojsom installation.

The following list highlights some of the more important aspects of blojsom.

* Setup and Installation
o Can be deployed to any Java application server.

* Administration
o Can be administered using your web browser.

* Multiple Blogs/Multiple Users
o Allows you to run multiple blogs on one installation of the software.
o Supports any number of users per blog.
o Stores separate configuration information per blog.
o Permissions can be assigned to users on an individual basis to provide fine-grained access control over what functionality they can and cannot access on your blog.

* Entries
o Generates permalinks to point to individual entries.
o Supports search-engine friendly permalinks of the form month/day/year/permalink.
o Entries can be categorized.
o Calendar-based navigation so that you can view blog entries by year, year and month, or year and month and day.

* Categories
o Supports any number of categories.
o Categories are hierarchical.
o Allows you to give more descriptive names to your categories.

* Responses
o Supports comments, trackbacks, or pingbacks per entry.
o E-mails the blog owner when a new response is received.
o Supports the following per entry:
+ Disabling responses.
+ Throttling so that a response can only be left from a given IP address every so often.
+ Moderation of responses to require approval of the blog owner before they are shown.
+ Banning of IP addresses from leaving responses.
o Support for the Comment API.

* Plugins and Event/Listeners
o Ships with over 50 plugins.
o Allows you to extend the capabilities of blojsom by developing your own plugins using the plugin API.
o Components can send and receive events using the event and listener API.

* Syndication Formats
o Generates HTML, RDF, RSS 0.92, RSS 2.0, RSS 2.0 (with comments and trackbacks) and Atom syndication feeds.
o Generates content in any other format through its flavor support.
o Output a feed in any format for all categories, for a specific category, or a subset of your blog's categories.

* Templates and Themes
o Dispatchers available for you to develop templates using JSP, Velocity, FreeMarker, or Groovy.
o Allows you to change the look and feel of your blog quickly through the use of themes.
o Template administration (adding, editing, and deleting) through the web.

* Remote Editing
o Supports XML-RPC blogging clients.
o Supports the Blogger API, MetaWeblog API, and the MovableType API through XML-RPC.

* Internationalization and Localization
o Designed with internationalization and localization in mind.
o Uses UTF-8 by default to handle international character sets.
o Generates localized date and times.
o Handles calendar localization.
o Supports localization of its user interface and templates.

* et cetera
o Allows you and your users to search your blog entries.

Documentation
http://wiki.blojsom.com/wiki/display/blojsom3/Installation

Download
http://wiki.blojsom.com/wiki/display/blojsom3/Download+Quickstart

mapleBlog is a simple MVC Struts 1.1-based Web log that uses Hibernate as its model layer and Tiles/JSP for its View.

It is relatively simple to configure and has full basic functionality. By using Hibernate, it is able to function with a wide variety of databases.

Can also easily be replaced by entity beans and EQL due to the façade used to cover all database activities. Although entity beans are dog slow.

Home Page
http://mapleman.linuxreal.org/pyblosxom/data/static/mapleblog.html

ScreenShots

http://mapleman.linuxreal.org/pyblosxom/data/images/mapleblog.png

Download

http://mapleman.linuxreal.org/files/mapleBlog.war

blog was a concept I came up with after working on a project for a client and it seemed like other people needed the same software. Instead of the ever-increasingly long series of one dimensional postings that form most web journals, blog divides the journal up into topics (called threads) and postings (called entries). blog groups topics, sub-topics and posted messages in a way that allows an intellegent browsing mechanism. blog would also work very well as a categorized FAQ or press release archive.

Technical Details (Summary):

Type of Software: API (Abstract Programming Interface)
Programming Language: Java
Platform: Any (its Java)
Required Software: Any Java 1.1 compliant Servlet Container (no, its not a servlet, but you'll need one to use blog).

Home Page

http://blog-java.sourceforge.net/

Downloads

Blog From Sourceforge.net
blog-utilities

Documentation
http://blog-java.sourceforge.net/docs/blog/index.htm

JSP Blog was created due to the fact that I could not find an Open Sourced JSP weblog. I found plenty in PHP, however none in JSP.

This project was initially conceived by Anthony Ehrhardt. I am a professional UNIX Engineer with 12 years of experience with UNIX and 6 years of Linux. Linux is my OS of choice.

jsp blog : A personal blog (weblog) that is written in 100% JSP. Made on Apache Tomcat and MySQL. Will ultimately be 100% cross-platform

Project Home
http://sourceforge.net/projects/jspblog

Downloads
http://sourceforge.net/project/showfiles.php?group_id=58092

SnipSnap is a free and easy to install weblog and wiki tool written in Java.

SnipSnap is a Weblog and Wiki tool and a research project of the department of software technology at FIRST.

SnipSnap is a product of the >>Frauhofer Institute Computer Architecture and Software Technology (FIRST) in Berlin, Germany.

SnipSnap Demo:
http://snipsnap.org/static/javaws/snipsnap.jnlp

Documentation:
http://snipsnap.org/space/snipsnap-documentation

Download
http://snipsnap.org/space/snipsnap-DOWNLOAD

Faqs

http://snipsnap.org/space/FAQ

Pebble is a lightweight, open source, Java EE blogging tool. It's small, fast and feature-rich with unrivalled ease of installation and use. Blog content is stored as XML files on disk and served up dynamically, so there's no need to install a database. All maintenance and administration can be performed through your web browser, making Pebble ideal for anybody who is constantly on the move or doesn't have direct access to their host.

Features of Pebble

Here is a summary of the key features that are supported by Pebble.

Content

* Posting and management of content through your web browser, including rich text editor support.
* Blogger and MetaWeblog API interface included for posting content via compatible tools.
* Categorisation of content into multiple hierarchical categories.
* Tagging of content and a generation of a tagcloud.
* RSS enclosures for distrbuting files or podcasting.
* Simple content publication workflow.
* Pinging websites via XML-RPC when new blog entries are added.
* Publication of static content alongside your blog entries.

Reader responses

* Reader responses, in the form of threaded comments and MovableType TrackBacks.
* E-mail notifications when new responses are received.
* Pluggable moderation, spam detection and CAPTCHA support.
* Bulk response management features to approve/reject/remove comments and TrackBacks.

Web-based Adminstration

* Management of your blog via a web browser.
* File management and the ability to upload arbitary files and images.
* Capture of blog referers, requests and logs for viewing or export.
* Customizable regex based referer filters to combat referer spam.
* Integrated help and documentation.

Newsfeeds

* RSS 2.0, RDF and Atom 1.0 feeds for blog entries and responses.
* Category and tag specific newsfeeds.

Navigation

* View blog entries by permalink, day or month.
* Navigate through your blog entries in several ways, including a locale-aware calendar control.
* Text based and advanced searching.

Team, project, multi-user blogs and security

* Multiple people can contribute to a single blog.
* Host more than a single blog for a project, group or community.
* Integrate Pebble with your existing security infrastructure (e.g. LDAP, Active Directory, RDBMS, etc).

i18n

* Content in international character sets such as UTF-8.
* Publication of content aligned with your timezone, regardless of where your host is based.
* Locale sensitive delivery of dates, times and numbers.
* Translated public-facing text provides a consistent user experience in a single language, including :

o Chinese (Simplified)
o Chinese (Traditional)
o Danish
o Dutch
o English

o Finnish
o French
o German
o Hindi
o Italian

o Japanese
o Norwegian
o Portuguese
o Spanish
o Swedish

Plugin APIs

* Permalink Providers let you customize the format of your permalinks.
* Content Decorators let you customize how blog entries are displayed.
* Blog Listeners let you write Java code that is called when your blog starts up and shuts down.
* Blog Entry Listeners let you write Java code that is called when blog entries are added, removed, published and unpublished.
* Comment Listeners let you write Java code that is called when comments are added, removed, approved and rejected.
* TrackBack Listeners let you write Java code that is called when TrackBacks are added, removed, approved and rejected.
* Confirmation Strategies let you plugin different strategies for readers to confirm their comments/TrackBacks, such as CAPTCHAs.

Download Pebble:

http://sourceforge.net/project/showfiles.php?group_id=79200

Project Demo Page

http://www.simongbrown.com/blog/

Apache Ant is a Java-based build tool. In theory, it is kind of like Make, but without Make's wrinkles.

Why another build tool when there is already make, gnumake, nmake, jam, and others? Because all those tools have limitations that Ant's original author couldn't live with when developing software across multiple platforms. Make-like tools are inherently shell-based -- they evaluate a set of dependencies, then execute commands not unlike what you would issue in a shell. This means that you can easily extend these tools by using or writing any program for the OS that you are working on. However, this also means that you limit yourself to the OS, or at least the OS type such as Unix, that you are working on.

Makefiles are inherently evil as well. Anybody who has worked on them for any time has run into the dreaded tab problem. "Is my command not executing because I have a space in front of my tab!!!" said the original author of Ant way too many times. Tools like Jam took care of this to a great degree, but still have yet another format to use and remember.

Ant is different. Instead of a model where it is extended with shell-based commands, Ant is extended using Java classes. Instead of writing shell commands, the configuration files are XML-based, calling out a target tree where various tasks get executed. Each task is run by an object that implements a particular Task interface.

Granted, this removes some of the expressive power that is inherent by being able to construct a shell command such as `find . -name foo -exec rm {}`, but it gives you the ability to be cross platform -- to work anywhere and everywhere. And hey, if you really need to execute a shell command, Ant has an task that allows different commands to be executed based on the OS that it is executing on.

Project Home Page:
http://ant.apache.org/

Documentation
http://ant.apache.org/manual/index.html

Downloads
Binaries: http://ant.apache.org/bindownload.cgi
Source: http://ant.apache.org/srcdownload.cgi

License:
http://ant.apache.org/license.html

Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.

If you think that Maven could help your project, you can find out more information about in the "About Maven" section of the navigation. This includes an in-depth description of what Maven is, a list of some of its main features, and a set of frequently asked questions about what Maven is.

Maven was originally started as an attempt to simplify the build processes in the Jakarta Turbine project. There were several projects each with their own Ant build files that were all slightly different and JARs were checked into CVS. We wanted a standard way to build the projects, a clear definition of what the project consisted of, an easy way to publish project information and a way to share JARs across several projects.

The result is a tool that can now be used for building and managing any Java-based project. We hope that we have created something that will make the day-to-day work of Java developers easier and generally help with the comprehension of any Java-based project.

Maven's Objectives

Maven's primary goal is to allow a developer to comprehend the complete state of a development effort in the shortest period of time. In order to attain this goal there are several areas of concern that Maven attempts to deal with:

* Making the build process easy
* Providing a uniform build system
* Providing quality project information
* Providing guidelines for best practices development
* Allowing transparent migration to new features

Learning about Maven

This site is separated into the following sections, depending on how you'd like to use Maven:

* Run Maven Information for those needing to build a project that uses Maven
* Use Maven Information for those wanting to use Maven to build their project, including a "10 minute test" that gives a practical overview of Maven's main features in just 10 minutes
* Write Maven Plugins Information for those who may or may not be using Maven, but want to provide a plugin for shared functionality or to accompany their own product or toolset
* Improve the Maven Repository Information for those who may or may not use, but are interested in getting project metadata into the repository
* Develop Maven Information for those who are currently developers, or interested in becoming developers of the Maven project itself

Each guide is divided into a number of trails to get you started on a particular topic, and includes a reference area and a "cookbook" of common examples.

You can access the guides at any time from the left navigation.

Documentation:
http://maven.apache.org/guides/index.html

Downloads
http://maven.apache.org/download.html

Rant stands for Remote Ant. It is a distributed build system that allows an Ant build file to launch builds on other systems and receive exceptions should they occur.

Download
http://sourceforge.net/project/showfiles.php?group_id=39381

Invicta is an open-source build management tool.
Using simple project definition files, it generates powerful build scripts (Apache ANT's), while hiding their complexity.
Furthermore, Invicta is a modular framework that allows advanced developers add their own customized types of components, which means writing once ANT code that can later be used by all the developers in their project or company simply by specifying the new type name.
Learn more about Invicta

Download Invicta:
Invicta is now available for download

Documentation:

Invicta includes a complete manual both for its basic usage and for advanced developers.

This manual is available online and can also be downloaded separately.

Make in Java (JMK) is an application which is used to ensure that a set of files is in a consistent state. If JMK detects an inconsistency, it executes commands that correct the inconsistency. JMK is based on the make utility which is part of most Unix systems, but is designed to be easily run on a variety of machines and operating systems.

JMK - Make in Java - A utility for maintaining files in a consistent state. The application is based on the make utility which is part of most Unix systems, but is designed to support the task of writing platform independent makefiles. File names and path lists are written in a canonical form, and translated by jmk into native form. As a result, a makefile can be used to maintain software on a variety of machines and operating systems.

JMK - Project Home
http://sourceforge.net/projects/jmk

Frequently Asked Questions
http://jmk.sourceforge.net/faq.html

The Savant build system is designed to help manage the complexities of building large software applications. In order to support highly modular designs companies might create numerous projects, which are all managed independently of each other and all of which might have different requirements of a build system. Additionally, these projects might depend on each other and other third party libraries as well. Savant is a framework for managing these types of build complexities.

Savant, originally part of the Verge open source project, has recently been moved out to its own project at http://java.net in order to allow Savant grow into a full build system and build framework. The new Savant projects home page is located at https://savant.dev.java.net and is looking for developers. This new build system and framework is being designed to allow maximum flexibility and robustness by supporting numerous scripting and compiled languages as well as providing robust dependency management.

The new Savant build system will also support the complex project structures required by J2EE and other types of applications. This next phase of the Savant build system is nearing completion and if you would like to participate, please apply for a position by visiting the Savant homepage at https://savant.dev.java.net

Savant Features

Dependency Management

* Inter-project dependencies and builds
* Transitive dependencies
* Robust dependency namespacing to avoid name collisions
* Configurable workflows for dependency fetching, caching, and publishing
* Well defined interfaces allowing customized dependency fetching. caching, and publishing
* Support for Maven 1 (http://www.ibilio.org) dependency fetching
* MD5 checking
* Full Apache Ant integration

Command-line tool

* Robust plugin system with versioning and inter-plugin dependencies
* Java compilation with multiple source trees
* Single or multiple JAR creation
* JUnit integration with CLI switches for different failure modes
* Project layout creation
* Dependency tree print-out (like pstree)
* Some J2EE support
* Ability to run ant scripts from Savant CLI and from other Savant plugins

Savant Documentation
http://www.inversoft.com/docs/savant

Download Savant
https://savant.dev.java.net/

CruiseControl is a framework for a continuous build process. It includes, but is not limited to, plugins for email notification, Ant, and various source control tools. A web interface is provided to view the details of the current and previous builds.

CruiseControl is distributed under a BSD-style license and is free for use. CruiseControl adheres to an open source model and therefore makes the source code freely available.

CruiseControl is maintained and developed by a group of dedicated volunteers.

Continuous Integration

An important part of any software development process is getting reliable builds of the software. Despite it's importance, we are often surprised when this isn't done. We stress a fully automated and reproducible build, including testing, that runs many times a day. This allows each developer to integrate daily thus reducing integration problems.

Cruise Control Documentation
http://cruisecontrol.sourceforge.net/overview.html

Cruise Control Download
http://cruisecontrol.sourceforge.net/download.html

Krysalis Centipede is a project build system based on Apache Ant.

You can just grab it and start building your project. Anything that is needed for a start is there, and the creation of personalized build targets is straightforward, because it's based on plain Ant. Centipede is un-intrusive, and gives you power without taking any. It also has an interactive target facility, so that the user can just run "build" and choose from a menu.

You just need to add a property to use additional pre-built targets. These packages are called antlibs, and behave like wars and seamlessly add functionality to the build.

Let's say you need to make documentation. Just add (an available documentation system based on Cocoon) to the properties file, write the docs, call the forrest in your main build file where you want documentation to be build and all the rest (comprising the download and installation) is completely automagic.

Since Centipede is used by many projects, it benefits from the enhancements done in each of them, thus and evolving on user requests-issues. This is pure Apache style cross project pollination.

It gives developers the power to add functionality where needed without creating complexity.

Developers seldom want to think much about the project build system, but have very clear ideas of what they want from it. Centipede gives them pre-built antlibs to be used like big component blocks, thus giving choice and power to where it really belongs.

Documentation
http://krysalis.org/centipede/quickstart.html

Download
http://sourceforge.net/project/showfiles.php?group_id=36516

Bee is a Java-based build tool. Bee inherited some principles of Make. Bee provides more procedure languages constructions, so generally can be used for script programming. It's highly extendable and base DTD can be easily changed, so it allows to create own dialects of Bee.

Project Home Page
http://www.gena.crocodile.org/bee/index-bee.html

LuntBuild is a powerful build automation and management tool. Continuous integration or daily build can be easily setup through a clean web interface. Generated builds are well managed through functions such as search, categorization, promotion, patching, deletion, etc. It also acts as a central build artifacts download area for your whole team.

Project Home Page

http://www.luntsys.com/luntbuild/

CPMake is a make utility written in Java to make anything (C, C++, Java, C#, XSL ...)
CPMake works similar to GNU make in that is uses rules and dependencies to build a project. CPMake uses Java scripting languages (BeanShell, Rhino, Jython and Groovy) for the build files to give increased flexability and the ability to customize the make file to your project.

CPMake Features:

* Make files work on any platform that supports Java.
* CPMake has built in dependency tracking for C/C++ and Java projects.
* Build files have access to all of the Java classes.
* Easy to debug build files.
* Multi threaded processing of build file.
* Cross platform paths. Use '\' or '/' Java doesn't care.

Project Home Page
http://www.cpmake.org/

CPMake Documentation
http://www.cpmake.org/documentation.html

Downloads
http://www.cpmake.org/downloads.html

CPMake Demo
http://www.cpmake.org/samples.html

JavaGen Ant Modules or JAM is a modular Ant toolkit for building J2EE applications. It consists of a collection of Ant scripts designed to perform common Java/J2EE build tasks such as compilation, packaging, testing, deployment and J2EE application server control. Although originally developed to support the JavaGen code generator, JAM has evolved into a full feature, stand-alone build framework.

Highlights include:

* JAM leverages the new import and target override features of Ant 1.6 to create a reusable build framework.
* JAM defines a small set of standard target names.
* JAM includes a Maven-to-Ant bridge providing access to Maven's POM and repository features directly from Ant.
* JAM supports various J2EE application servers as interchangeable modules.
* JAM supports code generation technologies such as XDoclet and UML-based JavaGen.
* JAM has extensive support for various unit test technologies including JUnit and Cactus.
* JAM modules support CVS, Axis, Castor, JMX, Hibernate and many other technologies.

To learn more read through the User's Guide starting with the simple example page.

JAM Download
http://javagen.com/jam/download.html

Project Home
http://javagen.sourceforge.net/

GenJar is a specialized Ant task that builds jar files based on class dependencies rather than simply the contents of a directory.

Work is underway on GenJar2. GenJar2 will be a functional replacement of GenJar, but build file syntax will change. Some of the features of GenJar2 include:

* Syntax consistent with Ant's jar task
* Replacement of GenJar's with Ant's
* Replacement of GenJar's with with Ant's
* BCEL for class dependency checking

The original GenJar branch will be maintained for as long as there is demand.

Documentation
http://genjar.sourceforge.net/manual.html

Download GenJar
http://sourceforge.net/project/showfiles.php?group_id=63362&release_id=144632

Project Home Page
http://sourceforge.net/projects/genjar/

Ivy is a free java based dependency manager, with powerful features such as transitive dependencies, ant integration, maven repository compatibility, continuous integration, html reports and many more.

Project Home Page
http://jayasoft.org/ivy

Antmod is a build management, release management, and repository management tool. Its implementation is an Ant-based extensible engine for retrieving, versioning, building, and deploying code to and from Subversion or CVS. It standardizes build files for Java projects and provides build plugins for various tasks. It also standardizes tagging and branching for both CVS and Subversion, and its module and repository management can also be used for non-Java projects. It greatly speeds up Java software development, promotes reuse of Java software, and standardizes the build-test- release cycle.

Homepage:
http://antmod.org/

Tar/GZ:
http://antmod.org/download.html

Zip:
http://antmod.org/download.html

Changelog:
http://antmod.org/news.html

CVS tree (cvsweb):
http://antmod.dev.java.net/source/browse/antmod/

Bug tracker:
https://antmod.dev.java.net/servlets/ProjectIssues

Mailing list archive:
http://antmod.dev.java.net/servlets/SummarizeList?listName=users

Continuum is a continous integration server that will ensure the health of your code base.

The term "continuous integration" refers to a process that builds and tests code on a frequent, regular basis. Many continuous integration systems monitor a source repository at regular intervals and trigger an "integration" every time someone commits a change. An "integration" can be anything from compiling and testing a single project to the assembly and testing of a deliverable from multiple dependent projects. Among the benefits of continuous integration are the immediate identification of defects and the ability to guarantee that a project's build will succeed at any point in the development cycle.

An in-depth description of continuous integration is beyond the scope of this FAQ. A much more detailed explanation of the concept can be found at the resources listed below:

* Martin Fowler has a article called "Continuous Integration"
* The C2 wiki has a page on ContinuousIntegration

There are many continuous integration projects and products on the market. Here is a list of other products which offer similar capabilities:

* CruiseControl
* AntHill

Features of Continuum

* Tight integration with Maven 2.x
* Tight integration with Maven SCM
o Subversion
o CVS
o Starteam
o Clearcase
o Perforce
o bazaar
* Easy to use web-based setup and interface
* Quartz-based scheduling
* An easy way to add new projects, see the adding projects section page for more information
* An XML-RPC interface for integration, automation and remoting
* Mail notification
* IM notification
o IRC
o Jabber
o MSN
* Blame Mechanism

Documentation
http://maven.apache.org/continuum/guides/index.html

Continuum Downloads
http://maven.apache.org/continuum/download.html

Project Home Page
http://maven.apache.org/continuum/index.html

Autojar helps creating jar files of minimal size from different inputs like own classes, external archives etc. It starts from one or more given classes (e.g., an applet), recursively searches the bytecode for references to other classes, extracts these classes from the input archives, and copies them to the output. The resulting archive will only contain the classes you really need. Thus you can keep size and loading time of applets low or make applications independent of installed libraries.
In a similar way, autojar can search directories and archives for other resources (like image files), extract them and copy them to the output.

Note that autojar in principle can't know which classes will be loaded dynamically (by Class.forName()). However, starting from version 1.3, one can tell autojar to search the bytecode for invocations of Class.forName() and inform you correspondingly. In some cases autojar actually can find out which classes are to be loaded, and add them automatically to the output.

Autojar uses the excellent bcel package (http://jakarta.apache.org/bcel/).

Using Autojar

Autojar comes in two flavours with equal functionality. The file autojar.jar is th self-contained version, created by autojar itself. Use it if you don't have BCEL installed. It is started by the command

java -jar autojar.jar [option...] [file...]

The second version, autojar-core.jar, is much smaller, as it contains only the autojar classes. You must have bcel-5.1.jar (or better) in your classpath to use it. Start it like this:

java -cp autojar-core.jar:bcel.jar de.uni_hamburg.eggink.autojar.Autojar [option...] [file...]

(As usual, Windows users have to use semicolon instead of colon in the classpath). Any program parameter (options and files) may be supplied directly on the command line or read from a text file. Example:

java -jar autojar.jar -o old.jar @params -c in.jar @class-list

Each line in params and class-list is considered a program parameter and inserted into the command line sequence.

Project Home Page
http://autojar.sourceforge.net/

Download Autojar
https://sourceforge.net/projects/autojar

Jar Jar Links is a utility that makes it easy to repackage Java libraries and embed them into your own distribution. This is useful for two reasons:

* You can easily ship a single jar file with no external dependencies.
* You can avoid problems where your library depends on a specific version of a library, which may conflict with the dependencies of another library.

Project Home page
http://tonicsystems.com/products/jarjar/

Hudson monitors executions of repeated jobs, such as building a software project or jobs run by cron. Among those things, current Hudson focuses on the following two jobs:

Building/testing software projects continuously, just like CruiseControl or DamageControl. In a nutshell, Hudson provides an easy-to-use so-called continuous integration system, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. The automated, continuous build increases the productivity.

Monitoring executions of externally-run jobs, such as cron jobs and procmail jobs, even those that are run on a remote machine. For example, with cron, all you receive is regular e-mails that capture the output, and it is up to you to look at them diligently and notice when it broke. Hudson keeps those outputs and makes it easy for you to notice when something is wrong.

Hudson Features

1. Easy installation: Just java -jar hudson.war, or deploy it in a servlet container. No additional install, no database.
2. Easy configuration: Hudson can be configured entirely from its friendly web GUI with extensive on-the-fly error checks and inline help. There's no need to tweak XML manually anymore, although if you'd like to do so, you can do that, too.
3. Change set support: Hudson can generate a list of changes made into the build from CVS/Subversion. This is also done in a fairly efficient fashion, to reduce the load of the repository.
4. Permanent links: Hudson gives you clean readable URLs for most of its pages, including some permalinks link "latest build"/"latest successful build", so that they can be easily linked from elsewhere.
5. RSS/E-mail/IM Integration: Monitor build results by RSS or e-mail to get real-time notifications on failures.
6. After-the-fact tagging: Builds can be tagged long after builds are completed
7. JUnit/TestNG test reporting: JUnit test reports can be tabulated, summarized, and displayed with history information, such as when it started breaking, etc. History trend is plotted into a graph.
8. Distributed builds: Hudson can distribute build/test loads to multiple computers. This lets you get the most out of those idle workstations sitting beneath developers' desks.
9. File fingerprinting: Hudson can keep track of which build produced which jars, and which build is using which version of jars, and so on. This works even for jars that are produced outside Hudson, and is ideal for projects to track dependency.
10. Plugin Support: Hudson can be extended via 3rd party plugins. You can write plugins to make Hudson support tools/processes that your team uses.

Download Hudson
https://hudson.dev.java.net/servlets/ProjectDocumentList

Using Hudson
http://hudson.gotdns.com/wiki/display/HUDSON/Use+Hudson

Some aspects of system implementation, such as logging, error handling, standards enforcement and feature variations are notoriously difficult to implement in a modular way. The result is that code is tangled across a system and leads to quality, productivity and maintenance problems. AspectJ is a seamless aspect-oriented extension to the Java programming language that enables clean modularization of these 'crosscutting concerns'. For the best AspectJ development experience, the AspectJ Development Tools (AJDT) project provides Eclipse platform based tool support for AOSD with AspectJ - see Eclipse AJDT project.

Features of AspectJ

* a seamless aspect-oriented extension to the Java programming language
* Java platform compatible
* easy to learn and use

AspectJ Enables

clean modularization of crosscutting concerns, such as error checking and handling, synchronization, context-sensitive behavior, performance optimizations, monitoring and logging, debugging support, and multi-object protocols.

AspectJ Downloads:

http://www.eclipse.org/aspectj/downloads.php

Documentation

Popular AspectJ docs: AspectJ 5 Developer's Notebook | Programming Guide | More docs...

AspectJ Project Home Page
http://www.eclipse.org/aspectj/

AspectWerkz is a dynamic, lightweight and high-performant AOP framework for Java.

AspectWerkz offers both power and simplicity and will help you to easily integrate AOP in both new and existing projects.

AspectWerkz utilizes bytecode modification to weave your classes at project build-time, class load time or runtime. It hooks in using standardized JVM level APIs. It has a rich and highly orthogonal join point model. Aspects, advices and introductions are written in plain Java and your target classes can be regular POJOs. You have the possibility to add, remove and re-structure advice as well as swapping the implementation of your introductions at runtime. Your aspects can be defined using either Java 5 annotations, Java 1.3/1.4 custom doclets or a simple XML definition file.

AspectWerkz provides an API to use the very same aspects for proxies, hence providing a transparent experience, allowing a smooth transition for users familiar with proxies.

AspectWerkz performance is reported in this separate project.

AspectWerkz is Free Software. The LGPL-style license allows the use of AspectWerkz 2.0 in both commercial and open source projects.

AspectWerkz Features

This is a very incomplete list, see the documentation for all features.

* Very high-performant. Weaved code is entirely statically compiled. AspectWerkz ranks 1st or 2nd in most of the benchmarks. Read more about the figures on the AspectWerkz Bench project pages.

* Annotation support: Matching on annotations (both JavaDoc and JSR-175). Supports user-defined annotations, retrieval of annotations. Both JavaDoc and JSR-175 annotations are accessed through one single API and both schemes are strongly typed.

* Aspects, advices and introductions are written in plain old Java code. I.e. no new language to learn, no new compilation phases, no need to tell your manager ;-). Will work seamlessly in any IDE, debugger, refactoring tool and test framework.

* The target classes can be regular POJOs (Plain Old Java Objects), i.e. do not require to have an interface.

* Weaving (bytecode modification) at compile time, load time and runtime. Hooks in and transforms classes loaded by any class loader except the bootstrap class loader. Which basically means that you can easily transform any (legacy) application or external library apart from rt.jar both at runtime and compile time.
JSR-163 JVMTI is supported for Java 1.5 usage as well.

* The join point model supports: staticinitialization, method execution and call, constructor execution and call, field access, field modification, catch handlers, cflow, within and withincode, hasmethod and hasfield. All advice works with all join points.

* Rich semantics allow to access runtime information about the join point within the advice using regular types without any casting or object array access. Reflective access to runtime information is also possible.

* Introductions/Inter type declarations (also called Mixins), i.e. the possibility to add interfaces and implementations to existing classes.

* META-INF/aop.xml container: Support for deploying several aop.xml Aspect defintion/deployment files alongside deployed application ( WEB-INF/aop.xml, META-INF/aop.xml) and have them following the classloader hierarchy.

* Annotation definition. Define your aspects and mixins using annotations using wether standardized Java 5 Annotations (JSR-175) or Java 1.3/1.4 custom doclet with strongly typed access.

* XML definition. Define your aspects and mixins using XML. The XML definition can also be used to refine, override and resolve the annotation definition.

* Pluggable aspect manager that can make it work seamlessly with IoC frameworks like Spring or PicoContainer.

* Support several different deployment models (scope) for aspects (perJVM(singleton), perClass, perInstance) and for mixin (perInstance, perClass, perJVM(singleton)).

* Hot deployment, aspects can be deployed and undeployed at runtime using a simple API.

* Fine-grained pattern language for selecting the join points.

* Highly orthogonal underlying model. All advice works with all join points and pointcut composition supports mixing all kinds of pointcuts.

* "Offline" transformation (can be used as a post-processor).

* Support for passing configuration parameters to the advices through the definition.

* Simple usage and configuration.

* Extensible container architecture allows to run any Aspects (AspectWerkz, Spring AOP, AOP Alliance, subset of AspectJ) within the AspectWerkz runtime.

AspectWerkz Downloads

http://aspectwerkz.codehaus.org/releases.html

Documentation & Tutorials for AspectWerkz
http://aspectwerkz.codehaus.org/introduction.html
http://docs.codehaus.org/display/AW/Tutorials

Nanning Aspects is a simple yet scaleable aspect-oriented framework for Java.

Nanning is also nice "little" town in Guanxi province in southern China. It's about 1-2 million inhabitants which barely qualifies it as a town by chinese standards. It is not to be confused with the much larger Nanking/Nanjing.

Nanning Features:

Nanning Aspects has the following features:

* An aspected object consists of a set of mixins. Every mixin is an interface, a target-object and a set of interceptors (advises on method-calls), these interceptors intercept calls on the interface on it's way to the target.
* An aspected object is used by creating a Proxy with the Reflection API. This proxy will implement all the interfaces of all the mixins by invoking all the interceptors for the called method and finally calling the proper implementation of the target object.
* Attributes (as Javadoc-like tags in the source code or as an xml-document with the same name as the class) can also be added to classes, fields and methods. These attributes are accesible at runtime.
* Inherited interfaces will call correct target. If several aspects implement same interface the first one will take precedence. The target of the aspect-class will always take precedence before the rest.
* An XML-config format that's actually a Jelly-script .
* Method-selectors that selects what methods an interceptor should intercept.
* Super-simple implementation. Really! Anybody can do it!

Nanning Restrictions

Nanning Aspects has the following restrictions

* You can only advise on method-call pointcuts which is far from the power that for example AspectJ offers. On the other hand compared to the complexity of AspectJ Nanning is much, much simpler. In reality many of the benefits of AOP can be reached with this simple construct. At the moment there is also some experimental support for intercepting object-instantiation.
* All your objects need to have interface and implementation separated, that is all public methods (accessible to clients) needs to be placed in an interface which is implemented by the actual class. In contrast to EJB your implementation must implement the interface, which also forces your implementation to stay in sync with your interface. (This is actually good, because the java-compiler will choke if they're out of sync before your code even hits unit-tests.)
* You'll get indeterministic effects if your interface has a method with same name as a method of another interface for the aspected object. (Currently considering disallowing this altogether.)

Most documentation is located at our SnipSnap http://nanning.snipsnap.org . It's an ongoing effort.

Download Nanning
http://nanning.codehaus.org/download.html

JBoss AOP is a 100% Pure Java aspected oriented framework usuable in any programming environment or tightly integrated with our application server. Aspects allow you to more easily modularize your code base when regular object oriented programming just doesn't fit the bill. It can provide a cleaner separation from application logic and system code. It provides a great way to expose integration points into your software. Combined with JDK 1.5 Annotations, it also is a great way to expand the Java language in a clean pluggable way rather than using annotations solely for code generation.

JBoss AOP is not only a framework, but also a prepackaged set of aspects that are applied via annotations, pointcut expressions, or dynamically at runtime. Some of these include caching, asynchronous communication, transactions, security, remoting, and many many more.

JBoss AOP Download
http://labs.jboss.com/jbossaop/downloads

JBoss AOP Documentation
http://labs.jboss.com/portal/jbossaop/docs/index.html

JBoss AOP Project Home
http://labs.jboss.com/jbossaop/

dynaop, a proxy-based Aspect-Oriented Programming (AOP) framework, enhances Object-Oriented (OO) design in the following areas:

* code reuse
* decomposition
* dependency reduction

dynaop Project Home Page
https://dynaop.dev.java.net/

dynaop Downloads
https://dynaop.dev.java.net/servlets/ProjectDocumentList

dynaop Documentation
https://dynaop.dev.java.net/nonav/release/1.0-beta/manual/index.html

JFreeChart is a free 100% Java chart library that makes it easy for developers to display professional quality charts in their applications. JFreeChart's extensive feature set includes:

* a consistent and well-documented API, supporting a wide range of chart types;
* a flexible design that is easy to extend, and targets both server-side and client-side applications;
* support for many output types, including Swing components, image files (including PNG and JPEG), and vector graphics file formats (including PDF, EPS and SVG);
* JFreeChart is "open source" or, more specifically, free software. It is distributed under the terms of the GNU Lesser General Public Licence (LGPL), which permits use in proprietary applications.

Project Home Page
http://www.jfree.org/jfreechart/

JFreeChart Download
http://www.jfree.org/jfreechart/download.html

JFreeChart Demo
http://www.jfree.org/jfreechart/samples.html

JFreeChart Documentation
http://www.jfree.org/jfreechart/api/gjdoc/index.html

OSCache is a caching solution that includes a JSP tag library and set of classes to perform fine grained dynamic caching of JSP content, servlet responses or arbitrary objects. It provides both in memory and persistent on disk caches, and can allow your site to have graceful error tolerance (eg if an error occurs like your db goes down, you can serve the cached content so people can still surf the site almost without knowing). Take a look at the great features of OSCache.

OSCache Features

Fast in-memory caching

* OSCache allows you to store dynamic content (eg for 30 minutes) in memory. Each further request is served directly from the memory cache, resulting in dramatic speed increases.
* The cache is keyed programmatically. This means you can calculate a cache key that works for your situation. For example an ecommerce site might use product ID as keys, or content site might use an article date and article ID combination.
* The cache is stored in standard scopes that any JSP programmer is familiar with (application or session). The session scope allows you to have different cached content per user. This is one unlike any other caching system we've ever seen.

Persistent on-disk caching

* OSCache can also write the cache to disk. This provides caching across server restarts, and caching of datasets that do not fit into memory. Caching can be configured to use memory or file caching, or a combination of both.
* If you want to persist the cache to somewhere other than disk, you can plug in a custom PersistenceListener. This allows you to persist the cache to anywhere (for example to a database via JDBC or to LDAP via JNDI).
* When using both disk caching and memory caching. It is possible to limit the cache size to avoid using too much memory but let disk cache unlimited, resulting in browser style complementary disk cache. When cached objects are removed from memory, they are still on disk. If the item is needed again and it is not expired the cache file will be used. This also gives fault tolerance if the server crashes.
* Persistence can also be switched to overflow mode using the property oscache.persistence.overflow.only. This changes the default behavior (of persisting every cache entry when there is a listener) to only persist when the memory cache capacity has been reached.

Excellent Performance

* Written with performance in mind.
* Mulitple cache requests can be handled concurrently.
* Only one requesting thread needs to update an expired cache entry even if multiple threads are requesting it simultaneously. Other threads can be configured to either receive the recently-expired object, or block until the cached object is updated. Similarly, when a new entry is being added to the cache, other threads requesting that entry will block until it is ready rather than run off and race to build the same object. In a high load environment this can provide enormous performance benefits.
* Automatically takes advantage of JRE 1.4 or higher if available.

Clustering support

* OSCache can easily be configured to cluster across multiple boxes. This provides both scalability and failover support without any changes required in your caching code.

Flexible Caching System

* OSCache allows you to cache portions of JSP pages, arbitrary Java objects, and even entire servlet responses.
* Cache capacity can be set allowing you to limit the number of cached objects.
* Multiple caching algorithms are supported such as LRU (Least Recently Used), FIFO (First In First Out), or unlimited. It is also possible to plug in your own custom algorithm.
* You are given a huge amount of control over the way cached objects expire. Objects can be cached indefinitely, expired once they reach a certain age, or expired based on a cron expression. Programmatic flushing is also possible, and if that is still not enough pluggable RefreshPolicies allow custom refresh strategies.
* Cached objects can be grouped together however you like, allowing for powerful management of cached data. This is an extremely useful feature that is far more powerful than what other caching solutions typically offer (such as the flushing of cache keys that match a particular pattern).
* Fully event driven! OSCache fires events for various happenings 'under the hood' such as cache entry events (adding, updating, flushing and removing) and cache accesses (hit, stale hit and miss). It is easy to add your own event handlers.
* Multiple caches can be created, each with their own unique configuration.

Simple JSP Tag Library

* The tag library to perform and control the caching is very simple. See the Tag Reference for more information.

Caching Filter

* A Servlet 2.3 Filter allows for caching of entire pages and generated binary files (like dynamically created images or PDF files).
* Caching of binary files is extremely useful when they are generated dynamically and the average creation time is long.
* The CacheFilter is using the last modified header to reduce excellently the transaction overhead and server load which speed ups the server response time.

Comprehensive API

* For the ultimate control, OSCache can be used through its straightforward API. You can instantiate, configure and control multiple caches programmatically. It would be possible for example to create one small in-memory cache that held currency conversion rates and was updated daily at 2am, while another cache could be purely disk based and used for holding dynamically created images.

Exception Handling

* OSCache provides a way for your site to gracefully tolerate errors. This is not error prevention, rather if an error occurs it should not stop your site from functioning. For example if your database goes down, normally your product descriptions will not be browsable. Using OSCache you can cache those descriptions so you can still browse them.

Cache Flushing

* Flushing of caches can be controlled via JSP Tags, so these functions can easily be built into your administration interface.
* There is programmatic control over what caches are flushed (eg all caches or just a particular scope).
* Cached objects can be expired in a number of ways. Objects can be told to expire once they reach a certain age, or, through the use of cron expressions, on particular dates and/or times (eg it is trivial to make an object expire every weekday at 3am). If this is not enough, you can expire objects programmatically as required, or plug in your own custom RefreshPolicy class that can dynamically decide when an object should be flushed.
* Entire groups of objects can be easily flushed from the cache. For example suppose you were caching product data as well as entire pages of your website. When a product was updated, you could flush not just the product object but also all the pages that contain information about that product. No more waiting for the cached objects to expire before the updated content shows up on your site!

Portable caching

* Pure Java, this means it is platform independent.
* OSCache is compliant with Servlet 2.3 and JSP 1.2 standards, which means it should work in the latest generation of servlet containers and application servers.

i18n Aware

* The caching is i18n aware and supports all encodings.

Solid Reputation

* Thousands of downloads, hundreds of users on the mailing list.
* Comprehensive JUnit test suite that covers every aspect of OSCache, including a web stress test and various concurrent cache access scenarios. To back this up, the kind folks at Cortex have supplied us with a Clover license to provide detailed code coverage analysis of our unit tests.
* We have solid issue tracking using JIRA to keep track of any feature requests, bug reports and development progress. JIRA is provided courtesy of Atlassian.

Project Home Page
http://www.opensymphony.com/oscache/

Documentation
http://www.opensymphony.com/oscache/wiki/Documentation.html

Java API Documentation
http://www.opensymphony.com/oscache/api/index.html

JCS is a distributed caching system written in java. It is intended to speed up applications by providing a means to manage cached data of various dynamic natures. Like any caching system, JCS is most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system. Learn how to start using JCS.

The JCS goes beyond simply caching objects in memory. It provides numerous additional features:

* Memory management
* Disk overflow (and defragmentation)
* Thread pool controls
* Element grouping
* Minimal dependencies
* Quick nested categorical removal
* Data expiration (idle time and max life)
* Extensible framework
* Fully configurable runtime parameters
* Region data separation and configuration
* Fine grained element configuration options
* Remote synchronization
* Remote store recovery
* Non-blocking "zombie" (balking facade) pattern
* Lateral distribution of elements via HTTP, TCP, or UDP
* UDP Discovery of other caches
* Element event handling
* Remote server chaining (or clustering) and failover

JCS works on JDK versions 1.3 and up. It only has two dependencies: Commons Logging and Doug Lea's Util Concurrent.

The foundation of JCS is the Composite Cache, which is the pluggable controller for a cache region. Four types of caches can be plugged into the Composite Cache for any given region: (1) Memory, (2) Disk, (3) Lateral, and (4) Remote. The Composite Cache orchestrates access to the various caches configured for use in a region.

The JCS jar provides production ready implementations of each of the four types of caches. In addtion to the core four, JCS also provides additional plugins of each type.

The LRU Memory Cache is an extremely fast, highly configurable memory cache . It uses a Least Recently Used algorithm to manage the number of items that can be stored in memory. The LRU Memory Cache uses its own LRU Map implementation that is significantly faster than both the commons LRUMap implementation and the LinkedHashMap that is provided with JDK1.4 up. This makes JCS faster than its competitors .

The Indexed Disk Cache is a fast, reliable, and highly configurable swap for cached data. The indexed disk cache follows the fastest pattern for disk swapping. Cache elements are written to disk via a continuous queue-based process. The length of the item is stored in the first few bytes of the entry. The offset is stored in memory and can be reference via the key. When items are removed from the disk cache, the location and size are recorded and reused when possible. Every aspect of the disk cache is configurable, and a thread pool can be used to reduce the number of queue worker threads across the system.

JCS is not a tag library or a web specific application. JCS is a general purpose caching system that can be used in web applications, services, and stand alone Java applications.

JCS is not a transactional distribution mechanism. Transactional distributed caches are not scalable. JCS is a cache not a database. The distribution mechanisms provided by JCS can scale into the tens of servers. In a well-designed service oriented architecture, JCS can be used in a high demand service with numerous nodes. This would not be possible is the distribution mechanism were transactional.

JCS does not use AOP. JCS is a high performance, non-invasive cache. It does not manipulate your objects so it can just send a field or two fewer over the wire.

JCS is not fork, an offshoot, a branch, or any other derivation of JCS. Nor is JCS named after another library. JCS is a mature project that has been under development and in use since 2001. Over the years JCS has encorporated numerous bug fixes and has added dozens of features, making it the best designed and most feature rich caching solution available.

Project Home Page
http://jakarta.apache.org/turbine/jcs/

JCS Download
http://jakarta.apache.org/jcs/DownloadPage.html

Ehcache is a widely used java distributed cache for general purpose caching, JEE and light-weight containers.

It features memory and disk stores, replicate by copy and invalidate, listeners, a gzip caching servlet filter and much more...

Ehcache is available under an Apache open source license and is actively developed, maintained and supported.

Features of Ehcache

* Fast and Light Weight
o Fast
o Simple
o Small foot print
o Minimal dependencies
* Scalable
o Provides Memory and Disk stores for scalabilty into gigabytes
o Scalable to hundreds of caches
o Tuned for high concurrent load on large multi-cpu servers
o Multiple CacheManagers per virtual machine
* Complete
o Supports Object or Serializable caching
o Support cache-wide or Element-based expiry policies
o Provides LRU, LFU and FIFO cache eviction policies
o Provides Memory and Disk stores
o Distributed Caching
* Standards Based
o Full implementation of JSR107 JCACHE API
* Extensible
o Listeners may be plugged in
o Peer Discovery, Replicators and Listeners may be plugged in
* Application Persistence
o Persistent disk store which stores data between VM restarts
o Flush to disk on demand
* Supports Listeners
o CacheManager listeners
o Cache event listeners
* JMX Enabled
* Distributed
o Peer Discovery
o Reliable Delivery
o Synchronous Or Asynchronous Replication
o Copy Or Invalidate Replication
o Transparent Replication
o Extensible
o Bootstrapping from Peers
* JEE and Applied Caching
o Blocking Cache to avoid duplicate processing for concurrent operations
o SelfPopulating Cache for pull through caching of expensive operations
o JEE Gzipping Servlet Filter
o Cacheable Commands
o Works with Hibernate
* High Quality
o High Test Coverage
o Automated Load, Limit and Performance System Tests
o Production tested
o Fully documented
o Trusted by Popular Frameworks
o Conservative Commit policy
o Full public information on the history of every bug
o Responsiveness to serious bugs
* Open Source Licensing
o Apache 2.0 license

Project Home Page
http://ehcache.sourceforge.net/

OpenJDK Project Home Page
http://openjdk.java.net/

Accessing Source Code

Access the source code repository for this project in one of following ways:

* Browse source code online to view this project's directory structure and files.
* Check out source code with a Subversion client using the following command. Note: replace the last username with your own username.

svn checkout
https://openjdk.dev.java.net/svn/openjdk/trunk
openjdk --username username

Subversion Help
http://subversion.tigris.org/

Download Source Code
https://openjdk.dev.java.net/source/browse/openjdk/

OpenJDK Binaries Download
http://download.java.net/openjdk/jdk7/

OpenJDK Binary License Details
The majority of OpenJDK code is released under the GNU General Public License Version 2 (GPLv2)

Source Code License Details
Certain source based on existing open source projects will continue to be available under their current licenses. Some binary components are covered under the Binary License for OpenJDK. Specific download pages and the source file headers provide license information associated with the available component pieces.

The OpenJDK Community is a collection of projects focused on experimentation and evolution of the JDK platform. Most of the community is open for public browsing and participation, however, parts of the community are private and only available to members of this jdk project who agree to the terms of the Java Research License (JRL) and have the Researcher project role.

To obtain this role, please go to Membership Request, review the JRL, and request the Researcher role.

Project Licenses

JDK source code is available under two different licenses in the OpenJDK Community.

1. GPL v2 open source license
2. Sun's Java Research License

Currently only the following components of the JDK are available under the GPL license:

* Java HotSpot virtual machine
* Java programming language compiler (javac)

The remainder of the JDK source will be released under GPL in the first half of 2007. Until this time, if you wish to experiment with or make contributions to the JDK, you must do so using source code under the JRL.

Other projects are also included in the OpenJDK community that do not include JDK source. These projects may use the JRL, GPL or other licenses.

Community Home Page
https://jdk.dev.java.net/

JDK6 Binaries and Source Code Download
http://jdk6.dev.java.net/

JDK7 Binary builds and Source Code Downloads
http://jdk6.dev.java.net/

OpenJDK is Sun Microsystems effort to open source Java programming language. Hence forth Java 7(JDK7) and other future releases will be called openJDK with respective version numbers.

At JavaOne 2006, Rich Green, Sun's Executive VP of Software, said, "It's not a question of whether, but its a question of how." One year later at JavaOne 2007, Sun delivered on that promise and announced the source for a fully buildable JDK is now available under the GPL v2 license on java.net. This is that, so called OpenJDK.

So, its simple open source Java Development Kit(JDK) is called OpenJDK.
Open source Java Development Kit(OpenJDK) is maintained by a group from open source community and java architects from sun microsystems.

FKache Open Source is an effort to make an Open Source version of JSR-107 FKache. Since the JSR-107 hasn&t released any specs for years, This version still builds on the original Functional Specification.

JSR 107 has started seeding some of the works. A Draft API has been released at: jsr-107 interest project at java.net. I have started deprecating and refactoring my project to make it an implementation of this draft API. This will be dome in several iterations, so you get a chance to change your code. For each iteration, all methods/classes/packages changed or removed is deprecated. So you only need to find all deprecated methods/classes in FKache, and replace them with the proposed replacement. I the deprecation is marked with "no replacement", and you are using that feature, please contact me to see if a solution can be made available.

Project Home Page
http://jcache.sourceforge.net

Download JCache
http://sourceforge.net/project/showfiles.php?group_id=66335

FKache Documentation
http://jcache.sourceforge.net/documentation/index.html

ShiftOne Java Object Cache is a Java library that implements several strict object caching policies, decorators that add behavior, and a light framework for configuring them for an application.

It's strict in that each cache enforces two limits in a very strict and predictable way.
# Max Size - each cache has a hard limit on the number of elements it will contain. When this limit is exceeded, the least valuable element is evicted. This happens immediately, on the same thread. This prevents the cache from growing uncontrollably
# Element Timeout - each cache has a maximum time that it's elements are considered valid. No element will ever be returned that exceeds this time limit. This ensures a predictable data freshness.

Currently, First In First Out (fifo), Least Recently Used (lru), and Least Frequently Used (lfu) caching policies are implemented. These are refered to as policy caches. They are responcible for holding onto the data in the cache.

ShiftOne Features

Features are added by wrapping policy caches with "decorators". When a decorator is configured for a cache, your application operates on the decorator cache, which delegates to a policy cache. Behavior is configured by linking several decorators in front of a policy cache.

Support includes:
# Monitoring and instrumentation with JMX
# Clustering using JGroups or JMS
# Hit/Miss statistics reporting
# Memory sensitivity using soft references
# Hibernate ORM integration (adaptor)

There are also a number of adaptors that allows a cache to take on another interface.

How is a cache obtained?

This cache implementation strives to abstract from an application, the concrete implementation and configuration of a cache. For this reason, cache's should be accessed exclusively using the "Cache" interface (cache policies are not public classes, so this is required).

Both caches and cache factories may be obtained from a cache configuration. A cache configuration allows mnemonic names to be associated with various cache and factory configurations.

If an application absolutely needs to programmatically set the max size and timeout of a cache, then a cache factory should be obtained from the config first, and used to create a cache.

Why was this implemented?

JOCache was originally implemented as part of the ExQ project to support ResultSet caching. It was later split out for use by other projects. It was designed to cache large expensive database query results.

ShiftOne Project Home Page
http://jocache.sourceforge.net/

Download ShiftOne
http://sourceforge.net/project/showfiles.php?group_id=67753

ShiftOne API Documentation
http://jocache.sourceforge.net/api/index.html