Planet NetBeans

NetBeans Ruminations » NetBeans: Quick Tip: Changing the Order of JavaHelp Topics

2012-07-31T19:27:16+00:00

Adding JavaHelp topics to a NetBeans Platform application is made really easy by the NetBeans IDE. Run the New File wizard, and choose the Module Development category, and under File Types pick JavaHelp Help Set. The wizard will generate all the necessary files for you.

The one thing in the process that was not obvious to me when I did this recently, is how you change the order in which help topics appear in the final product. It is in fact also very easy once you know how.

Open the generated package-info.java file, and have a look at the @HelpSetRegistration annotation. You will notice that it has a position attribute. And changing the position of the set in the final product is as simple as changing that value!

APIDesign - Blogs: How Strict a Backward Compatibility Should Be?

2012-07-31T12:13:00+00:00

Here are some thoughts on the difference between 100% BackwardCompatibility and their slightly more practical variants.

--JaroslavTulach 12:13, 31 July 2012 (UTC)

praxis » NetBeans: Video Rough Cuts #1

2012-07-30T22:05:07+00:00

I’ve just started doing a series of videos of Praxis LIVE in action. These rough cuts are unedited except for addition of titles, and are straight screencasts without voiceover. At some point in the near future I’ll look at doing … Continue reading →

Bistro! 2.0: Google Developer Live – Tous les contenus, tous les jours

2012-07-27T13:59:37+00:00

Google Developer Live (GDL) a été lancé peu de temps avant Google I/O 2012 et propose du contenu technique sous forme de vidéos: courtes démonstrations, webinars, présentations complètes ou office hours, qui sont elles interactives par nature avec l’utilisation de hangout on Air (discussion dans un Google + Hangout, (re)diffusion et avec YouTube).

Les sujets traités vont de Android à Chrome en passant par Google+, AppEngine, YouTube, Maps et autres APIs Google.

Coté Cloud, il y a par exemple cette courte présentation des différentes solutions de stockage (Cloud Storage, Datastore et Cloud SQL) et de requêtage (REST, SQL, BigQuery). Il y a aussi des formats plus longs comme ce tutorial sur l’API Search d’AppEngine, un tutorial interactif sur l’API Google MAPS, cette session sur le language Dart couplée à une série de questions sur Google Moderator ou encore ces réflexions de Robert Scoble sur le monde des startups.

Coté Android, il y a les Office Hours (horaire Européen) pour poser ses questions et les Friday App Review (ici avec Reto Meier).

Vous trouverez un agenda complet sur le site Google Developer Live ainsi que tous le contenu archivé sur YouTube. Il se passe quelque chose tous les jours!

“Bon, et le contenu en français c’est pour quand?” Stay tuned!

Filed under: Uncategorized Tagged: gdl, google, live, youtube

NetBeans RSS Feed Filter: JAX-RS Tip of the Day: Basic Client Authentication

2012-07-27T12:42:47+00:00

This is the second part of the JAX-RS Tip of the Day: Basic Authentication with JDBC. If you have not already done the pre-requisites, please examine the other article first.

Abstract

Unless you are developing a public service where authentication is not required like weather, or time services. This means that you will require authentication, and authorization. This application demonstrates how to perform basic authentication. This may be all that is required for your application, as long as, it is operating in a secure environment, or using secure transport (HTTPS).

Technical Details

If you have already completed creating a secure service, then you will really like how easy it is to create a basic authentication client for that service.

Requirements

As you can see from the code below. The most important item is to add a HTTPBasicAuthFilter to allow you to authenticate. Its that simple... really.

ExampleResourceClient.java

package com.bluelotussoftware.jersey; import com.sun.jersey.api.client.WebResource; import com.sun.jersey.api.client.filter.LoggingFilter; /** * REST Basic Authentication Client Application * * @author John Yeary * @version 1.0 */ public class BasicAuthenticationClient { public static void main(String[] args) { ExampleResourceClient erc = new
    ExampleResourceClient(); erc.setUsernamePassword("jyeary", "test"); System.out.println(erc.getMessage()); erc.close(); } static class ExampleResourceClient { private com.sun.jersey.api.client.WebResource webResource; private com.sun.jersey.api.client.Client client; private static final String BASE_URI = "http://localhost:8080/secure-jdbc-rest-service/resources"; public ExampleResourceClient() { com.sun.jersey.api.client.config.ClientConfig config = new
    com.sun.jersey.api.client.config.DefaultClientConfig(); client = com.sun.jersey.api.client.Client.create(config); client.addFilter(new LoggingFilter()); webResource = client.resource(BASE_URI).path("example"); } public String getMessage() throws com.sun.jersey.api.client.UniformInterfaceException { WebResource resource = webResource; return resource.accept(javax.ws.rs.core.MediaType.TEXT_PLAIN).get(String.class); } public void putMessage(Object requestEntity) throws
    com.sun.jersey.api.client.UniformInterfaceException { webResource.type(javax.ws.rs.core.MediaType.TEXT_PLAIN).put(requestEntity); } public void close() { client.destroy(); } public void setUsernamePassword(String username, String password) { client.addFilter(new com.sun.jersey.api.client.filter.HTTPBasicAuthFilter(username, password)); } } }

Geertjan's Blog: On Vacation

2012-07-27T07:00:02+00:00

...and I will not be bringing my laptop. Back on Monday, August 13th!

NetBeans RSS Feed Filter: JSF Tip of the Day: Schema Declaration Issue

2012-07-26T20:42:29+00:00

This is not so much as a tip as a warning. If you are trying to use the published schema at Java EE : XML Schemas for Java EE Deployment Descriptors and specifically the facelet-taglib schema from the definition, it has a typo in the declaration.

INCORRECT

CORRECT

Do you see the error?

It is in the schemaLocation. They misspelled library as libary in web-facelettaglibrary_2_0.xsd.

I try to confirm the schema from the source rather than copying it from some other non-authoritative source. This time I found a problem with the cannon source.

praxis » NetBeans: The Influence of the Actor Model (Praxis architecture 101)

2012-07-26T18:59:44+00:00

No, not a post about my salacious exploits with a C-list Hollywood celebrity (that’s for a different blog ), but a technical overview of a key aspect of the Praxis architecture. Absolutely essential to Praxis’ media neutral architecture, as well … Continue reading →

NetBeans RSS Feed Filter: JAX-RS JUG Demo CDI and @Singleton Usage

2012-07-26T12:44:17+00:00

This is the last demonstration I gave at the Greenville Java Users Group (GreenJUG) on CDI and JAX-RS. I cleaned up the code, but not as much as you would think. I managed to code this in about 15 minutes during the meeting live while everyone watched. It was a fun experience, but the best part is that it worked during a live un-rehearsed demo.

It goes to show you that CDI and JAX-RS are simple enough in combination to use in a live high stress demo environment. Imagine what it could do for you in your code. This code was written using NetBeans 7 IDE which may be responsible for the simplicity as much as the other technologies.

Here is the source code: cdi-example.zip

The code below demonstrates some interesting bits. The source code above contains the less interesting POJOs.

PersonResource.java

PersonDB.java

Geertjan's Blog: Plug A Custom BasicTabbedPaneUI into the Mavenized NetBeans Platform

2012-07-26T10:54:30+00:00

Two NetBeans Platform developers, Bo Conroy and Adriana, mentioned at the end of my blog entry here that plugging in a new tabbed component factory doesn't work for them in their Maven-based NetBeans Platform application. The reason for that is that, in my example code, I used JTabbedPaneAdapter, which is an implementation class in "org.netbeans.core.windows".

So, you could do different things. (1) Create an issue to make that class public (that's something I'll be doing soon), though there may be reasons why this isn't done already. (2) Create your own implementation of "org.netbeans.swing.tabcontrol.customtabs.Tabbed", which could be a bit of work and currently isn't documented. That's something I'll be working on soon. (3) Set the "org.netbeans.core.windows" module as a friend module of your own module, which means that you're conscious that you're using an internal NetBeans Platform class and that if it changes unexpectedly you can't complain because you knew up front that you're not going to be using a public API.

This is how you do that:

Find the Module Descriptor (module.xml) file in the module where you want to use an internal class:
In that file, paste this content:
```
<?xml version="1.0" encoding="UTF-8"?> <nbm> <dependencies> <dependency> <id>org.netbeans.modules:org-netbeans-core-windows</id> <type>impl</type> <explicitValue>org.netbeans.core.windows/2 = 201207171143</explicitValue> </dependency> </dependencies> </nbm>
```
The pattern for impl dependencies is XXX = IMPL_VERSION where XXX is the codenamebase and IMPL_VERSION is the implementation version from the module's manifest. (Read here.)

The explicitValue element can be constructed by looking in the manifest of the JAR that you want to make your friend:

Then build the application and everything will work as expected:

Sources of this sample are here:

http://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.2/misc/MVNTabPaneDemo

NetBeans Ruminations » NetBeans: Building Multiple Selected Maven-Based Modules

2012-07-26T05:42:01+00:00

Sometimes a small change in an application can make a pretty big difference in user experience. A colleague of mine installed the NetBeans IDE 7.2 yesterday. And after a while he commented that you can now select multiple Maven-based module projects and choose the build action from the context menu! It might seem like an insignificant change, but with our 3-tier application a change can often stretch over multiple modules. So for us this is definitely useful!

Do keep in mind though that the multiple builds are started in parellel. So if there are dependencies between the modules you would still have to choose the build order yourself.

NetBeans RSS Feed Filter: JAX-RS Tip of the Day: Basic Authentication with JDBC

2012-07-26T04:42:36+00:00

Abstract

Unless you have a public API like a weather service, or perhaps barometric pressure measurements. You will likely need some form of authentication, and authorization for your service. A tried and tested mechanism is to use JDBC Realm based authentication. In this example I will create a set of database tables on Apache Derby, set up the security realm on GlassFish 3.1.2.2, and configure basic authentication on a RESTful web service. The majority of the work will be done using the NetBeans IDE 7.2.

Requirements

NetBeans 7.2
secure-jdbc-rest-project Maven project

Database

The first thing we need to do is to set up our database tables which we will use for authentication. These tables can contain more information, but in my example I will keep them simple.

Creating Tables

First we will need to create a Users table which will contain our username and password. Using the sample database in NetBeans do the following:

Select the Services Window, and open the Databases selection
Right click on the Java DB icon, and start the server if it is not already started
Right click on the sample database connection: jdbc:derby://localhost:1527/sample [app on APP] and connect.
Right click on the sample connection and select Execute Command.
Execute the create table commands and create index commands below.

CREATE TABLE users ( username varchar(255) NOT NULL, password varchar(255) DEFAULT NULL, PRIMARY KEY (username) );

CREATE TABLE groups ( username varchar(255) DEFAULT NULL, groupname varchar(255) DEFAULT NULL);

CREATE INDEX groups_users_idx ON groups(username ASC);

Create Tables

Add Users and Groups

We need to add at least one user and group to our table. Since I am using GlassFish as the container, I will use SHA-256 to hash my password. That way it is not visible in plain text.

Right click on our new USERS table, and select View Data
Click on the Insert Records Icon
Add a user, and add a SHA-256 hash of the password.
Note:An online generator can be found at SHA-256 hash calculator
Repeat the same process as above to open the GROUPS table
Add the username and a group called users

That completes all we need for our JDBC authentication.

GlassFish JDBC Realm

Using the NetBeans IDE perform the following:

Go to the Services window and expand the Servers selection.
Right click on GlassFish 3.1.2 server and select Start.
Right click and select View Domain Admin Console.
On the Admin console web page on the tree on the left select Configurations » server-config » Security » Realms.
Add a new realm called jdbc with the following properties:
- Name: jdbc
- Class Name: com.sun.enterprise.security.auth.realm.jdbc.JDBCRealm
- JAASContext: jdbcRealm
- JNDI: jdbc/sample
- User Table: users
- User Name Column: username
- Password Column: password
- Group Table: groups
- Group Table User Name Column: username
- Group Name Column: groupname
- Database User: app
- Database Password: app
- Digest Algorithm: SHA-256
- Encoding: Hex
- Charset: UTF-8
Note: the parameters are case sensitive.
Navigate to Configurations » server-config » Security
Change the Default Realm to jdbc
Check the Default Principal To Role Mapping checkbox to enabled
Click Save and Restart server.

The security mapping configuration for automatic mapping makes it so that our application will not require a glassfish-web.xml file as part of our deployment.

JAX-RS Application

Finally we have completed all of the requirements on the server side for securing our applications. This security mechanism can be used by more than the application we will are preparing to deploy. We need to set up the security constraints in our web.xml file as shown below. If you have downloaded the code you can simply open it in NetBeans and examine it.

web.xml

Using NetBeans, you can simply run the application and it will prompt you for an application server. Select the current GlassFish server we have set-up, and it will deploy in a few seconds. You will come to a index.jsp page.

Click on the link for the application.wadl, or navigate to http://localhost:8080/secure-jdbc-rest-service/resources/example and you will be prompted to login. Once you login, you should get this message from the REST service.

This is an example message

Geertjan's Blog: Simplified Usage of the NetBeans Platform

2012-07-25T18:11:35+00:00

The latest NetBeans Platform application showcased at NetBeans Zone, Zirius, the Norwegian ERP System, is illustrative of how the bare minimum of the NetBeans Platform can be used, to the point where the NetBeans Platform doesn't show through at all:

On the one hand, this means that you're not leveraging the width and breadth of all that the NetBeans Platform provides. On the other hand, it takes time to migrate an application to the NetBeans Platform and the above is a logical first stage. Though you have modularity, an update mechanism, and a loosely coupled mechanism for communication across modules via the Lookup API, you keep everything else exactly as it was before: same UI, including same toolbar and menu bar.

That's possible because you can remove everything from the NetBeans Platform and start with a clean slate, in so far as the user interface is concerned:

Above, there's a single NetBeans TopComponent, with its tabs removed. The toolbar is removed and the menu bar is removed, with some dummy menu items added via a custom menu bar. Now you can treat the TopComponent like a JPanel and simply add all your UI components within it.

The application above looks like this:

And the sources can be downloaded here:

http://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.2/misc/NBContainer

The code in the repo above was written following the instructions described in the Zirius article. Using those sources, you can very easily create strictly defined user interfaces, i.e., without the flexible NetBeans window system, with a tree view on the left and a GUI pane on the right, like this, for example, i.e., an image viewer:

Similar applications on the NetBeans Platform, i.e., leveraging low level infrastructure, while all the rest are custom UI components within a single TopComponent, can be read about in these two articles:

What's also cool about the Zirius story is that Toni and I visited that company two years ago and, clearly, the NetBeans Platform message did not fall on deaf ears!

NetBeans Ruminations » NetBeans: Tutorials Revamped for NetBeans Platform 7.2

2012-07-25T07:01:07+00:00

Besides implementing and testing the IDE itself, there are various other tasks involved in a new release of the NetBeans IDE. One important aspect is ensuring that the tutorials on the NetBeans website are up to date. And this release is no exception: there are a number of interesting NetBeans Platform Learning Trail tutorials that have been updated by Geertjan, and I would like to highlight some of them that I think are particularly useful.

NetBeans IDE 7.2 Plugin Quick Start – a tutorial that illustrates some of the basic concepts around module development on the NetBeans platform, by guiding the reader to implement a Google search bar in the IDE.
NetBeans Project Type Module Tutorial – a tutorial describing all the aspects of integrating your own kind of project into the IDE. This is an aspect of the platform that has IMO improved drastically over the last few years. This tutorial is most definetely worth a read!
NetBeans Platform Runtime Container Tutorial – a tutorial describing the minimum set of modules that makes up a NetBeans Platform application.

NetBeans for PHP: NetBeans 7.2 is out!

2012-07-24T14:57:21+00:00

NetBeans 7.2 was today published. You can download it here. You could read about the PHP features added to the NetBeans 7.2 release here on the blog, but the main features added or improved are:

Support for PHP 5.4
PHP editing: Fix Uses action, annotations support, editing of Neon and Apache Config files and more
Support for Symfony2, Doctrine2 and ApiGen frameworks
FTP remote synchronization
Support for running PHP projects on Hudson

For more information, just look at New and Noteworthy page for NetBeans 7.2.

And as obvious you can help us to test the build. Just try it and if you find an issue / error, please report it. Thanks for your help.

Geertjan's Blog: Top 10 New Features in NetBeans IDE 7.2

2012-07-24T14:40:01+00:00

Start spreading the news! NetBeans IDE 7.2 is out with, as always, its clean and neat user interface:

Here's the top 10 features you'll find in this release:

Static code analysis support, in particular, FindBugs integration.
Smoother startup and faster project scanning.
New, better, and faster tools throughout the Java Editor.
Enhancements for Java EE developers, such as JPA code completion and PrimeFaces 3.2.
Better JavaFX tools, in particular, JavaFX Scene Builder integration.
Even more NetBeans love for Maven.
Tools and templates for TestNG.
New PHP frameworks integrated, together with more editor tools.
Groovy & Grails faster and more tools.
NetBeans C++ powered up and yet more support than before.

Go get it while the buzz is buzzing!

APIDesign - Blogs: Dependencies Between Jigsaw Modules Made Easy!

2012-07-24T13:56:00+00:00

Those who observe my blog may remember that I have an obsession. I am trying to understand module versioning and dependencies between modules. Recently I was playing with JigsawServices:

module M1 { requires service S;
    }

The above concept is essentially NP-Complete as one may have choices from multiple modules providing implementation of the service and selecting the right one is NP-hard as explained in this example.

But I think I have found an acceptable solution. Today I will have a presentation about it (here are the slides). Wish me luck!

--JaroslavTulach 13:56, 24 July 2012 (UTC)

NetBeans Ruminations » NetBeans: NetBeans 7.2: Hot Off The Press!

2012-07-24T12:18:54+00:00

NetBeans 7.2 has just been released and can now be downloaded from the official download page! For more information about the new and noteworthy features in this release, have a look at this wiki page.

Edit: Also read Geertjan’s blog post about the Top 10 New Features in NetBeans IDE 7.2.

Geertjan's Blog: BackupGoo: For When Clouds Start Leaking

2012-07-23T20:13:34+00:00

Here's a great little backup tool, named BackupGoo, for your Google-related artifacts, i.e., mail, docs, contacts, and calendar:

I had everything set up in seconds, on my Ubuntu machine, as well as on my Windows machine. Great application. Gets you ready for those days when the clouds are leaky:

And here's the structure of the application, familiar to anyone using or creating applications on the NetBeans Platform:

Would be cool if the NetBeans Platform's Favorites window would be included in BackupGoo, which would let you browse into the folder of backed up files and then you'd be able to read those files within BackupGoo using the NetBeans Platform's text editor.

Geertjan's Blog: org.netbeans.spi.project.ui.ProjectOpenedHook

2012-07-22T10:20:31+00:00

If you want something to happen when a project conforming to your project type opens or closes, put an instance of org.netbeans.spi.project.ui.ProjectOpenedHook into your project type's lookup. The methods "projectOpened" and "projectClosed" are called when a project of your type opens or closes in your application's GUI.

However, let's make it more interesting! Let's say you want to integrate a tool into NetBeans IDE, for example, that will process ANY project as soon as it is opened. For that purpose, you're able to add objects into the lookup of project types over which you have no control.

Here's an example. Whenever any NetBeans project opens, a balloon message is created, i.e., shown in the bottom right of the IDE, with the possibility to search Google for information relating to the project.

The code, but note that below the ProjectOpenedHook is added to the lookup of four NetBeans projects, though it could be added to many others too, for each the annotation needs to include the related project ID:

import java.awt.event.ActionEvent; import
    java.awt.event.ActionListener; import java.net.URL; import java.net.URLEncoder; import org.netbeans.api.project.Project; import org.netbeans.spi.project.LookupProvider; import org.netbeans.spi.project.ui.ProjectOpenedHook; import org.openide.awt.HtmlBrowser.URLDisplayer; import org.openide.awt.NotificationDisplayer; import org.openide.util.ImageUtilities; import org.openide.util.Lookup; import org.openide.util.lookup.Lookups; @LookupProvider.Registration(projectType = {
    "org-netbeans-modules-web-project", "org-netbeans-modules-java-j2seproject", "org-netbeans-modules-apisupport-project", "org-netbeans-modules-apisupport-project-suite" }) public class DefaultProjectOpenedHook implements LookupProvider { @Override public Lookup createAdditionalLookup(final Lookup lookup) { Project p = lookup.lookup(Project.class); final String name = p.getProjectDirectory().getName(); return Lookups.fixed(new ProjectOpenedHook() { @Override protected void projectOpened() {
    NotificationDisplayer.getDefault().notify( //display name: "Opened " + name, //icon: ImageUtilities.loadImageIcon("org/netbeans.png", false), //description: "Search Google for " + name + "!", //action listener: new ActionListener() { @Override public void actionPerformed(ActionEvent e) { try { String searchText = URLEncoder.encode(name, "UTF-8"); URLDisplayer.getDefault().showURL( new URL("http://www.google.com/search?hl=en&q=" + searchText + "&btnG=Google+Search")); } catch (Exception
    eee) { return;//nothing much to do } } }); } @Override protected void projectClosed() { } }); } }

Geertjan's Blog: Wrapper Project for NetBeans Projects

2012-07-21T21:29:58+00:00

A great question in this blog by swpalmer recently:

I have a need for a custom project type that is mostly just a parent for existing NB project types for Java(Ant or Maven, soon Gradle) and C++. Think of it like a one project for a Java library that uses JNI and the project for the native library that implements the native methods that go with it. Add a little bit of metadata and some custom packaging steps (currently written with Gradle) and that would be my new project type.
Would making a new parent project type that has subprojects of existing NB project types be an easy thing to implement?

Well, here's a simple example. Imagine you have folders for your customers, each containing multiple NetBeans projects. Would be cool to be able to open all those projects together, as part of a new project defined by some recognized structure in the customer folder:

Then, once open, you can do typical things you'd like to be able to do to multiple projects belonging to a shared container of some kind, such as open the individual projects for separate editing:

Notice that, though the icon is retained from the original NetBeans project, the logical view isn't. I don't think there's a way around that.

The way this works is that the "createLogicalView" override of the Project implementation returns a Node that defines its children as FilterNode.Children, with the icons overridden. That defines the logical view. The ability to open the NetBeans project together with the main project is done via a SubprojectProvider in the Lookup of the main project, which recognizes subfolders containing an "nbproject" folder as a subproject of the main project.

Best of all, I can now create Actions which lookup all the subprojects and then do something with the group of subprojects. Maybe, for example, all the subprojects can be built together or run together or something like that. A higher level container like this can open up a lot of possibilities and isn't hard to create, if you combine the instructions in the above paragraph with the instructions in this tutorial:

http://platform.netbeans.org/tutorials/nbm-projecttype.html

Finally, if the customer project in the screenshots above were to be a Gradle project, then I think the question with which this blog entry started would be resolved.

praxis » NetBeans: NPE Hunting (Win7, Java7, custom LAF)

2012-07-21T17:05:30+00:00

I recently had to track down the cause of a NullPointerException when opening a JFileChooser dialog in Praxis on Windows with Java 7. Turns out there’s a nasty little bug that affects NetBeans platform apps and the NetBeans IDE when … Continue reading →

Geertjan's Blog: New Tutorial: Integrating JavaFX Charts into the NetBeans RCP (Part 2)

2012-07-20T16:58:18+00:00

Recently the NetBeans Platform JavaFX Integration Tutorial was released. There were still some open issues, though, as described here in Part 1 of this series. Gail and Paul Anderson, from Anderson Software Group, picked up the gauntlet and fixed these problems, as well as introducing additional JavaFX charts to the application:

I'll be updating the tutorial soon with the new code and fixes provided by Gail and Paul! All the code is already available here:

http://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.2/misc/StockTraderClient

They'll also be delivering a tutorial on JavaFX and the NetBeans Platform at JavaOne 2012 in October this year:

"TUT4801 - Make Your Clients Richer: JavaFX and the NetBeans Platform"
The NetBeans platform is known for its comprehensive window framework and loosely coupled architecture. JavaFX offers a rich set of visually appealing GUI components. This tutorial shows you how to use both to enhance the user experience in desktop client applications. In the tutorial, you will learn how to integrate JavaFX into a NetBeans application. You will start with a basic application that generates data. You will then create a NetBeans module that includes a dynamic JavaFX chart component. This chart component leverages JavaFX bindings to visually animate data as the values change. The result includes an application with a sophisticated out-of-the-box GUI coupled with flashy, JavaFX-powered animations.

That's a two hour topic, i.e., a tutorial, they will do on this subject. Looking forward to it!

Bistro! 2.0: API Google Maps: gratuit ou pas?

2012-07-20T14:59:38+00:00

Pour certains ce sera un rappel ou une clarification, pour d’autres peut-être une information nouvelle.

L’API Google Maps est une des toutes premières API proposée par Google et probablement aussi une des plus populaire auprès des développeurs.

Cartes stylisées ou pas, l’usage gratuit de l’API est limité à 25 000 chargements de cartes par jour. Au delà il en coutera $0.50 pour 1000 chargements supplémentaires (après avoir initiallement été de $4). Les détails sont disponibles sur cette page. Il est important de comprendre qu’un chargement de carte (map load) est en réalité une instanciation de l’API Maps et non pas l’affichage de chaque tuile (tile). De telles limites existent également pour le geocoding, l’API Image Street View, etc.

Google estime à moins de 0,5% le nombre de sites concernés par cette règle des 25 000 chargements quotidiens. Dans les faits, les sites qui dépasseront cette limite tous les jours pendant plus de 90 jours consécutifs seront contactés par Google. Pas d’arrêt de service à prévoir en cas de popularité soudaine d’un site ou d’un service. Le meilleur moyen de mesurer sa consommation est de se connecter sur la Console Google API.

Tout ceci est applicable lorsque le site ou service qui utilise l’API Google Maps est librement accessible à tous. Les détails sont disponibles ici. Dans le cas contraire (éditeur de logiciel embarquant l’API par exemple), Google propose Maps API for Business.

Si vous avez besoin d’un “rafraichissement” sur l’API Google Maps, je vous invite à regarder cette présentation récente en français. Au rang des anecdotes, vous y apprendrez par exemple que Google Maps utilise une variante de la projection Mercator ou que ses tuiles sont des images 256×256 pixels. Si vous ne l’avez pas encore fait, la migration vers l’API v3 est fortement encouragée.

Comme pour toutes ses technologies, Google vous invite à poser vos question techniques sur StackOverflow et à suivre sa page Google+.

Enfin coté actualité produit, il y a désormais la possibilité de télécharger des cartes entières pour une utilisation hors-ligne, l’arrivée dans certaines villes du projet helicopter (vues à 45 degrés) et de nouvelles offres SaaS pour l’entreprise : Google Maps Engine, ou Google Maps Coordinate.

Filed under: Uncategorized

Bistro! 2.0: Thoughts on the Jigsaw debacle

2012-07-20T09:36:57+00:00

Disclaimer: this is a personal piece of opinion and in absolutely no way does it necessarily reflect the views of my current employer. I have spent 13 years at Sun/Oracle (5 of which in the GlassFish team which had a modularity experience of its own) and I still care very much about the future of Java. I now work at Google.

Runtime modularity in Java has been promised since JSR 277 was filed in 2005 and I wrote how excited I was about its potential back then. Seven (7!) years, a fair amount of OSGi lobbying and politics, Sun’s acquisition, and a plan B promise later, we’ve come to this day to learn that it’ll be pushed further out to 2015 which really means 2016 for a stable release and probably 2020 for a wide adoption. After being promised Java 8 with Jigsaw in late 2012 by Oracle, we’re now taking another 3-year hit because the project missed “the train”.

About resources and goals
Jigsaw has been Mark Reinhold’s baby project for all this time (Mark is the Chief Architect of Java) and I’m now hearing excuses about staffing issues. “Oracle failed to staff Java modularity effort for years”. Hey, now that’s a much better headline! The reality I believe is that Oracle still doesn’t know why it’s doing Jigsaw and thus giving it the proper priority is hard. Modularize the JRE itself to help with JavaME and JavaFX adoption? Offer a modules system for Java’s longer-term viability? A business case can certainly be put together to shrink down the JRE to get Oracle upper management on board. On the other hand, bringing the JVM, the compiler, and the language together around a modules system seems, sadly, to be falling off of Oracle’s radar.

About that train
The common wisdom is that the Eclipse way of shipping software is the best way to get a community of developers building on a platform. You’ve probably also heard of “release early release often”. Eclipse is a very special project which is really about providing a baseline for the Foundation members to build upon and I’d argue that Eclipse IDE users on the other side are not benefiting much from this release model. When it comes to Java, we’re talking about something that also has a diverse audience and I think developers remain far more important than vendors and that a cadenced release model is actually harmful. It’s easy to agree on shipping software when it’s fully baked but the two-year cycle is really the key issue here. Oracle should be able to declare Jigsaw a strategic goal and deliver it with an extra 6 to 12 months (which, by the way, would still mean 2+ years from now!).

About the community
Jigsaw has been presented for many many years by Sun and later Oracle as a key feature in numerous keynotes and conferences and promised in Java 7, Java 8 (in fact I’ve done my share of such promotion while at Oracle) and now Java 9. That has created a lot of expectations in the community. In fact, it’s not only about Java SE as a large portion of the Java ecosystem is also waiting for a standard modularity solution: JavaME, Java EE (see this sample IBM reaction when modularity had to be removed from EE 7), Groovy and other JVM languages and probably by many developers building non-trivial applications with Java. Surely there’s got to be a better way to convey bad news to the community than “sorry, we’ve missed the train!”. In retrospect, the plan A/plan B approach was a brilliant communication plan with Plan A really not being an option and the community rallying behind Plan B. It’s often about how things are conveyed, not only about what they convey.

About open source
I hear some say that this would not have happened if Java was truly open source with a community, not a company, overlooking its destiny. First, my definition of Open Source remains. IP and governance are (ideally) orthogonal to the license and no simple solution exists for all software projects. But more importantly, this is a sad case of a project’s failed risk mitigation (sadly a very common failure in our industry). To consider that a different governance model would have changed anything is wishful thinking. Innovative carefully crafted designs always come from a very small number of talented engineers and in fact, this may even be a case where going open source and transparent was not a good idea but rather a fatal distraction.

About what’s next
As I wrote above, Oracle has the resources to declare Jigsaw a strategic goal. I can agree that it may be hard to deliver by late 2013 but waiting for 2016 is effectively killing Jigsaw and encouraging everyone to look at alternatives which will jeopardize yet even more Jigsaw’s chances of ever seeing the light of day. In fact, even Oracle is considering profiles in Java 8, an ugly band-aid if you ask me. One you’ll need to painfully tear off to get proper modularity in the platform. Jigsaw really shouldn’t be seen as “a new feature”, to me it’s really the Java reboot some people have been calling for a long time. Only a compatible one.

Now of course this is all my personal take and I don’t pretend to know what’s good for Java nor represent the community at large. So getting some hard data about what the community expects from Jigsaw would be a good start before making any decision. I believe this has not been done so far. The closest I’ve seen is the recent JAXenter poll which isn’t very scientific (self-selected, somewhat biased questions).

So in the end, if the community wants Java 8 with its updated and stripped-down content (Lambda, maybe JSR 310, what else?) in 2013, Oracle and the JCP should deliver just that. Again, it’s about meeting expectations. But shipping a Java 8.5 with Jigsaw sooner than later should also be considered. And if there really needs to be a train release model, it has to be a yearly one and not every release needs to be a major one.

In a world where standing still is perceived as fossilization, bringing proper modularity to Java is what moving Java forward ™ is really about.

Filed under: Uncategorized Tagged: java, jcp, jigsaw, oracle, osgi

Geertjan's Blog: NetBeans Support for Gradle Multi-project Builds

2012-07-19T15:53:41+00:00

The start of multi-project build support (described here) for the NetBeans Gradle plugin. For the projects that are part of the multi-project build, a separate project type is defined, which is registered in the lookup of the main Gradle project. Now each of the projects can be opened and worked on independently of the main project, in the same way as with suites/modules in NetBeans Platform development or the EJB modules in a NetBeans Java EE application project, for example.

Above, you see the Netflix Curator on GitHub, which Tim Boudreau suggested might be a good largish real world application for trying out the NetBeans plugin for Gradle.

As a consequence, I learned a lot about sub project type support in the NetBeans Platform. (Well, actually this is part of the APIs exposed by NetBeans IDE and not the NetBeans Platform.) Read about it here, which is where I documented it in the NetBeans Platform 7.2 Project Type tutorial:

http://platform.netbeans.org/tutorials/nbm-projecttype.html

Geertjan's Blog: Extending the Lookup of a Java SE Project

2012-07-18T19:45:01+00:00

Here I have the start of some kind of visualizer for Java SE projects in NetBeans IDE. A project is passed in and then the visualizer does something with it:

public class MyJavaSEVisualizer { public MyJavaSEVisualizer(Project p) { // do something with the project to visualize it } }

Next, I have some action. In this case, the action is invoked from the File menu. The action is only enabled if a project is in the lookup. The action then retrieves the visualizer from the lookup of the project:

@ActionID(category = "File", id = "org.jse.lookup.SomeAction") @ActionRegistration(displayName = "#CTL_SomeAction") @ActionReference(path = "Menu/File", position = 0) @Messages("CTL_SomeAction=Some") public final class SomeAction implements ActionListener { private final Project context; public
    SomeAction(Project p) { this.context = p; } @Override public void actionPerformed(ActionEvent e) { MyJavaSEVisualizer mjsev = context.getLookup().lookup(MyJavaSEVisualizer.class); if(mjsev != null){ JOptionPane.showMessageDialog(null, "this is a Java SE project"); // now call a method on mjsev... } else { JOptionPane.showMessageDialog(null, "this is NOT a Java SE project"); // now don't call a method on mjsev... } } }

But how does the visualizer end up in the lookup of the project? Like this, i.e., without changing the source of Java SE projects, but by extending the lookup of Java SE projects, i.e., the lookup of projects can be defined to be pluggable and, in the case of NetBeans IDE projects, projects have been defined in that way:

@LookupProvider.Registration(projectType = "org-netbeans-modules-java-j2seproject") public class MyJavaSEVisualizerLookupProvider implements LookupProvider { @Override public Lookup
    createAdditionalLookup(Lookup lookup) { return Lookups.fixed(new MyJavaSEVisualizer(lookup.lookup(Project.class))); } }

Bistro! 2.0: Google Developer Expert (GDE) en France

2012-07-17T15:10:47+00:00

Parmi les annonces que vous n’avez peut-être pas vu passer lors de Google I/O 2012, il y a le programme Google Developer Experts.

Avec ce nouveau programme, Google propose à des individus d’obtenir un titre d’expert à l’année pour l’un des domaines de prédilection de Google (Android, Cloud, HTML5, Chrome, Social, Geo, etc…).

Il ne s’agit bien entendu pas d’un rôle de porte-parole mais plus d’une reconnaissance apportée à une personne à la fois technique, experte et visible (présentations publiques, blog, commits, etc…). Ce titre lui permettra d’entretenir une relation avec Google (contact avec les developer advocates, access aux previews et plus encore) et de présenter lors de conférences développeurs.

Initiallement piloté en Israel et au Japon, le programme est désormais publique et actif en France comme l’indique la page des Experts actifs. Sa gestion est effectuée localement par Google France.

Maj: voici un billet sur GDE rédigé par le responsable du program au niveau mondial.

Filed under: Uncategorized Tagged: expert, gde, google

Geertjan's Blog: Gradle Classpath Support in NetBeans

2012-07-17T09:40:22+00:00

This may be my greatest achievement as a NetBeans Platform programmer, ever. Since my girlfriend is not a programmer, she's not going to be able to join with me in celebrating this happy news. (Well, she can celebrate, but without full appreciation.)

So I turn to the on-line community of developers everywhere: I've created a Gradle project type for NetBeans IDE, with classpath support. That means that not only the JDK, but also the dependencies declared in the Gradle build file are on the classpath of the project:

The JARs in the Libraries node above are defined in the Gradle build file, refer to the screenshot in yesterday's blog entry for details. Those JARs are put on the classpath, thanks to the NetBeans plugin, and can then be coded against, as you can see above.

Still a lot needs to be done before this is usable. Changes in the Gradle build file need to be reflected in the hierarchies in the explorer view; the user should be able to map Gradle tasks to project commands; the user should be able to change the JDK; and many other similar project-level features need to be implemented, while it would also be cool to have the Package View support integrated into this project type.

But, for now, this is a great step forward. It would be great to have a few people out there who'd like to try out this early (and also later) version of the plugin, but bear in mind that only very few features work. Well, you can run all your tasks and the classpath works, so that's all the basic stuff ready to be used by anyone using Gradle.

A small cool thing I like is the fact that the project node hierarchy is pluggable. So, you could create an external module and provide a new node in the project view above, but more about that another time.

Many thanks to the Grails project (which owes some gratitude to the Ruby project, among others), which is where almost all of the Gradle classpath code comes from.

Geertjan's Blog: More Serious Attempt at a NetBeans Gradle Plugin

2012-07-16T19:01:38+00:00

After a few small skirmishes in this area, here's a more serious attack:

What you see above is that a Gradle build file can be expanded, exposing its tasks, which can be double-clicked to be invoked. Also, the JAR dependencies of the project are visualized and can be browsed just like any other JAR file in NetBeans. When a change is made in the file, the task hierarchy and the dependency hierarchy are automatically rebuilt.

Any folder that has a file named 'build.gradle', on the highest level within the folder, is recognized as a Gradle project and can be opened:

All of the features above are then automatically available. There's also a file template for creating a new Gradle build file from scratch, for an existing project that doesn't yet have Gradle support.

The final step, at least for this version of the plugin that provides basic Gradle support, is to work with the class path. I'll need to look at how this is done for the Grails project type, as well as, maybe the Maven project type. Not only the Java classes in 'src' should be on the classpath, but also the Java classes in the JARs retrieved via the declared dependencies.

The sources are here, anyone is free to do whatever they want with them:

http://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.2/misc/GradleProjectType