Too often today, enterprise applications are built to work, but not to last. Custom modules and services are inflexible to change and hard to maintain and debug. For the services that J2EE provides, it has been a boone to the development of quality software, but what about the services that aren't offered yet, or need to be lighter-weight? Carbon exposes technical components with a consistent and robust mechanism for management and configuration while providing lifecyle and component control services.

The Carbon Framework is a set of core functionality and a model for building lightweight technical services in Java. It is designed for enterprise solutions where robust components with flexible management and consistent configuration are required. The foundation of Carbon is an XML-based configuration service that supports a namespace of strongly-typed and editable configuration data. Technical components like cache services or schedulers can be deployed and managed through Carbon's configuration service and are easily substistuted with alternate implementations. The management capabilities are provided though JMX, facilitating the maintenance and monitoring of services.

Carbon is designed for J2SE 1.3 or higher but works well within J2EE servers and can use their JMX services. However, the rich configuration capabilities can be used for any part of a Java application independent of the component model. Configuration documents maintain their formatting across edits and it is easy to define new complex data types and programmatically construct, edit and save data. The configuration services are also enriched by the concept of deployment settings which will allow complex environments to be modeled and stored in a single directory structure, Jar file or JNDI service, while taking on the appropriate customizations for their location.

For more information, see the carbon project homepage at http://carbon.sf.net.

Has anybody tested if it's able to create a Cache for clustered environment too?

Carbon does not yet have a supported cluster capable cache. There is, however, an experimental one based on the JavaGroups multicast capable clustering support. It still needs more work though.

Who cares? This is top priority news of the day? Yeah right.

After using ATG Dynamo for the last 4 years or so, I am now in the pure J2EE world. But I really miss the Nucleus, which is (among other things) a very nice component/configuration framework. What other component/configuration frameworks are out there, besides Carbon and the Bean Factory/Application Context stuff from Rod Johnson's book?

There are a couple of other frameworks that have a similar concept to them out there. The biggest would probably be the Avalon framework from the Apache group and the Core Services Framework (CSF) from HP, though there have been others.

I'd love to see some discussion on the differences between these and some idea of what things people would want to see in these frameworks.

From my perspective, HP-CSF was an early and neat idea into the concept of components with lifecycle. It was even considered and I think accepted as the basis for JSR-111, but I don't know what its status is. Avalon seems to have some more complexity to them in that they allow for different implementations of a container (and there are a few you can try).

For us, Carbon was primarily a way to make the job of framework writers easier. We had done it for many years and built many reusable components, but they we're missing that basic layer that had to be reconstructed for each new service. This was a way to build structure around that process and we feel we've made good progress. We're happy with the ability to easily and repeatably build manageable, configurable services that have some fairly advanced features. For me, the configuration aspect is the part that is the farthest ahead of the current specifications and there hasn't been many projects to tackle it. JConfig, preferences and digester(sortof) are all that come to mind.

(Stuart Dabbs Halloway also wrote about some of these ideas.)

Having developed until now with Turbine as a services framework, which seems to be somewhat inadequate for "full" j2ee development (at least in the version 2.1 that is used as the basis for our architecture) I was searching for something that provides something similar to its concept of service, and maybe Carbon may fit our needs: we will try it out in the next few weeks. In the meanwhile, thanks for making it available as open source!

I noticed confix on http://www.sapia-oss.org/

by "preferences" you mean http://sourceforge.net/projects/jpreferences/ ?

Those are also interesting extensions of the basic configurations that people have been using since PropertyBundles appeared. I like the way JPreferences extends the util.prefs (what I was originally talking about), to support JavaBean syntax.

Carbon configuration, however, was designed to do more. We wanted a mechanism that could truely support the complex configurations that are needed for a large scale enterprise application. We spent years supporting a configuration service that had functionality similar to util.preferences and decided that we needed more. Carbon config supports a namespace of documents that each represent a complex configuration. This namespace can live in ldap, jars or on the filesystem and are automatically found by the service. (No more finding and reading files manually). This also gives Carbon config the control to do intelligent caching, and an event system for notifying on config changes.

Carbon configurations are also rich-object's that are defined by an interface and they support arbitrarily complex types. Also, the configuration files are directly mapped to the bean such that altering one property will not cause formatting changes to the rest of the document. A pluggable data validation service rounds out the capabilities to make a pretty neat service.

I tried using this module iwth whatever limited documentation available and failed. Do you have any sample application to demonstrate how it works?

The Sapient Carbon framework looks very well designed, also the documentation is eventually GOOD. But, why not to include some sample code to clarify some of the framework issues?

I completely agree with you. Although the available documentation is much
better than the average, it seems a daunting task to get it working without
any example or tutorial.

> The Sapient Carbon framework looks very well designed, also the documentation is eventually GOOD. But, why not to include some sample code to clarify some of the framework issues?

Taking a break from the sessions at JavaOne we packaged up the Skeleton/Sample application we had been working for people to download and take a look at.

Inside the carbon_sample_2_0.zip's Implementation is a structure meant to be a good starting point for developing J2EE applications based on the Carbon framework. The basic jars and config files an application would need.

There's also a demo directory that can be directly copied into the Implementation. The demo contains an example component with configuration that gets called from a JSP through either a JavaBean or EJB.

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



Also, you can take a look at the jUnit test harnesses and test configurations in the main source download. This is a lot more complex than what's in the sample structure.