Wednesday Mar 31, 2010

Happy Birthday to Me

The blog you are now reading began on 1 April 2005. And here's the slightly inauspicious first blog entry, together with the obligatory "Who Am I" thingy, which I've changed several times since then:

https://blogs.oracle.com/geertjan/date/20050401

And this is today's blog entry, i.e., this one you are now reading:

https://blogs.oracle.com/geertjan/date/20100401

I've learnt an unlikely amount of things via blogging. I've learnt, more than anything, that an organization that encourages blogging is a creative place to work. And, implicit in that, to me, is the notion that a blogger should be allowed to blog about anything they want, otherwise what's the point? Blogging is about expressing your feelings about something, where feelings are neither positive nor negative. "Congratulate when appropriate, complain when necessary," has been my unstated guideline. And being constrained to only blog on business-related topics is just so wrong, since a central point of business blogs is to show the people that make up the business.

Anyway, here's looking forward to lots of blog entries about vacations, pets, and funny things that happened on the way to work! And the things learned there, of course, that are all the more interesting for being shared between the random oddities that make up a life.

Tuesday Mar 30, 2010

Musculoskeletal System Modeling on the NetBeans Platform

Yet another NetBeans Platform application (discovered by Tom Wheeler) is OpenSim, which is described as follows in its 300+ page user guide:

OpenSim is a freely available software package that enables you to build, exchange, and analyze computer models of the musculoskeletal system and dynamic simulations of movement. OpenSim version 1.0 was introduced at the American Society of Biomechanics Conference in 2007, and with version 2.0, an application programming interface (API) has been added, allowing researchers to access and customize OpenSim core functionality. Since the initial release, thousands of people have begun to use the software in a wide variety of applications, including biomechanics research, medical device design, orthopedics and rehabilitation science, neuroscience research, ergonomic analysis and design, sports science, computer animation, robotics research, and biology and education.

The software provides a platform on which the biomechanics community can build a library of simulations that can be exchanged, tested, analyzed, and improved through multi-institutional collaboration. The core software is written in C++, and the graphical user interface (GUI) is written in Java. OpenSim plug-in technology makes it possible to develop customized controllers, analyses, contact models, and muscle models among other things. These plugins can be shared without the need to alter or compile source code.

Sounds like just about the most lifeaffirming NetBeans Platform application I have yet heard of. Here's a screenshot I found in aforementioned user guide, clearly showing we're dealing with a NetBeans Platform application here:

Here's a description of the above GUI:

OpenSim provides a graphical user interface that provides access to many of the software features. For example, you can import motion analysis data, scale a computer model of the musculoskeletal system, perform inverse dynamics analysis, and plot results all from the graphical interface. Models of many different musculo-skeletal structures, including the lower extremity, upper extremity, and neck, can be loaded, viewed and analyzed. Muscles are shown as red lines; virtual markers are shown as blue spheres.

This is also yet another application where there are few/none official mentions on the site of the NetBeans Platform being used as the basis of the application. It makes sense in a way; when you talk about your car, do you mention the supplier of its tyres?

Monday Mar 29, 2010

Raytheon on the NetBeans Platform

Yesterday, I came across yet another NetBeans Platform application in the defense sector. Raytheon's Virtual Control "is a flexible enterprise management and control system that has been designed to support a wide range of distributed system needs. Its robust capabilities are being applied across the LVC domains to support some of the most critical development programs in the Department of Defense (DoD)".

That, all on its own, is a nice endorsement of the NetBeans Platform, since that's what clearly underpins it:

The above numbers denote: (1) Topology View, (2) Tree View of Managed Topics, (3) Property Sheet, (4) Visual Display of Alerts, (5) Throughput Test, (6) Multicast Test, (7) HLA Federates, (8) RTI NG Pro Federations. Read more about the application here (PDF).

Looking at the screenshots page of NetBeans Platform applications, Raytheon is in good company, since many others in the same sector are using the NetBeans Platform too.

Connecting the Cut Action to a Context Aware Action

Next in the JFugue Music NotePad, I am working on creating a "cut action", which means integrating with the NetBeans Platform cut action. As you can see below, when (and only when) one or more notes are selected, the cut action (look in the toolbar) becomes enabled:

How to do this yourself? Inside the TopComponent, I have these two lines of code, which links the "cut-to-clipboard" action to an action registered in the layer:

final ActionMap actionMap = getActionMap();
actionMap.put("cut-to-clipboard", Utilities.actionsForPath("Actions/Bla/").get(0));

Then, in the layer, the first action registered in "Actions/Bla" is as follows:

<folder name="Actions">
    <folder name="Bla">
        <file name="org-netbeans-modules-musician-actions-NoteCutAction.instance">
            <attr name="delegate" methodvalue="org.openide.awt.Actions.inject"/>
            <attr name="displayName" bundlevalue="org.netbeans.modules.musician.actions.Bundle#CTL_NoteCutAction"/>
            <attr name="injectable" stringvalue="org.netbeans.modules.musician.actions.NoteCutAction"/>
            <attr name="instanceCreate" methodvalue="org.openide.awt.Actions.context"/>
            <attr name="noIconInMenu" boolvalue="false"/>
            <attr name="iconBase" stringvalue="org/netbeans/modules/musician/resources/Play16.gif"/>
            <attr name="selectionType" stringvalue="ANY"/>
            <attr name="type" stringvalue="org.netbeans.modules.musician.common.Note"/>
        </file>
    </folder>
</folder>

Take note of the fact that the "type" element enables all (thanks to "ANY") available Note objects to be injected into the action registered for the "injectable" element.

That's all. Now the "injectable" action can receive a List of Note objects and can do with them what they want. Which Note objects are injected? Those that are available via the Lookup. Personally, I'm using Wade Chandler's central lookup, which is an amazing thing, meaning that I am not tied to any windows or even to the current selection.

Sunday Mar 28, 2010

Melody and Harmony in JFugue Music NotePad

Thanks to the injection of the domain object into actions (an approach discussed in this blog yesterday), it is now possible to play multiple scores simultaneously in the JFugue Music NotePad (see the menu items 'Melody' and 'Harmony' on the root node in the brand new viewer component below):

Pretty cool. Now, either all the sheets are played consecutively (melody) or simultaneously (harmony). (Plus, as before, they can be played individually too.) And all thanks to the injection of the Score object, which I separated out into a separate module that now contains all the business objects in the application.

Thanks Troy for laughing at my melody-only approach, which inspired me to work on the harmony support, which is pretty easy thanks to JFugue API!

Saturday Mar 27, 2010

Extending the NetBeans IDE Debugger

The real message of the article "How to Make the NetBeans Platform Sensitive to Customers", which I recently wrote on NetBeans Zone, is that actions in applications on the NetBeans Platform can be sensitive to their business objects (also known as model objects). In the case of that article, the business object was "Customer", while in NetBeans IDE the business objects are "FileObject", "DataObject", "Node", among others.

One of these is org.netbeans.api.debugger.jpda.ObjectVariable, which enables you to create actions that are sensitive to object variables in the NetBeans IDE Debugger:

<folder name="Actions">
    <folder name="Build">
        <file name="org-demo-detector-java-ShowSelectedObjectVariables.instance">
            <attr name="delegate" methodvalue="org.openide.awt.Actions.inject"/>
            <attr name="displayName" bundlevalue="org.demo.detector.java.Bundle#CTL_ShowSelectedObjectVariables"/>
            <attr name="injectable" stringvalue="org.demo.detector.java.ShowSelectedObjectVariables"/>
            <attr name="instanceCreate" methodvalue="org.openide.awt.Actions.context"/>
            <attr name="noIconInMenu" boolvalue="false"/>
            <attr name="iconBase" stringvalue="org/demo/detector/java/customer.png"/>
            <attr name="selectionType" stringvalue="ANY"/>
            <attr name="type" stringvalue="org.netbeans.api.debugger.jpda.ObjectVariable"/>
        </file>
    </folder>
</folder>

From the bold lines above, especially, you can see that all the selected "org.netbeans.api.debugger.jpda.ObjectVariable" instances will be injected into my action class, which I defined as follows:

import java.awt.Dialog;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import org.netbeans.api.debugger.jpda.ObjectVariable;
import org.openide.DialogDescriptor;
import org.openide.DialogDisplayer;

public final class ShowSelectedObjectVariables implements ActionListener {

    private final List<ObjectVariable> context;

    public ShowSelectedObjectVariables(List<ObjectVariable> context) {
        this.context = context;
    }

    public void actionPerformed(ActionEvent e) {
        DialogDescriptor dd = new DialogDescriptor(new UIPanel(context), "Selected Variables");
        Dialog dlg = DialogDisplayer.getDefault().createDialog(dd);
        dlg.setVisible(true);
    }
    
}

The "UIPanel" that you see above receives the selected ObjectVariables, where they are placed into a text area, as shown below, thanks to this constructor in the panel:

UIPanel(List<ObjectVariable> context) {
    initComponents();
    for (ObjectVariable objectVariable : context) {
        jTextArea1.append(objectVariable.getType() + 
                ": " + objectVariable.getValue()+"\\n");
    }
}

To get the above to work, start the debugger in the IDE where you install the module. Then, when you select a row in the Variables window, the action will become enabled (the grumpy face button in the toolbar below) and when you invoke the action your new dialog will appear, showing the currently selected variables:

So, now you've made your first steps in extending the NetBeans IDE Debugger, more about which can be read here.

Friday Mar 26, 2010

Your Thesis on the NetBeans Platform?

Have you written a university/college thesis that discusses the NetBeans Platform in some way? To assist others doing the same thing, we're collecting as many as we can get hold of and posting them here:

http://edu.netbeans.org/thesis.html

Drop me a line / leave a comment at the end of this blog entry if you'd like yours to be included there too!

The latest one is by Jan Poživil, who wrote a Masters thesis on top of the NetBeans Platform in May 2009, at the Faculty of Electrical Engineering at the Czech Technical University in Prague. The thesis was entitled "Integrated Visualization Environment for Interactive Analysis of User Activity Logs" (download it here).

Abstract: "This thesis presents a design and implementation of an integrated visualization environment for interactive visual analysis of user activity logs. Data are organised into projects and the application provides data persistence across application sessions. Data visualization is performed by third-party plugin modules. Plugin modules are also used for conversion of data into the internal format of the application. Plugin module authors will use the public API/SPI, which was created for the purposes of extending application functionality. The application is implemented in Java and based on the NetBeans Platform."

And here's a screenshot:

Congratulations with this very interesting thesis on the NetBeans Platform!

Wednesday Mar 24, 2010

Open-Source Math Suite on the NetBeans Platform

The java.net featured project is https://uamath.dev.java.net/, which is a Set of Calculators for the New Force Material Equivalency and Compression Decompression Model of the Universe. Don't know what that means exactly, but when I run the app (which is a NetBeans project), I see a central control frame, from which the calculators can be opened:

Here's how the same application looks on the NetBeans Platform, which means that you can see many calculators simultaneously, without needing to click a button to open them:

And I think the application looks much more professional than the original.

One or two clicks later (i.e., I simply added another module, which provides OfficeLAF), and I had this result:

And the application is now pluggable, which wasn't true in the original application, meaning that contributors can create new modules that can be added to this application at runtime. Each contributor could add a new calculator, provided in a new module. Or you could put each of the existing calculators into seperate modules, then distribute a base application containing two or three of them, while making the modules providing the other calculators available for money. I.e., you can set up a pricing scheme based on your modular architecture.

Plus, no coding was done to create the above application. Everything was generated from templates, after which the content from the original application was copied to the generated NetBeans TopComponents.

And the whole porting process took me about 30 minutes to complete. In fact, right before breakfast.

In other news. How sensitive can you make the actions in your NetBeans Platform application? Find out here.

Tuesday Mar 23, 2010

Plugging into Hippo CMS

It's possible to extend the Hippo CMS, via Maven-based Wicket-style applications, as can be seen here:

The Java-side of the Wicket label seen above has this interesting Wicket-oriented code:

add(new Label("label", new LoadableDetachableModel() {
    private static final long serialVersionUID = 1L;
    @Override
    protected Object load() {
        UserSession session = (UserSession) org.apache.wicket.Session.get();
        String name = session.getJcrSession().getUserID();
        DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.MEDIUM, session.getLocale());
        return df.format(new Date()) + " Hallo there "+ name + "!";
    }
}));

After creating the above two Maven-based applications, which I did on the command line via these great instructions, you modify your own CMS in the Hippo CMS console, which looks like this:

Then run your own CMS again, i.e., when you plug in new features, you're creating a CMS on top of the Hippo CMS. The "Hello World" message below (in "fuchsia", as one can read in the first screenshot above) is the result of the new plugin I created:

Next thing is to learn about how to create useful plugins I might want to add to the Hippo CMS. Good to know there are so many examples available here.

Monday Mar 22, 2010

Getting Started with Hippo Development in NetBeans IDE

As a free and open-source Wicket-based Maven-built content-management system with a very cool name, Hippo deserves praise.

Getting started developing a website on Hippo with NetBeans IDE is trivial. Start with the Maven Project archetype:

Use the Generate Project Setup page to create the project, with these values:

  • Repository: http://repository.hippocms.org/maven2
  • GroupId: org.onehippo.ecm.archetypes
  • ArtifactId: website
  • Version: 1.01.00

I.e., in the IDE, use the dialog you get when clicking Add (after clicking Next) in the above dialog:

You'll end up with this project structure in NetBeans IDE:

The structure of the above project is described on the structure of the generated Maven project page.

I used Jetty from the command line (as described here) to launch the two web applications. The "cms" application launches an application for managing the website:

Meanwhile, the "site" application is the website itself, which you can simply refresh in the browser whenever you make a change in the application shown above. Here's how the website currently looks:

Next thing I want to explore is how to create plugins for Hippo.

Friday Mar 19, 2010

Minimum Dependencies for EMF? (Part 2)

In answer to my own question, I managed to get the dependencies needed for Gunnar's sample running in Equinox down to 26 OSGi bundles (from 1000+ a few days ago!):
com.ibm.icu_4.0.1.v20090822.jar
org.eclipse.core.boot_3.1.100.v20080218.jar
org.eclipse.core.commands_3.5.0.I20090525-2000.jar
org.eclipse.core.contenttype_3.4.1.R35x_v20090826-0451.jar
org.eclipse.core.expressions_3.4.101.R35x_v20100209.jar
org.eclipse.core.filebuffers_3.5.0.v20090526-2000.jar
org.eclipse.core.filesystem_1.2.1.R35x_v20091203-1235.jar
org.eclipse.core.jobs_3.4.100.v20090429-1800.jar
org.eclipse.core.resources_3.5.2.R35x_v20091203-1235.jar
org.eclipse.core.runtime.compatibility_3.2.0.v20090413.jar
org.eclipse.core.runtime_3.5.0.v20090525.jar
org.eclipse.emf.common_2.5.0.v200906151043.jar
org.eclipse.emf.ecore.change_2.5.0.v200906151043.jar
org.eclipse.emf.ecore.edit_2.5.0.v200906151043.jar
org.eclipse.emf.ecore.xmi_2.5.0.v200906151043.jar
org.eclipse.emf.ecore_2.5.0.v200906151043.jar
org.eclipse.emf.edit_2.5.0.v200906151043.jar
org.eclipse.emf.query_1.2.100.v200903190031.jar
org.eclipse.emf.transaction_1.3.0.v200902010221.jar
org.eclipse.emf.validation_1.3.0.v200901271722.jar
org.eclipse.emf_2.5.0.v200906151043.jar
org.eclipse.equinox.app_1.2.1.R35x_v20091203.jar
org.eclipse.equinox.common_3.5.1.R35x_v20090807-1100.jar
org.eclipse.equinox.preferences_3.2.300.v20090520-1800.jar
org.eclipse.equinox.registry_3.4.100.v20090520-1800.jar
org.eclipse.equinox.util_1.0.100.v20090520-1800.jar

And maybe not all of these are needed, but at most these are needed. That implies that Gunnar's sample actually uses quite a lot of features from the Eclipse Modeling Tooling story, i.e., not only EMF, but also the Transaction framework, the Validation framework, and the Query framework. All integrated into a nice NetBeans Platform application.

By the way, Gunnar's sample is now available on java.net (thanks Sven):

https://nb-emf.dev.java.net/

My next step is to create a 'hello world' scenario that uses EMF (minus all the frameworks around it, so that should end up with a lot less dependencies than the above), which will then become the official OSGi quick start for the NetBeans Platform. Hurray.

In other news. Watch this video of the final dinner at the end of the NetBeans Platform Certified Training in Belgrade last week!

Modular JavaFX Development?

Reading this new article on NetBeans Zone, re JavaFX development on the NetBeans Platform:

...I envision a world of applications that include JavaFX + EMF + OSGi, developed in NetBeans IDE!

Thursday Mar 18, 2010

Minimum Dependencies for EMF? (Part 1)

Two of the most frequently asked questions during NetBeans Platform Certified Trainings are:
  • Can I integrate my OSGi bundles into a NetBeans Platform application?

  • Can I integrate my EMF models into a NetBeans Platform application?

Unequivocally, and for the first time, I can now reply "YES" to both these questions.

OSGi can now exist alongside the NetBeans Platform's runtime container. The key to how all this is possible is below, in Jarda's own (though slightly paraphrased, by me) words:

"I decided to write a bridge. The basic idea is to let the two independent APIs live alongside each other and bridge information between them in a way that allows them to talk to each other.

Thus Netigso [the OSGi/NetBeans solution that is part of NetBeans IDE 6.9], runs two containers in the same Java virtual machine, alongside each other. The first container is the regular NetBeans Platform runtime container and the second container is Felix [or Equinox, via Netbinox] - an OSGi implementation written by Richard Hall. The bridge goes through all the registered JAR files and decides whether they represent an OSGi or NetBeans JAR (unsurpisingly, both systems use JARs as basic packaging units and also store additional information about the JARs in their manifest). Each JAR is then passed to the right container to receive the appropriate runtime environment.

Moreover, each JAR has a shadow - a fake peer registered in the other container - that just sits there and is ready to do the bridging. What kind of bridging? Well, mostly class or resource loading. As soon as there is a NetBeans module that has a module dependency (a.k.a "requires bundle") on some OSGi bundle, the shadow associated with that bundle gets activated. The NetBeans module then delegates all class or resource loading to that bundle. Similarly, if there is a NetBeans module exposing some public packages, any OSGi bundle can import them, which activates the shadow bundle associated with that module. The activation is then intercepted and the alternative bundle's loading mechanism is injected into it, which delegates all resource loading to the NetBeans module.

The beauty of this solution is that it remains fully compatible for both worlds."

For more on the above, see http://wiki.apidesign.org/wiki/Netigso, which is in Jarda's own unique words.

Today, I had my first experience in the actual USEFULNESS of mixing OSGi with the NetBeans runtime container. I took Gunnar's fantastic EMF/NetBeans integration sample and moved it to the tooling environment for Equinox that will be part of NetBeans IDE 6.9. Read about that here.

Right now, the only question I still have is very practical: what is the minimum set of EMF dependencies that I need when using EMF? I mean, in the example I took the entire "eclipse/plugins" folder, which contains over 1000 OSGi bundles. Not a very performant solution and, though the tooling handles everything well, that's not what I should be delivering to my users. I know there are tools for finding what the dependencies of some OSGi bundles are, though I would have thought there'd be a page that simply lists common OSGi bundle combinations, in the form of "if you want to use EMF, you will need the following dependencies", followed by a list of dependencies. Is there such a page or, if not, can someone tell me what the minimum set of dependencies is?

I can see us, assuming we can really get down to a minimum set of EMF dependencies (since the world is not enough!), including EMF in our NetBeans Platform Certified Trainings in the future. In fact, if such a minimum set of EMF dependencies can be identified, consider me a new EMF evangelist because it is, in that case (but only in that case), clearly a great system that NetBeans Platform developers will love to have in their toolkit.

Wednesday Mar 17, 2010

Biochemical Network Simulation on the NetBeans Platform

Yet another NetBeans Platform application in the list of bioinformatics applications on the NetBeans Platform is... drumroll... BioNessie:

"BioNessie is a free, state-of-the-art platform-independent BIOchemical NEtworks Simulation and AnalySIs Environment."

Clearly, it is an application on the NetBeans Platform:

"It provides a full user-friendly Graphical User Interface (GUI) which allows the user to import, create, edit and export the biochemical models with the SBML (Systems Biology Markup Language) standard. The unique Concurrent Versions System (CVS) design helps users to keep track of the version history of their SBML models during construction and subsequent modification."

Read more about it here!

Monday Mar 15, 2010

NetBeans Platform in the French Community

Mike Francois from Developpez.com recently translated into French an article I wrote on DZone. Here it is:

Interopérabilité d'OSGi avec la plateforme NetBeans

"Avec la sortie de NetBeans 6.9, la plate-forme de service OSGi s'est vue obtenir un support complet par l'EDI.

Geertjan Wielenga, auteur technique de l'équipe NetBeans, a rédigé un article sur l'interopérabilité d'OSGi avec la plate-forme NetBeans.

Ci-dessous, la traduction de son article qui je l'espère vous apprécierez autant que j'en ai eu pour le traduire."

So, it is great to have articles like this written, so that the NetBeans Platform can be introduced to French speakers too. At the same time, several French organizations are already making use of the NetBeans Platform, from the ray simulation analyzer at the University of Poitiers (described here) to the radar simulation analyzer at the French Ministry of Defence (described here).

And, in the next few weeks, a first NetBeans Platform Certified Training will be held for a selected group of new NetBeans Platform developers in France. That will be the first time that the course will be delivered via WebEx, maybe the start of several more, if everything turns out well. With Mike Francois from Developpez.com, I'm talking to see whether a small tour of cities/universities could be arranged to introduce the NetBeans Platform to French developers.

If French readers of the above are interested in this development in some way, feel free to say so (and suggest locations for trainings in France) privately via an e-mail to me or by leaving a comment at the end of this blog entry.

File-Based Document-Centric NetBeans Platform Application

Not all document-centric applications need a full-blown project system. So here is a small application that lets you create files. The files could open in a multiview editor, of course, but for sake of argument, let's simply open them in a plain text editor.

In the end, you'll be able to open the New File dialog:

...and choose the Letter wizard, set some properties:

...which is then generated (via FreeMarker) into your template:

To attain the above result, use the Wizard wizard to create a one panel file wizard. Design the panel as shown above. Then use the following content in your "instantiate" method within the iterator class:

@SuppressWarnings(value = "unchecked")
public Set instantiate() throws IOException {

    DataObject activatedDObj = WindowManager.getDefault().getRegistry().getActivated().getLookup().lookup(DataObject.class);
    String targetName = wizard.getProperty(LetterVisualPanel1.NAME).toString();
    DataFolder df = DataFolder.findFolder(activatedDObj.getPrimaryFile());

    Object[] data = (Object[]) wizard.getProperty(LetterVisualPanel1.PRODUCTS.toString());
    HashMap hashMap = new HashMap();
    hashMap.put("url", wizard.getProperty(LetterVisualPanel1.URL));
    hashMap.put("name", targetName);
    hashMap.put("types", data);

    FileObject template = FileUtil.getConfigFile("Templates/Letters/letter.letter");

    DataObject dTemplate = DataObject.find(template);

    DataObject dobj = dTemplate.createFromTemplate(df, targetName, hashMap);

    FileObject createdFile = dobj.getPrimaryFile();

    return Collections.singleton(createdFile);

}

Read about the DataObject.createFromTemplate here, as well as about how to register the template in the layer file:

<folder name="Templates">
    <folder name="Letters">
        <file name="letter.letter" url="letter.ftl">
            <attr name="SystemFileSystem.localizingBundle" stringvalue="org.car.templates.Bundle"/>
            <attr name="displayName" bundlevalue="org.car.templates.Bundle#Templates/Letters/letter.letter"/>
            <attr name="instantiatingIterator" newvalue="org.car.templates.LetterWizardIterator"/>
            <attr name="template" boolvalue="true"/>
            <attr name="javax.script.ScriptEngine" stringvalue="freemarker"/>
            <attr name="instantiatingWizardURL" urlvalue="nbresloc:org/car/templates/letterWizardDescription.html"/>
        </file>
    </folder>
</folder>

And here's the related "letter.ftl" file referred to above:

<html>

   <head>
       <title>Welcome!</title>
   </head>

   <body>

       <h1>
            Welcome ${name}<#if name = "Tom">, you wonderful person!</#if>!
       </h1>

       <p>URL: <a href="${url}">${url}</a>

        <table border=1>
           <tr><th>Chosen Products<th></tr>
          <#list types as product>
           <tr><td>${product}</td></tr>
          </#list>
        </table>

   </body>

</html>

To let FreeMarker process the above file, you need the "javax.script.ScriptEngine" element in your layer, as shown above, together with the following line in your manifest:

OpenIDE-Module-Needs: javax.script.ScriptEngine.freemarker

Then set dependencies on the DataSystems API, as well as the FreeMarker Integration module (until 6.9, after which you won't need this at all), which is within the "ide" cluster.

And now you're done. Simply brand the Favorites window as shown elsewhere and then you have a file-based document-centric application, i.e., you're not using any project-related APIs (which would have added a lot of superfluous features in the context of this small file-based application).

Sunday Mar 14, 2010

Why Investment in NetBeans Platform Trainings is a No-Brainer

Another pic from yesterday's first day of NetBeans Platform training at the University of Belgrade, Serbia:

Many more pics can be found here in Boris Horvat's Picasa Web Album, with more info on the NetBeans User Group Serbia site.

And, guess what, the adoption of NetBeans IDE could be increased massively if an investment were to be made in NetBeans Platform trainings. After all, the students at the University of Serbia have little interest in a training in NetBeans IDE, since IDEs are (or should be) intuitive. Therefore, either no training is needed (because the IDE is intuitive) or no training is wanted (because the IDE is such a mess that it is abandoned for another IDE). However... via NetBeans Platform trainings, students get exposed to NetBeans IDE, since NetBeans IDE is the SDK for the NetBeans Platform, as can be seen on the monitors below:

Hence, logic dictates that anyone who wants adoption of NetBeans IDE to increase should invest very heavily in promoting and sponsoring trainings in the NetBeans Platform, since anyone who has ever studied Swing and/or anyone who wants a modular framework for their applications (and who doesn't want that?) would then be exposed to NetBeans IDE via being trained in usage of the NetBeans Platform.

Saturday Mar 13, 2010

Another Day, Another NetBeans Platform Training...

These days Toni Epple and myself find ourselves in Belgrade, Serbia, delivering yet another NetBeans Platform Certified Training. Here's a snapshot of a class segment (from NetBeans User Group Serbia at the University of Belgrade):

Several of the students are very interested in AI (artificial intelligence), since they're the team behind Neuroph, which is going to be moved to the NetBeans Platform. Maltego from South Africa (yet another AI application on the NetBeans Platform) just came up in the discussion here in the Serbian pub where I've made the lifechanging decision that Jelen (a.k.a. "Deer Beer") is my new favorite beer.

Thursday Mar 11, 2010

YouTube Movie of jMonkeyEngine on NetBeans Platform

YouTube movie of a preview of jMonkeyEngine Game Development Environment that is being moved to the NetBeans Platform:

Follow the ongoing discussions about this work here.

Wednesday Mar 10, 2010

Bioinformatikzentrum Weihenstephan on the NetBeans Platform

Anton Epple, Aljoscha Rittner, and myself gave a NetBeans Platform Certified Training during the past 1 1/2 days at the Fachhochschule Weihenstephan, in Freising, Germany. More specifically, we were at the Bioinformatikzentrum, where the students are exploring the NetBeans Platform as the basis of bioinformatics applications:

Of course, they're not the first, at all, to evaluate the NetBeans Platform as the basis of bioinformatics applications, as argued by Toni in Is NetBeans the #1 Bioinformatics Platform?

It was a good time and we plan to keep in touch with the students on the course and to help where necessary in their work with the NetBeans Platform. And tomorrow Toni and I are off to Belgrade to give the same training to the NetBeans User Group Serbia!

About

Geertjan Wielenga (@geertjanw) is a Principal Product Manager in the Oracle Developer Tools group living & working in Amsterdam. He is a Java technology enthusiast, evangelist, trainer, speaker, and writer. He blogs here daily.

The focus of this blog is mostly on NetBeans (a development tool primarily for Java programmers), with an occasional reference to NetBeans, and sometimes diverging to topics relating to NetBeans. And then there are days when NetBeans is mentioned, just for a change.

Search

Archives
« March 2010 »
SunMonTueWedThuFriSat
 
4
6
8
12
16
20
21
25
   
       
Today