My first ever work-related trip to Canada will be to Quebec this coming January 11th to deliver a presentation (in French) on Java EE.

This is an Oracle event around Java where I'll be a speaker together with my colleague Mike Keith.

Here are the details if you are interested in attending this free event :
• Oracle Canadian Java Briefing (English)
• Séance d’information sur Java (French)

As Henrik, Marcus, and Markus posted yesterday, JRockit Mission Control 4.1 (download) is out and it has two interesting features I wanted to try out: early support for HotSpot and a Mac OS version.

The best (the only?) way to test both of these features without installing the JRockit JVM itself is to install Mission Control as an Eclipse (3.7) plugin using its update center.

Once you switch to the Mission Control perspective, locally running JVMs (Apple's latest 1.6 JVM, the JDK 7 Developer Preview or OpenJDK) are all detected with "General", "MBeans" and "Runtime" sections very much functional. It's still early days with the Flight Recorder and Memory Leak Detector features not yet available.

Looking at a JVM running GlassFish 3.1.1, the application server AMX's are available once you initiate a bootAMX operation.

I'm back from my 8th (!) Devoxx conference (I don't think I've missed one since 2004) and this conference keeps delivering on the promise of a Java developer paradise week. GlassFish was covered in many different ways and I was not involved in a good number of them which can only be a good sign!

Several folks asked me when my Java EE 6 session with Antonio Goncalves was scheduled (we've been covering this for the past two years in University sessions, hands-on labs and regular sessions). It turns out we didn't team up this year (Antonio was crazy busy preparing for Devoxx France) and I had a regular GlassFish session. Instead, this year, Bert Ertman and Paul Bakker covered the 3-hour Java EE 6 University session ("Duke’s Duct Tape Adventures") on the very first day (using GlassFish) with great success it seems. The Java EE 6 lab was also a hit with a full room of folks covering a lot of technical ground in 2.5 hours (with GlassFish of course).

GlassFish was also mentioned during Cameron Purdy's keynote (pretty natural even if that surprised a number of folks that had not been closely following GlassFish) but also in Stephan Janssen's Keynote as the engine powering Parleys.com.

In fact Stephan was a speaker in the GlassFish session describing how they went from a single-instance Tomcat setup to a clustered GlassFish + MQ environment. Also in the session was Johan Vos (of Mollom fame, along other things). Both of these customer testimonials were made possible because GlassFish has been delivering full Java EE 6 implementations for almost two years now which is plenty of time to see serious production deployments on it.

The Java EE Gathering (BOF) was very well attended and very lively with many spec leads participating and discussing progress and also pain points with folks in the room. Thanks to all those attending this session, a good number of RFE's, and priority points came out of this. While this wasn't a GlassFish session by any means, it's great to have the current RESTful Admin and upcoming Java EE 7 planned features be a satisfactory answer to some of the requests from the attendance.

Last but certainly not least, the GlassFish team is busy with Java EE 7 and version 4 of the product. This was discussed and shown during the Java EE keynote and in greater details in Jerome Dochez' session. If any indication, the tweets on his demo (virtualization, provisioning, etc...) were very encouraging.

Java EE 6 adoption is doing great and GlassFish, being a production-quality reference implementation, is one of the first to benefit from this. And with GlassFish 4.0, we're looking at increasing the product and community adoption by offering a pragmatic technical solution to Java EE PaaS deployments. Stay tuned ! (the impatient in you is encouraged to grab a 4.0 build and provide feedback).

Si vous n'êtes pas à Colombes chez Oracle pour la journée OTN Developer autour de Java EE, vous pouvez vous joindre à un séminaire en ligne sur GlassFish ce jeudi :

GlassFish - Serveur Java EE Open Source et Opérationnel
Jeudi 3 novembre 2011
15h00 à Paris
10h00 à Montréal
S'enregister

Evénement gratuit Java EE et GlassFish la semaine prochaine chez Oracle France :
"Comment exploiter tout le potentiel de Java EE 6 et de GlassFish ? Pour cela, Oracle vous invite à un atelier pratique inédit qui vous permettra de découvrir Java EE 6 et développer avec GlassFish."

jeudi 3 novembre 2010 de 9h30 à 16h30.
Oracle France - 15, boulevard du Général de Gaule 92715 Colombes

Au programme: présentation et labs (venir avec son portable).
Inscriptions en ligne (places limitées).

Pour faire suite à mon billet du début d'année sur le livre "Développements n-tiers avec JavaEE" aux Editions ENI, voici maintenant l'ensemble du code source développé dans l'ouvrage qui est maintenant disponible. Il s'agit d'une application complète développée tout au cours du livre et testée dans GlassFish 3.1.x.

En parlant de GlassFish, voici un nouvel ouvrage en préparation.

JUG's are an increasingly important part of the larger Java community (see recent JCP elections) and yet only a fraction of Java developers attend regular meetings (as we found out at JavaOne).

Before I start I probably should say that while I don't have hard data to back this up, I've seen a large number of JUG's be created in the past 2-3 years, more than 10 years after Java was first introduced, accounting for maybe as much as half of today's active JUGs. In France alone, there is more than a dozen active JUGs that were created, all in the last 3-4 years. There doesn't seem to be a shortage of interest for Java, quite the opposite.

I don't run a JUG nor am I really active in one but I've been visiting many of them in the past few years (they tend to be the format that I like best), I've seen a good number of them take off, some crash, and I interact with several JUG leaders on a regular basis, so I thought I'd share the ingredients that I believe are key to a successful JUG.

First, you need to have a venue. It may sound obvious but the lack of a regular (hopefully free-of-charge) room for your meetings is often the reason for JUG activity going down or simply disappearing. Universities seems to be the best solution after company meeting rooms.

Second, you need sponsors. While this can cover for Pizza & Beer (or Wine & Cheese, you decide), maybe more importantly this should help you cover for your speakers expenses (travel + hotel). While those speakers employed by large companies should be able to expense their entire travel, you don't want to miss out on the independent consultants. Another option is to have formal JUG members paying a yearly fee. This works well once you have a well established set of events, including maybe a yearly (international) conference.

Third, last, and not least - you need good content. This is content that addresses your JUG's interests and it doesn't have to be always about bleeding edge technology of the latest and greatest JVM language. Some folks take JUG's as a training, others mostly as a get-together, and probably also a good chunk as a way to stay on top of what's new in the Java ecosystem. You need to balance different topics but my recommendation would be to have a small set of folks decide on the agenda. Voting or large groups of folks deciding don't usually work too well.

While all of the above probably applies for any technology user group, JUG's are a bit special because they are loosely federated by mailing lists and interactions are facilitated by Sun initially and now by Oracle. If you are starting a JUG, you probably want to read about it on this all-in-one page, be listed on java-user-groups and start chatting with fellow JUG leaders, they are a great bunch and will most certainly have tips for you.

I should of course not forget to mention that you'll need energy and passion to keep a JUG running. Lot's of it!

JavaOne was good this year but that was just the beginning of traveling for my month of October.

I'm just back from a very well-attended inaugural session at the Lava JUG (in Clermont Ferrand, France) covering Java 7 (together with Julien) and some JavaOne 2011 news. The event had 120+ participants. So pictures here. It's always great to hear about new JUGs popping up close to 15 years after the creation of Java (more on JUGs in a future entry).

This coming week, I'll be in Romania:
• Cluj Napoca on Wednesday 19th, 2011 in the Golden Tulip Hotel. Send email to register.
• Bucharest on the next day: Thursday 20th, 2011 in the Intercontinental. See event page for details.

The week after (October 27th), I'm participating in fOSSa in Lyon, France. This is, as the name implies, an Free/Libre open source software conference and I'm happy to see that Serli's Jerome Petit is also listed as a speaker to discuss the benefits he see for his company in their numerous open source contributions (GlassFish and others). Let this talk enlighten many others!

L'activité du forum francophone GlassFish sur developpez.com est toujours aussi importante et la croissance en quatre ans est impressionnante :

Septembre 2007 :

Septembre 2011 :

Ca représente une augmentation de x7,5 du nombre de discussions (contre x2.5-3 pour les autres) et de x6 du nombre de message (contre x2,0-3 pour la compétition).

L'événement est gratuit et propose pour la première fois un "track" dédié à Java.
Pour ma part, il sera question de JavaEE dans le Cloud.

Je ne sais pas si les classes seront chargées mais l'inspection académique a mis le paquet sur le nombre d'événements Java pour cette rentrée 2011.

• JUG Summer Camp le 16 septembre, déjà une tradition (La Rochelle)
• Soirée CDI au Mars JUG le 20 septembre (Marseille)
• Programme NormandyJUG, début le 20 septembre (Rouen)
• Open World Forum fait la Java, le 23 septembre (Paris)

Le tout donc sur une semaine et toutes ces conférences/réunions sont gratuites.

I recently posted a screencast showing how a simple JavaEE 6 web application can take advantage of Java 7's new language features (aka project coin). Here are more details on the code for the three Java 7 new language features shown. The full code is available here.

The first Project Coin feature shown (Java 7 refactorings start at 7:37 into the screencast) is Strings in switch statements. This is rather straightforward (a number of folks thought this was already supported) and if probably a good candidate to use with web frameworks which take user input as Strings.


String name = request.getParameter("name");
if ("duke".equals(name)) {
    vip = true;
    name = name.toUpperCase(); // let's visually recognize DUKE
} else if ("sparky".equals(name)) {
    vip = true;         // another VIP
}


String name = request.getParameter("name");
switch (name) {
    case "duke":
        vip = true;
        name = name.toUpperCase(); // let's visually recognize DUKE
        break;
    case "sparky":
        vip = true;         // another VIP
        break;
}

Of course you can also have a default: section equivalent to an else statement.

The second feature is try-with-resources and is shown here in the initializing sequence of a stateless EJB. It uses JDBC to ping a well-known system table. The code specifically relies on the fact that multiple classes in JDBC 4.1 (Connection, Statement and ResultSet) now implement the new Java 7 java.lang.AutoCloseable interface. This is what allows for the following code requiring proper closing of resources :


@PostConstruct
public void pingDB(){
    try {
        Connection c = ds.getConnection();
        Statement stmt = c.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT * from SYS.SYSTABLES");
        while (rs.next()) {
            System.out.println("***** SYSTEM TABLES" + rs.getString("TABLENAME"));
        }
        stmt.close();
        c.close();
    } catch (SQLException ex) {
        ex.printStackTrace();
    }
}

... to be rewritten as follows (resources initialized in a single statement, no closing required as the compiler takes care of it when they go out of scope) :


@PostConstruct
public void pingDB() {
    try (Connection c = ds.getConnection(); Statement stmt = c.createStatement()) {
        ResultSet rs = stmt.executeQuery("SELECT * from SYS.SYSTABLES");
        while (rs.next()) {
            System.out.println("***** SYSTEM TABLES" + rs.getString("TABLENAME"));
        }
    } catch (SQLException ex) {
        ex.printStackTrace();
    }
}

As you can see in the source code, the DataSource is actually created using a @DataSourceDefinition annotation which is a new feature in Java EE 6.

The third and final part of the demonstration uses a somewhat convoluted piece of JPA code to illustrate the multi-catch feature. For the purpose of the demo, the JPA query (also in the above EJB) uses a LockModeType.PESSIMISTIC_WRITE (new in JPA 2.0) when building the JP-QL query and adds two catch blocs for PessimisticLockException and LockTimeoutException :


try {
    List customers = em.createNamedQuery("findAllCustomersWithName")
        .setParameter("custName", name)
        .setLockMode(LockModeType.PESSIMISTIC_WRITE)
        .getResultList();
    if (customers.isEmpty()) {
        doesExist = false;
        Customer c = new Customer();
        c.setName(name);
        em.persist(c);
    } else {
        doesExist = true;
    } catch (final PessimisticLockException ple) {
        System.out.println("Something lock-related went wrong: " + ple.getMessage());
    } catch (final LockTimeoutException lte) {
        System.out.println("Something lock-related went wrong: " + lte.getMessage());
    }
}

Which can be refactored to this equivalent code using multi-catch :


try {
    List customers = em.createNamedQuery("findAllCustomersWithName")
        .setParameter("custName", name)
        .setLockMode(LockModeType.PESSIMISTIC_WRITE)
        .getResultList();
    if (customers.isEmpty()) {
        doesExist = false;
        Customer c = new Customer();
        c.setName(name);
        em.persist(c);
    } else {
        doesExist = true;
    } catch (final PessimisticLockException | LockTimeoutException ple) {
        System.out.println("Something lock-related went wrong: " + ple.getMessage());
    }
}

This new language feature is *very* useful for reflection or java.io File manipulation, not quite the most common Java EE code out there.

Of course all of the above only works with JDK 7 at runtime and if running NetBeans 7.0.1 you'll also need to set the source level to Java 7 for the quick fixes to light up. I've also successfully executed this under Mac OS X using the OpenJDK Mac OS binary port.

Some resources :
• Full Source code.
• Screencast showing this "in action".
• String in switch statements.
• try-with-resources.
• Multi-catch and precise rethrow.

Java 7 is here! and so is GlassFish 3.1.1! Get them while they're hot!

New Java versions can sometimes take a bit of time before they're adopted because:
a/ your IDE doesn't support the new version and associated language constructs
b/ you're a server-side developer and it'll be a while before your application server supports that new version of the JDK

Well, with Java 7, things are different with the quasi-simultaneous releases of JDK 7, NetBeans 7.0.1 (coming up very soon) and GlassFish 3.1.1! Here's a new screencast on the GlassFish Youtube Channel showing Java EE 6 development taking advantage of the project Coin features and running on GlassFish 3.1.1 and Java 7 :

Julien Ponge et moi-même serons à Lyon pour la soirée Java 7 du LyonJUG. En attendant, voici un entretient croisé réalisé par Agnès Crépet et Cédric Exbrayat sur Java 7 et autres sujets connexes et posté sur le site Duchess France.

Rendez-vous Jeudi 19h, à l'INSA de Lyon!

I find JPA and in particular EclipseLink 2.3 to be particularly well suited to illustrate the concept of multitenancy, one of the key PaaS features en route for Java EE 7.

Here's a short (5-minute) screencast showing GlassFish 3.1.1 (due out real soon now) and its EclipseLink 2.3 JPA provider showing multitenancy in action. In short, it adds EclipseLink annotations to a JPA entity and deploys two identical applications with different tenant-id properties defined in the persistence.xml descriptor. Each application only sees its own data, yet everything is stored in the same table which was augmented with a discriminator column.

For more advanced (or more realistic) uses such as tenant property being set on the @PersistenceContext, XML configuration of multitenant JPA entities, and more check out the nicely written wiki page.

I spent last Thursday in Brno to deliver a number of Java EE talks and a keynote at the Oracle Developer Java Conference. It was great because it had a good developer feel and was similar in spirit to other community-driven conferences that I recently attended. Maybe the best part was the attendance - well over 400 (excluding Oracle employees and speakers) which is great for a first time.

Dalibor Topic fought the ash cloud and managed to reach Brno to kick off the day with a Java keynote with updates on Java 7 and current thinking about Java 8 and beyond. Doug Clarke, Java Persistence Director of Product Management at Oracle was here to cover advanced JPA features as well as recent evolution in EclipseLink with a nice multi-tenancy demo (I understand there's a screencast coming soon). I took this opportunity to interview Doug on EclipseLink. The recording will soon be up on the GlassFish Podcast.

And of course, last but not least, the Prague web services engineering team was strongly represented and covering JAX-RS and Jersey. Given how the last session overran by more than half an hour I'd say this was a successful and engaging presentation. Both Marek (JAX-RS co-spec lead) and Jakub (Jersey lead) blogged about the event and shared code demo.

That's a pretty poor photo there that I have but I'm hoping to see better ones given the presence of a profesional photographer (doing a keynote and three sessions I sure felt like a rockstar with photos of me taken at each of them...).

Startup and shutdown actions is a pretty common use-case for enterprise development and GlassFish 3.x offers at least two different ways to implement such call-backs: lifecycle modules and EJB 3.1 startup beans.

The first one has been around for a little while and is called Lifecycle modules. These are specific to GlassFish and thus not portable to other application servers but they offer a simple and effective way to implement behavior that applies to the entire application server instance (or to an entire cluster), independently of any deployed application.

A single class implementing com.sun.appserv.server.LifecycleListener (available from as-install/glassfish/modules/glassfish-api.jar) can intercept five different events: Initialization, Startup, Ready, Shutdown, and Termination (check the documentation for more details). Here's a canonical example :

public class GlassFishEvents implements com.sun.appserv.server.LifecycleListener {

    private static final Logger logger = Logger.getLogger("admin.events");

    @Override
    public void handleEvent(LifecycleEvent le) throws ServerLifecycleException {
       switch (le.getEventType()) {
          case LifecycleEvent.INIT_EVENT:
             logger.severe("INIT_EVENT");
             break;
          case LifecycleEvent.READY_EVENT:
             logger.severe("READY_EVENT");
             break;
          case LifecycleEvent.SHUTDOWN_EVENT:
             logger.severe("SHUTDOWN_EVENT");
             break;
          case LifecycleEvent.STARTUP_EVENT:
             logger.severe("STARTUP_EVENT");
             break;
          case LifecycleEvent.TERMINATION_EVENT:
             logger.severe("TERMINATION_EVENT");
             break;
          default:
             logger.severe("UNKNOWN event");
       }
    }
}

Registering the lifecycle module can be done via the admin console or the CLI (asadmin create-lifecycle-module) with optional ordering (relative to other modules, similar to servlets), an enabled/disabled state (default is enabled) and the ability to prevent the server from starting if the module fails to load.

An alternate way is to use EJB 3.1 (part of Java EE 6) and in particular a bean combining the @Startup and @Singleton annotations. Its lifecycle methods marked with JSR 250 common annotations will contain the event callback logic. Here's a simple example simulation the creation of database tables :

@javax.ejb.Singleton
@javax.ejb.Startup
public class CreateTables {
    @PostConstruct
    public void init() {
       logger.warning("Creating tables");
    }

    @PreDestroy
    public void cleanup() {
       logger.warning("Dropping table...");
    }
}

While this offers a more portable solution, it has some notable differences with GlassFish lifecycle modules.

First of all there are only two events that can be intercepted: @PostConstruct, @PreDestroy which are application events, not runtime system events. Undeploying the application is also the only way to disable the behavior and since this is an application-level event interception, there cannot be action taken on other parts of the runtime on failure (arguably you can do a lot more in the rest of you application).

Finally there is no notion of ordering but rather you can express explicit dependencies using @DependsOn as shown here to simulate populating tables that need to be previously created :

@javax.ejb.Singleton
@javax.ejb.Startup
@javax.ejb.DependsOn("CreateTables")
public class PopulateTables {
    @PostConstruct
    public void init() {
       logger.warning("Populating tables");
    }

    @PreDestroy
    public void cleanup() {
       logger.warning("archiving table data");
    }
}

Also note that a Singleton approach only applies to a single instance (not a cluster-wide singleton). If you're wondering which approach to chose, it really boils down to whether you want to implement system-level or application-level events.

Of course you can combine the two approaches which would trigger a log similar to this one on a startup/shutdown cycle :

SEVERE: INIT_EVENT
WARNING: Creating tables
WARNING: Populating tables
SEVERE: STARTUP_EVENT
SEVERE: READY_EVENT
...
SEVERE: SHUTDOWN_EVENT
WARNING: archiving table data
WARNING: Dropping table...
SEVERE: TERMINATION_EVENT

After almost 7 years and almost 1000 entries, this blog was moved to the new blogs.oracle.com infrastructure (based on the very fine Apache Roller). Whether you're reading this in a feed aggregator or on the webpage, redirects should make everything transparent for you.

Clearly with the rise of twitter and the time spent on TheAquarium I have little time left for this blog, but do expect some activity on a weekly (or so) basis.

I resisted doing so for all those years, but with the move to pre-defined templates I felt it was time to put a photo up on the blog to differentiate the page a bit.

Quick note to share that I'll be in Brussels tomorrow (April 28th 2011) for a GlassFish session at the BruJUG. Details on this page.

I'm taking off tomorrow for Moscow to attend and present at JavaOne Russia. It'll certainly be fun to see snow after a 26deg week-end in Paris.

I'll probably record another Java Spotlight Podcast with the rest of the crew and we'll see how much Russian cuisine and walking around I'll get to do in the little time I'll stay there...

This is the first time JavaOne goes to Russia and I'm curious to see how different it'll be from the several Sun Tech Days I've attended in the past in St. Petersburg. It'll probably be one of my busiest conferences with multiple talks and hands-on labs. See you there!

Of course you can consider using the new GlassFish 3.1 because it is operations-friendly with full clustering and centralized admin or because it offers a great developer environment with fast startup, a modular architecture or application versioning but I'd like to argue that the GlassFish value is greater than sum of the parts and a devops appserver. Today.

In fact GlassFish is pursuing what it's been doing since version 2.x: hit a middle ground between the requirements from developers (latest APIs, lightweight runtime) and those from operations (manageable, stable, centralized admin). Here are some features which I believe to be relevant to developers, operations and QA :

• Fast startup: whether you're developing, testing or deploying an application, the time it takes to bring a service online is critical. GlassFish has had this for a while (even before 3.0) but the full modular architecture offers yet greater flexibility.

• Embedded API: while the new standard EJBContainer API is a great step forward, it mostly addresses the unit testing use-case while this feature offers an API to drive the entire set of GlassFish services and features.

• Maven plugin: easily integratable into your favorite continuous integration server. In a continuous deployment scenario and generally for automation, Maven and CI's are key tools to rely on.

• Domain-driven administration: the concept of a domain has been around for a while in GlassFish and with 3.1 the entire admin tools (CLI, Web and REST) scale from a single instance development or production config to a full multi-cluster environment. This makes for easy transfer of work from development to QA and/or to production and back.

• More questionable features (wrt Devops) are active redeployment and application versioning. While the former is recommended only in development the versioning feature can be used in many different ways for testing and potentially in production (with the caveat that only one application version can be active at a given point in time).

Of course there's much more to devops than just a product or technology. Is your application server devops-friendly?

With the growing use of Maven in enterprise projects, starting off with the best possible pom.xml is important. The good news is that there are a number of Java EE 6-related archetypes which can help you get started while offering IDE independance. The bad news is that their quality and portability in particular varies significantly.

The Java EE 6 platform APIs are now in Maven central : javaee-api:6.0 and javaee-web-api:6.0. These should be used with a provided scope and your POM should contain dependencies for the actual implementation (check this 3.1 download page for how to work with GlassFish).

Consider using that simple platform dependency rather than replying on archetypes introducing a long list of dependencies mixing APIs and implementations.

Jérôme Lafosse, ancien du CNAM et consultant formateur Java, vient de sortir son nouveau livre: "Développements n-tiers avec JavaEE".

Un nouveau livre sur Java EE et sur GlassFish, ça commence à devenir une habitude! J'ai participé à la relecture de plusieurs livres autour de Java et je dois dire que je trouve que les auteurs sont fous de consacrer autant d'énergie à rédiger le contenu et à le refaire plusieurs fois avant la sortie finale de l'ouvrage. Celui-ci n'échappe pas à la règle.

Au delà d'être écrit en français, ce livre est différent dans la mesure ou il ne se consacre pas exclusivement aux nouveautés de Java EE 6 mais s'adresse plutôt aux personnes qui souhaitent une couverture exhaustive de Java EE et n'ayant que des connaissances minimales sur le sujet. Par "exhaustif" j'entends qu'il couvre des technologies récentes comme CDI, Bean Validation, JAX-RS, comme des plus "traditionnelles" comme Servlet, EJB ou JSF mais aussi toutes les étapes de mises en oeuvre, y compris versioning d'applications, clustering GlassFish. Jérôme a suivi de près les développements de GlassFish 3.1 pour pouvoir proposer son livre seulement quelques jours après la sortie de GlassFish 3.1.

Le livre est imposant avec ses 900 pages (!) mais il couvre le développement complet d'une application ainsi que l'installation et l'utilisation de GlassFish, Hudson, NetBeans, Subversion, ANT, Eclipse, JUnit, et Selenium. Et pour ne rien gâcher l'éditeur propose la version numérique pour toute personne achetant le livre (c'est fou que ça ne soit pas une pratique plus répandue).

The next JavaOne conference is scheduled for in little over than a month (April 12-13, 2011) in Moscow, Russia, planning is well on its way and I'm happy to report that I'll be presenting a number of sessions there.

JavaOne Keynote speakers are none other than Steve Harris (Senior VP of Application Server Development) and Henrik Stahl (Senior Director of Product Management).

The preliminary schedule is here (expect a few minor changes). As you can see there is plenty of Java EE and GlassFish content.

Встречаемся на JavaOne !

GlassFish 3.1 est désormais disponible en version finale et il y a beaucoup de choses à dire (et comme d'habitude je n'ai pas le temps de faire quelque chose de court...).

Vu d'avion l'objectif de cette version majeure (à mon gout c'est presque une 4.0) c'est de réintroduire le clustering et l'administration centralisée sur un socle modulaire (OSGi) et complètement certifié Java EE 6. Dans les faits, il y a eu beaucoup d'améliorations autour du provisioning SSH (à la Hudson/Jenkins ou autres Hadoop), de la scalabilité du domaine multi-cluster, multi-instances, mais aussi des nouveautés comme le versioning d'applications contribué par Serli, les "scoped-resources", ou l'intégration de Coherence\*Web (sous le nom de ActiveCache for GlassFish).

Toutes ces fonctionnalités sont ou seront traités dans des blogs et énumérés sur TheAquarium. Il y aura également un nombre de videos égrainés au rythme d'une par jour. Bien entendu il y a également la documentation complète pour le produit (versions open source et Oracle): glassfish.org/docs.

Ah oui, j'oubliais, si vous insistez il y a même une version en français (dite "multilingual").

Following the example set by my colleague Geertjan, I delivered a half-day Java EE 6 tutorial to a group of a dozen or so students from Togo and a person or two from Burkina-Faso over skype. The material was heavily based on the Java EE 6 Tutorial delivered with Antonio Goncalves at Devoxx and available from beginningee6.kenai.com.

The students gathered at the Université Catholique de l'Afrique de l'Ouest in Lomé, Togo for this session put together by Horacio who I had met last summer in Brazzaville. Here's a picture of the group attending this short training :

The third webinar of the GlassFish Webinar Series aired Thursday last week and we had a good turnout with only limited technical problems (!).

I was presenting on "Building a Web Application with Java EE 6" and the replay is now available from the GlassFish YouTube Channel with the Q&A transcript now posted as well.

The webinar covered some basics for JSF 2.0, JAX-RS 1.1, and CDI 1.0. It is really close to the Java EE 6 Hands-On Lab delivered at JavaOne SF, Sao Paulo, Beijing and other places. The source code is on beginningee6.kenai.com with a detailed guide.

Upcoming webinars are announced on http://glassfish.org/webinars.

Hong's recent packaging response on the GlassFish Forum reminded me of other similar problems faced by GlassFish users.

When packaging applications in an EAR file, the library JARs need to be placed in the archive lib directory (jars at the archive root level are not added to the classpath and thus available from other EAR artifacts..

The library jars placed in the "/lib" directory of the EAR (the directory name can be overridden in application.xml) will be visible to all sub-modules (JARs, WARs, and RARs) with no further configuration. No need to add Class-Path entries in the EAR manifest.

In the sub-modules, you can use Class-Path entries to explicitly reference library JAR files you may need.

Of course you can also "install" those libraries in the GlassFish "/lib" directory but you may run into other problems since they would be visible and shared from all applications.

GlassFish also offers a asadmin deploy --libraries foo.jar option (something a good number of people end up using when looking for an equivalent to "shared libraries" offered by other containers).

Then of course, if you're like most server-side Java developer you could probably put your application on a diet and remove a few of those JARs to use what's already in the platform.

The GlassFish Update Center is a really severely underused feature of the product (IMO). Of course you can install GlassFish and simply ignore the update center and not use it to install updates, 3rd party frameworks, your own packages or upcoming patches but that would be ignoring one of the unique features of the product.

This new screencast shows how to setup a GlassFish Update Center repository behind your company's firewall. It shows access to support.oracle.com (which replaced sunsolve) to grab the content of the repository, setting up an internal server (a Publisher), and updating existing GlassFish installs to use it or installing new app servers from this repo.

The offline version is here (75 MB).

The screencast scenario is largely based on this "Extending and Updating GlassFish Server Inside a Closed Network" documentation (for GlassFish 3.0.1) and you may also find "Upgrading to Oracle GlassFish Server From GlassFish Server Open Source Edition" to be useful. Finally, the blog about support from Oracle mentioned at the end of the screencast is here.

Wishing you a successful 2011 and sharing the obligatory stats for 2010 :

The #1 entry on this blog for 2010 is "GlassFish 3.0.1 is out - Delivering on the community roadmap promise" (June 2010, accounting for more than 7% of the traffic). Other top entries include :
• "Using the EJBContainer API with or without Maven (but with GlassFish v3)" (Oct. 2009)
• "javaOne 2010 : Java EE 6 Panel "What do we do now?" notes" (Sept. 2010)
• "GlassFish without the IDE (quick survival guide)" (March. 2010)

Overal traffic was 46.29% from Google search engines, 29.65% from referring sites, and 11.30% was direct traffic.

More than 20% of visitors come from the US, and almost as much from France. Germany, UK, and India are around 5% each. Suriname, Gibraltar, Tuvalu, Timor-Leste, and Malawi each accounting for a grand total of 1 hit.

Compared to 2009:
• +32% Visits, -9% New Visitors (not sure how to interpret both).
• -12% for Firefox (still #1 at 54%), +180% for Chrome (#2 at 19%), IE still #3 but dropping by 25%
• 87.26% have Java enabled
• 70% still use Windows (Linux is 16% and Mac is 12%)

I don't think I've seen this tip mentioned before in blogs or documentation and yet have had the request from different users and customers. If you want to log all the asadmin commands, simply set the AS_LOGFILE environment variable to the name of a file.

% export AS_LOGFILE=/tmp/asadmin.log
% asadmin ...
% cat /tmp/asadmin.log
12/23/2010 14:31:33 EXIT: 0 asadmin list-domains
12/23/2010 14:32:39 EXIT: 1 asadmin start-domain
12/23/2010 14:33:27 EXIT: 0 asadmin start-domain
12/23/2010 14:33:58 EXIT: 0 asadmin list-domains
12/23/2010 14:34:04 EXIT: 0 asadmin list-applications
12/23/2010 14:34:21 EXIT: 0 asadmin undeploy org.beginningee6.tutorial_demo11_war_1.0
12/23/2010 14:38:13 EXIT: 0 asadmin stop-domain
12/23/2010 14:38:46 EXIT: 1 asadmin start-domain
12/23/2010 14:41:00 EXIT: 0 asadmin --verbose start-domain domain1
12/23/2010 14:41:58 EXIT: 0 asadmin get servers.\*
12/23/2010 14:42:14 EXIT: 0 asadmin get servers.server.server.resource-ref.jdbc/__TimerPool.enabled
12/23/2010 14:44:37 EXIT: 0 asadmin deploy ../../HelloHK2bis.war

If you think this should be the default behavior, file an issue (with "3.2" as the "Fix Version"). I'll vote for it!
If you're trying to troubleshoot asadmin (or simply curious) you can set export AS_DEBUG=true to obtain a chatty output.

While in Beijing for JavaOne China, I had the opportunity to do an interview with Roberto Chinnici. It is now available (just in time before the holiday traveling) on the GlassFish Podcast (Episode #71) and focuses mainly on Java EE 7. We talk about cloud, multi-tenancy, application versioning, modularity, timing for the JSRs and the release, and more (JAX-RS, JPA, Web tier, ...).

You'll excuse the background carols, the hotel lobby insisted on celebrating Christmas everyday, all day :-).

We interrupt this program to bring you some "signs" which some of you have requested following my previous Beijing posts.

maybe a quote by Antoine de Saint-Exupéry ?

Men's room in a shopping mall.

Another men's room. No comment...

Behave! (contributed by Geertjan)

While preparing for my demo in Nandini's JavaOne keynote in Beijing last week, I recorded myself delivering the demo ahead of time (there no such thing as too much preparation :). The scenario is short and doesn't get into many of the details but I thought I'd still share it here. I'd be happy to discuss details about how it was built.

The points I'm making in this short demo are :
• simplified JavaEE programing model
• right-sized Java EE Web profile
• full clustering in upcoming GlassFish 3.1
• OSGi dynamic services using CDI (in GlassFish of course)

For those not able to get to YouTube (bandwidth, great firewall, ...), I've posted the offline file here.

5 talks done! Two to go!

One talk done. Six to go!

So I've made it to Beijing, checked in the hotel, walked around the Olympic stadiums and had the privilege to be taken out to diner to a famous roasted duck restaurant. Since there is no twitter here, here are some pictures (more with local "signs" in another post, they're quite funny, inspirational or just really surprising).

Tomorrow is going to be the first very busy day with multiple rehearsals and a first presentation for Java licensees.

While a good number of my Oracle Java evangelist colleagues are in Sao Paulo for JavaOne, I'm busy preparing for JavaOne China which is starting early next week.

This event will have the traditional JavaOne Keynote, Technical Mobile, JavaSE and JavaEE keynotes and a long list of technical sessions. The registration numbers look \*very\* good. I'm still trying to nail down some details for the Java EE and GlassFish demo(s) but everything else is now ready.

The convention center for the event is located right next to the Olympic stadiums. I need to see if I can find the time to visit the bird's nest and the aquatic center. More once the event starts unfolding. Now on to getting some sleep before the trip and crazy event schedule. Here's a small subset of that :

In the Java EE 6 & GlassFish category :

Siva posted a great entry on the use of type-safe injection of dynamic OSGi services as few days ago which was followed by a blog on TheAquarium. There is now a short (4-min) screencast for this :

This demo requires a recent promoted build of GlassFish 3.1.
Check out this wiki page for all things OSGi in GlassFish : http://wikis.sun.com/display/GlassFish/OSGi.

I just love how fast this community can move!
Kudos to Henri and Gildas for the continuous build and the .dmg/pkg downloads.

• Java SE 7/8 platform and language JSRs have been filed ! (for some background information, check out "how to read a JSR" and "Majority or 2/3rds?").

• Release of NetBeans 7 Beta, with JDK 7 language construct support (and hints!) and a lot more. This beta version ships with GlassFish 3.1 build 29.

Coincidence ou pas, je ne sais pas trop.

N'empêche que la béta de NetBeans 7 vient de sortir.

Et ce qui est super avec cette béta, c'est qu'il est possible de déjà s'amuser avec les modifications du langage, modification faisant partie du project coin, et qu'on devrait retrouver dans le JDK 7.

Ca va vous permettre de voire directement sur votre code *** ce que ces modifications de langage vont vous apporter, que ce soit du point de vue de la lisibilité, compréhension, simplification du code (ou pas).

*** Disclaimer : n'essayer pas cela directement sur le code sur lequel vous travaillez tous les jours. Faites en une copie, et travailler sur la copie. Les changements de syntaxe sont justes des propositions. Et rien ne dit que cela se retrouvera tel quel dans le JDK 7. N'utilisez donc jamais cela sur un projet actuellement en cours de développement.

Plus d'infos ? http://wiki.netbeans.org/NewAndNoteworthyNB70

My first day at Devoxx was exhausting but quite satisfying. Our "Java EE 6 Tutorial, reloaded" session went very well, with all 15 demos working flawlessly, including the 4 new client demos, new slides for CDI, a "Gotchas" section and an overall pass on the slide deck. The feedback (questions, discussions, tweets, ...) was very good and many asked about the address for the demos, so here it is: http://beginningee6.kenai.com/ (code is in the trunk, we'll tag it soon). The slides are here.

In the afternoon, Antonio and myself decided that three hours of talking wasn't enough so we took on to run a Hands-On Lab for another 3 hours. This was another set of reasons for satisfaction: 40+ people (full room) with no one leaving because of technical issues (quite rare in HOLs) and lots of good conversations comparing NetBeans to other IDEs, JSF to Struts, CDI/EJB to Spring, etc...

Overall it seems people attending were happy going through the (admittedly simple) three exercises on JSF, JAX-RS, and CDI. Those exercises and the instructions document are available from this URL. Check the README.txt file which will tell you which projects to use (with or without Maven).

Of course, as always, lots of familiar faces and fun discussions. Now looking forward to the keynote sessions tomorrow (JavaSE) and Thursday (JavaEE).

Devoxx 2010 is starting in a few hours and I'll be on the train tomorrow to Antwerp. I'll have a pretty busy schedule with a tutorial, a hands-on lab, and a BOF.

So this year again, I'm giving a Java EE 6 Tutorial with my friend Antonio Goncalves. We called it "reloaded!" for a reason: it is not a repeat. A lot has happened in the past 12 months: Java EE 6 was released (and GlassFish had 3.0 and 3.0.1 releases), Oracle finally acquired Sun, CDI is getting traction, vendors are delivering, and to be bluntly honest, we've made progress in our understanding of the platform. So expect demos (including a number of new ones), new topics (mainly CDI), putting Java EE 6 portability to the task with an additional runtime, and a few new fun things. The session is at 9h30 on Tuesday.

Devoxx is having Hands-On Labs for the first time this year and attendees will be able to attend a self-paced, Java EE 6 Lab on the Tuesday afternoon which would be a great follow-up to the morning session. The only requirement for this is to come with a laptop with NetBeans 6.9.1 (java version with GlassFish) loaded (no more Maven required, it's just a bad idea with conference wifi). The rest is in the instructions we'll hand out at the beginning of the session. I'll blog after the conference about where you can find everything to work through those three exercises and get you feet wet with Java EE 6.

In other Java EE 6 festivities from fellow colleagues :
• Paul Sandoz will be able to discuss how JAX-RS integrates with the rest of the Java EE platform as well as present content from the recent JSR proposal for JAX-RS 2.0 (packed with useful stuff IMO).
• Linda DeMichiel will cover JPA 2.0 (I tend to learn something new every time I hear a JPA 2.0 talk) and a more advanced talk about the Java Persistence Criteria API.
• GlassFish architect Jérôme Dochez will cover the HK2, multiple-purpose kernel in his "HK2: Oracle WebLogic Server, Oracle GlassFish Server, and Beyond" session and will, of course, lead the GlassFish BOF.
• Ludo will cover the tooling aspects comparing NetBeans, Eclipse and IntelliJ when it comes to supporting the Java EE platform today.

They will all be giving the Java EE future keynote on Thursday morning.

There are many more interesting server-side sessions from the guys at JBoss, a must see performance by Adam Bien, a couple WebSockets presentations [1], [2], some OSGi talks, and a lot more.

Beyond the (almost) mandatory "Future of Java" and other JDK 7 talks, I'll also try to hit the NoSQL, Cloud and DevOps sessions, time and socializing permitting.

• GlassFish Podcast on Play! to celebrate their 1.1 release and their GlassFish container.
• First patch release for GlassFish 3.0.1. This is for paying Oracle GlassFish Server customers. Others will get the fixes as part of 3.1.
• Details on CDI/Weld in the upcoming GlassFish 3.1 release. Hoping memory and performance issues are all behind us.
• Oracle JVM strategy clarification. Best quote: "We estimate that the contribution of code from JRockit into OpenJDK will be one of the largest - if not the largest - single contributions to the project since its inception."
• Get The Facts: MySQL Licensing and Pricing. Community Edition still free+GPL+InnoDB.
• JDK 7 Support in NetBeans IDE 7.0. Ok, when do I find the time to try this all out?

and last but certainly not least :
• Apple Joins OpenJDK!, (with some details from an Apple engineer).

• that "Java for Business" has offered Java 1.4.2 and Java 5 (both EOL'd) support to paying customers for the past 3 years ?
• that Doug Lea committed to working on OpenJDK ?
• that Oracle proposed the Apache Foundation and Red Hat for the JCP ratified seats ?
• that JCP membership is free for individual members ?

just sayin'...

The folks in the NLJUG certainly know how to build a community and run events. JFall 2010 was in a new location this year (rather small Nijkerk, but you can get to pretty much anywhere in The Netherlands by train) and it was sold out at 1000+ attendees. And this is just a couple of weeks before Devoxx, another major Java conference literally miles away.

The conference started off with Danny Coward's keynote which was really well attended. His content had meat (JavaME, JavaSE, JavaFX, and JavaEE) and the feedback was positive. At diner with Bert and the rest of the NLJUG team the day before, I was told that my Java EE 6 talk had the most registrations and indeed the room which was used for the keynote looked far from empty even with 6 tracks in parallel. My talk focused on Java EE 6, how we got there, and what's causing the revival of flamewars on some community sites and overall excitement for the new platform. I managed to cram servlet3, ejb31, and cdi10 in a 3-minute closing demo. Reading the tweets after the talk seemed to indicate that people liked the session and learned several things.

Later in the day, I delivered a hands-on lab no less than three time with a total of 60 or so participants getting a feel for Java EE 6. The updated code and instructions for the labs are here. This went well after I realized we'd have no network and moved to non-Maven projects. GlassFish 3.0.1 and NetBeans 6.9.1 proved to be a good simple and sufficient combination for the labs (most people installed them on the spot).

I really enjoyed the discussions there on the night before, after a my talk, over lunch, during the labs and on the train on my way back. Lots of energy. So much for a dying Java community and technology!

Roger get-a-blog Brinkley and Terrence Barr started a new weekly podcast, called the Java Spotlight. My colleague Dalibor Topic and myself are also participating in a panel. The first episode is already out with an interview with Mark Reinhold, Chief Java Architect on the future of Java SE recorded at JavaOne (Plan A, Plan B), a news section and more.

We've just recorded the second episode which should be up shortly with an interview of Steve Harris, Senior Vice President of Application Server Development at Oracle on the Sun acquisition, Java EE, and future of GlassFish.

Here are the compulsory podcast coordinates :

• Homepage (blog): http://javaspotlight.org/
• Podcast feed: http://feeds.feedburner.com/thejavaspotlightpodcast
• Subscribe from iTunes
• Feedback: feedback-AT-javaspotlight.org

PS: No, this does not mean that the GlassFish Podcast is going silent.

As part of my various Java EE 6 and GlassFish presentations, I was in Luxemburg last week visiting the YaJUG. The other speaker having declined a few weeks before the event, I ended up doing a two part presentation, the second one focused on GlassFish (slides). I think both went well but I'll confess that I received the same feedback from three different attendees - GlassFish 3.x needs to have clustering before it is seriously considered as a strategic runtime for their company (lots of banks in Luxemburg).

I honestly didn't think that lacking clustering in 3.0.x was such a big issue for the following reasons:
• Java EE 6 and modularization (HK2/OSGi) were more important
• people are still building Java EE 6 applications
• GlassFish 2.1.1 provides state of the art clustering today for Java EE 5 applications
• GlassFish 3.1 (which has Clustering as its main theme) will follow the 3.0.1 release by less than a year to provide a second-generation Java EE 6 product with centralized admin, load-balancing, and HA.

Now, perception is more important than my personal take on this so, here's where GlassFish 3.1 stands :
• it is feature-complete and Milestone 6 was released just today, so try that build out : Full distro (79MB), Web Profile (51MB)
• Shreedhar discussed some of the HA improvements (see this post on TheAquarium)
• FishCAT is back!

Get the full schedule from the GlassFish Wiki.

Listen to podcast #2: to learn about our take on Swing and its poor reentrancy. Find out what it may mean for your own API design and especially Runtime_Aspects_of_APIs that you create. Learn to fight with that problem by maximizing the declarative nature of your API. --JaroslavTulach 17:43, 18 May 2009 (UTC)

Listen to this: ! It is almost a year since we (me and Geertjan) started our regular API Design Tips podcasts. They used to be part of larger NetBeans podcasts, however recently I needed some promotion material for TheAPIBook and I decided to extract the API Tip parts. I am glad I can offer these sketches to you. Enjoy podcast #1. --JaroslavTulach 19:50, 12 May 2009 (UTC)

Sun propose maintenant à son catalogue une Certification EDI NetBeans.

[...] Lire la suite!

NetBeans Visual Web Pack, vous connaissez ?
Mais saviez-vous que NetBeans Visual Web Pack, qui vous permet de concevoir visuellement vos applications JSF, reposait sur les composants du projet open source Woodstock.

Sun vient d'annoncer qu'il n'allait plus continuer à supporter Woodstock. Que faire ?

[...] Lire la suite!

Lorsque Sun dit que JavaFX n'est pas encore disponible sous Linux, c'est parce que le support pour la vidéo n'est pas encore parfaite. Mais en fait, pour le moment, tout le restant fonctionne. Il est parfaitement possible pour une personne n'ayant que Linux d'écrire des applications JavaFX.
[...] Lire la suite!

As I noted recently, I see the year 2009 as the year of annotations. The NetBeans project is about to rely on them more heavily. Finally! We've been waiting for that for ages, but finally we can compile with JDK 1.6 JavaC and we can use compile time annotation processors. As a result we can replace our layer based registrations with annotations and benefit from compile type checking, code completion, from having the registrations in the same place as the code that is being registered, etc. Also we can offer our API users simple looking annotations and let associated annotation processors do more advanced and more effective processing. As a result the developers have simple API to deal with, while actual registration hidden behind can be as effective as possible, even at the cost of complexity, but without compromises to reliability (as the complexity is kept in the processing infrastructure, not exposed to API users).

The other project related to annotations that we are likely to incorporate during 2009 is our extended use of Annotations for Software Defect Detection. This is heavily based on the JSR 305, yet until it is stable we do not want to expose such unstable API to users of our stable APIs (more on that in Chapter 10, in section Beware of Using Other APIs). As such we are going to create our own annotations (still recognizable by FindBugs and co.). The hope is that our annotation will stay compatible even if the underlaying JSR 305 slightly changes. Please find our current patch and comment here or in the issue 137437.

Last project that deals with annotations is developed by our editor hints guru Jan Lahoda - its aim is to bring complex refactoring to masses! How? Why? We have observed that using @Deprecated annotation is good hint to help your API users recognize that some part of your API is obsolete and shall no longer be used, however that in no way helps users of your API with converting their code to new, non-deprecated style. We have a solution: Use Code Transformation Annotations! Dear [API] writers, let's adopt these annotations and use them in your API! They are completely standalone (read more), lightweight and we are ready to incorporate feedback of everyone interested in the project. Indeed, my plan is to bring these easy to use and flexible refactorings to NetBeans soon, hopefully for version 7.0.

So these are my three annotation related projects. I find them quite exciting and I cannot wait to see them being used. Annotations are here to simplify life of API users and developers. As soon as we have them, we will have full right to call the year 2009 the year of annotations!

--JaroslavTulach 09:06, 12 December 2008 (UTC)

Le NetBeans Innovators Grants, programme initié par Sun, est maintenant terminé.

Après avoir opéré une sélection d'une vingtaine de projets parmi plus de 170 soumissions, au mois d'Avril 2008, les projets devaient être terminés pour le 8 août au plus tard, faisant place aux vérifications, votes, délibérations, ...

Finalement, les résultats sont connus.
[...] Lire la suite!

http://www.jaspersoft.com/nw_press_jaspersoft_iReport_NetBeans.html

JasperSoft, la compagnie qui derrière les outils open-source de Business Intelligence JasperReport, vient d'annoncer une nouvelle version de son outil WYSIWYG d'édition de rapports iReport, sous forme d'un module NetBeans. La version officielle sera disponible en février, mais une version beta est disponible sur le nouveau portail Plugins de NetBeans.org.

Ce qui est intéressant également, c'est la petite phrase dans le communiqué de presse:
Usable as a NetBeans IDE plug-in or a stand-alone application

Si je lis bien entre les ligne, il s'agira donc de la prochaine version de iReport (version 3?), qui sera disponible de deux manières, soit sous forme d'une application indépendante, soit en module NetBeans. C'est là un bel exemple des possibilités offertes par la plateforme NetBeans!

Pour en savoir plus sur JasperReport et iReport:

• http://www.jasperforge.org/
• http://www.jasperforge.org/jaspersoft/opensource/business_intelligence/ireport/

http://doc.ubuntu-fr.org/netbeans

NetBeans 6.0 est disponible depuis moins d'une semaine, et voilà qu'un membre du club Développez, srvremi, nous propose une très intéressante contribution: il a empaqueté NetBeans 6.0 pour pouvoir le distribuer et l'installer via les outils traditionnels de ces Debians: apt-get, synaptic ou autres.

Le travail est remarquablement fait, puisque NetBeans est découpé en 7 paquets (Java SE, Java EE, UML, C/C++, Ruby, Mobility, SOA) et trois Runtimes (Tomcat, Glassfish, Open ESB).

Vous trouverez les adresses du dépôt sur le blog de srvremi ou sur la page Netbeans d'Ubuntu-fr.org.

Du bon boulot!

http://www.netbeans.org

Un peu plus d'un an après NetBeans 5.5, sa dernière version majeure, quelques mois après la sortie de la version 5.5.1, NetBeans atteint un nouveau palier avec la publication de la version 6.

Au programme de cette nouvelle évolution, en plus de la nouvelle icône: l'intégration des extensions de NetBeans 5.5 dans l'EDI (Mobility, Profiling, Visual Web Pack mais aussi UML), un support avancé pour Ruby, le projet Schielmann qui permet de facilement construire le support pour un nouveau langage dans l'EDI, le support de Glassfish V2...

Mais surtout, le coeur de l'EDI, l'éditeur, a été totalement refait pour fournir aux développeurs des fonctionnalités et des performances "top of the art", à la mesure du reste de l'application. L'éditeur est vraiment devenu un réél plaisir à utiliser, rapide, efficace et agréable.

• Télécharger NetBeans 6.0
• Tutoriaux et documentation.

Vous pouvez partager vos impressions sur le forum!

[...] Lire la suite!

http://www.netbeans.org/community/releases/60/index.html

Après deux versions beta au cours des derniers mois, NetBeans 6 vient de franchir l'étape de la version Release Candidate avec la disponibilité de la RC1, téléchargeable ici. La date de parution définitive est toujours fixée au 3 décembre.

Au programmme de cette nouvelle évolution, en plus de la nouvelle icône: l'intégration des extensions de NetBeans 5.5 dans l'EDI (Mobility, Profiling, Visual Web Pack mais aussi UML), un support avancé pour Ruby, le projet Schielmann qui permet de facilement construire le support pour un nouveau langage dans l'EDI, le support de Glassfish V2...

Mais surtout, le coeur de l'EDI, l'éditeur, a été totalement refait pour fournir aux développeurs des fonctionnalités et des performances "top of the art", à la mesure du reste de l'application. J'utilise NetBeans 6 depuis la beta1, je dois avouer que c'est un plaisir de travailler dans le nouvel éditeur.

• Télécharger NetBeans RC1
• Quoi de neuf en un coup d'oeil.
• Quoi de neuf en détail
• Tutoriaux et documentation.

Vous pouvez partager vos impressions sur le forum!