Tuesday May 24, 2016

Technology Evolution As Seen Through Conference Session Titles

I recently (last week) participated in JavaCro, a great Java conference in Croatia. I have participated in that event since its inception in 2012. Here are the titles of the keynotes I presented at JavaCro over the years:

  • "Unlocking the Java EE 6 Platfom" (29 - 30 May, 2012, in Tuhalj)
  • "Unlocking the Java EE platform with HTML5" (3 - 5 June, 2013, in Tuhalj)
  • "Consuming Java EE Backends in Desktop, Web, and Mobile Frontends" (12 - 13 May, 2014, in Poreč)
  • "Everything a Java EE Developer needs to know about the JavaScript Landscape" (11 - 12 May, 2015, in Rovinj)
  • "Oracle JET: Enterprise JavaScript for Visualizing Cloud Data" (18 - 20 May, 2016, in Rovinj)

More clearly than the above, the transition from fullblown Java EE to an increasingly HTML/JavaScript-centric frontend technology is hard to imagine! I think I can predict what my keynote session next year will be focused on—hybrid mobile development with Oracle JET, and related Cloud services, including REST endpoints via Java EE on the backend.

Now to think of a suitable title—maybe something like "Unlocking Mobile Devices with Oracle Cloud Solutions". 

Monday May 23, 2016

Locked/Unlocked Icons on Packages Matching "module-info.java" File

Here's what I'm working on in the context of Jigsaw, which kind of proves the awesomeness of the NetBeans APIs, since this is provided by an external NetBeans module. Take a look at the icons on the packages in the Projects window. Two of them have an unlocked lock icon ("com.wordlibrary" and "com.wordlibrary.spi") while the other two have a locked lock icon. The unlocked lock icons indicate that those packages have been exported via the "module-info.java" file:

Yes. Those locked/unlocked icons, and the analysis of the "module-info.java" file, all that, can be done externally via a NetBeans plugin. That's pretty awesome.

Sunday May 22, 2016

Getting Further Modulerizing with Jigsaw in NetBeans IDE

Let's modulerize the Anagram Game using Jigsaw further than we initially did, using the Services idioms that are also part of Jigsaw, discussed in the previous blog entry.

Here's the use case, i.e., a small Anagram game: 

The category can be switched via the drop-down: 

The point of this blog entry is that "Technical" and "Animal" are both made available via service providers, each made available by a different Jigsaw module, "org.wordlibrary.technical" and "org.wordlibrary.animal":

Each of the service providers serve up an implementation of the same service, "com.wordlibrary", consumed by "com.toy anagrams".

The point is that the application is now pluggable. Simply introduce onto the module path new Jigsaw modules that implement the service and register them using their "module-info.java" class, as discussed earlier. It's all very similar to META-INF/services, except that here we're using modules instead of libraries, with all the advantages that modules bring over libraries, in particular the ability to hide the internals of a module from unintended access.

Pretty cool to have applied all the concepts discussed in the previous blog entry to a real example and it works.

Saturday May 21, 2016

Getting Started with Java Jigsaw Services in NetBeans IDE

In the Project Jigsaw: Module System Quick-Start Guide, a section is included on Services. Idioms such as "service consumer" and "service provider" are part of the set of solutions provided by Project Jigsaw.

A full code sample is discussed in the section above, which I have successfully implemented in NetBeans IDE. Three Jigsaw modules make up the scenario—a service defined in "com.socket", a service provider defined in "org.fastsocket", and a service consumer defined in "com.greetings". 

Read this document, about the fact that "'module', 'requires', 'exports', 'to', 'uses', 'provides', and 'with' are restricted keywords", which are used in the ways described in that document in the "module-info.java" files below.

  1. Service (com.socket). Below, you see "NetworkSocketProvider", which is a pluggable API, accessed via "ServiceLoader.load" in "NetworkSocket". 

    The "module-info.java" above is as follows:

    module com.socket {
        exports com.socket;
        exports com.socket.spi;
        uses com.socket.spi.NetworkSocketProvider;
    }
    
  2. Service Provider (org.fastsocket). Below, you see an implementation of "com.socket.spi.NetworkSocketProvider" and notice that no packages are exported here.

    The "module-info.java" above is as follows:

    module org.fastsocket {
        requires com.socket;
        provides com.socket.spi.NetworkSocketProvider 
                with org.fastsocket.FastNetworkSocketProvider;
    }
    
    
  3. Service Consumer (com.greetings). Below, you see a service consumer, which needs to have the other two modules on its module classpath (while it still has "org.astro" available, which applied to an earlier sample). In NetBeans IDE, right now, the Libraries node does not visualize modules on the module path if they do not export any packages, as is the case with "org.fastsocket".

    The "module-info.java" above is as follows:

    module com.greetings {
        requires org.astro;
        requires com.socket;
    }

That's it—service provision and consumption natively built into the Java language for Jigsaw modules.

Friday May 20, 2016

Getting Started Modulerizing with Jigsaw in NetBeans IDE

Now that we have gone through an absolute basic scenario, yesterday, let's go ahead and modulerize an application, using Java Jigsaw to do so.

Here's the starting point, a small Java Swing application that provides an Anagram Game, which is one of the standard Java samples that comes with NetBeans IDE:

Each Java application you create with the NetBeans JDK 9 Branch Build is a Java Jigsaw module. So, I created a new Jigsaw module and moved the two Java classes you see above in the "lib" folder into the new Jigsaw module.

I put the "WordLibrary" class into a package named "api" and the "StaticWordLibrary", which extends "WordLibrary", into a package named "impl", I added a "module-info.java" file to both Jigsaw modules. In the API module, I exported the "com.toy.api" package and in the other Jigsaw module, where my Swing code is found, I required the "com.toy.api" module. In the Project Properties dialog of the Jigsaw module where my Swing code is found, I added the API module to the module path. I then had the following, which works exactly as before:

Most important of all, the Swing code is unable to use the "impl" package, since that package has not been exported. The WordLibrary class in the "api" package loads the "StaticWordLibrary" class in the "impl" package, while no other module needs to reference that "StaticWordLibrary" class directly. A key advantage in this scenario is precisely this aspect of hiding the internals of my application from others who might accidentally want to access and use these internals.

Thursday May 19, 2016

Getting Started with Java Jigsaw Modules in NetBeans IDE

I went through the first two sections of "Project Jigsaw: Module System Quick-Start Guide" in the NetBeans JDK 9 Branch Build. In the end, I had created the Greeting module, which requires the Astro module that exports the package containing the World class, used by the Main class in the Greeting module. Click to enlarge the screenshot below, to see the various details, including the "module-info.java" graph:

Right now, NetBeans does not yet support the features described in the quick start about Jlink, packaging, and multimodule compilation. Read here all the details on the current state of JDK 9 support in NetBeans IDE:

http://wiki.netbeans.org/JDK9Support

Tuesday May 17, 2016

Design of 3rd Edition of NetBeans Community T-Shirt!

Periodically, like anything else, the NetBeans community t-shirt gets an update! Today the update is connected with the upcoming NetBeans Day UK, to be held at the University of Greenwich on 31 May (free tickets still available!), where everyone will get a free NetBeans community t-shirt, sponsored by a range of organizations around the world!

New additions to the t-shirt are—AirHacks, Aspose, Kodewerk, and WakaTime!

Read about the 2nd edition here and the 1st edition here!

Monday May 16, 2016

Getting Started with "ojFilmStrip"

I've been getting to know ojFilmStrip, one of the many awesome Oracle JET components.

Everything I'm doing with Oracle JET at the moment starts from a hybrid architecture, i.e., it starts with the Cordova-based Yeoman-generated scaffolding, via NetBeans IDE, as described here

After doing the above, i.e., I have set up a hybrid Oracle JET application, I have it running in the browser via "grunt build --platform=android", and then I started reading the Film Strip section in the Oracle JET Cookbook. With that as a starting point, I did the following:

  1. Open the "incidents.html" file (in "src/js/views") and replace everything in there with the below. The bits in bold below are added, the rest is already in the "incidents.html" file:
    <div class="oj-hybrid-padding">
        <h3>Incidents Content Area</h3>
        <div>
            <div id="filmStripDiv" class="oj-panel" style="margin: 20px;">
                <div id="filmStrip"
                     data-bind="ojComponent: {component: 'ojFilmStrip'}">
                    <!-- ko foreach: chemicals -->
                    <div class="oj-panel" style="margin: 2px;">
                        <span data-bind="text: $data"></span>
                    </div>
                    <!-- /ko -->
                </div>
            </div>
        </div>
    </div>
    
  2. Open the "incidents.js" file (in "src/js/viewModels") and add ''ojs/ojfilmstrip" to the "define" block, then add the below right below "var self=this":
    self.chemicals = ko.observableArray([
        "Hydrogen",
        "Helium",
        "Lithium",
        "Beryllium",
        "Boron",
        "Carbon",
        "Nitrogen",
        "Oxygen",
        "Fluorine",
        "Neon",
        "Sodium",
        "Magnesium"
    ]);

The above is a minimal code usage from the Oracle JET Cookbook, i.e., focused only on making use of the absolute basics of the "ojFilmStrip" component. Plus, we're using an observable array because in the next part, we want to be able to add new chemicals to it and have the view update itself. Next, automatically, without refreshing, in the browser, I see this:

When I make the resolution narrower, a small subset of the chemicals remains visible and I can automatically scroll left and right:

Let's now work on letting the user programmatically update the film strip of chemicals.

  1. Add a button to "incidents.html", connected to a JavaScript function that you'll create in the next step:
    <button data-bind="click: addChemical">Add...</button>
  2. Before we add some kind of way for the user to specify the name of the chemical to add, we'll simply hardcode it.
    self.addChemical = function () {
        self.chemicals.push("Plutonium");
        $('#filmStrip').ojFilmStrip("refresh");
    }

In the above, I need to add the "refresh" because of the reasons described in this article. However, once the chemicals get to the end of the visible strip, the entire content of the strip disappears, i.e., the strip goes blank. It's some kind of refresh problem because when I change the resolution and click the arrows a few times, the content comes back again. The instructions for using "destroy" don't work for me.

Once the above works, i.e., I have tried this in the desktop browser as well as on my Android device, I'll have a great sample scenario for integrating the Android device camera into a cool Oracle JET component. 

Saturday May 14, 2016

Using the YoOracleJET NetBeans Plugin for iOS

When you use the YoOracleJET NetBeans plugin, which is a set of tools for doing hybrid OracleJET development in NetBeans IDE, you'll find a few "gotchas" when working on Mac OSX, i.e., you're creating iOS apps in this scenario.

The error you'll get while using the iOS project templates in NetBeans IDE, i.e., provided by the YoOracleJET plugin, is as follows:

env: node: No such file or directory

I googled around with the error above and came to this page.

As a result, I recommend you run the following commands on the Mac OSX command line BEFORE you use the iOS project templates provided by the YoOracleJET plugin:

sudo ln -s /usr/local/bin/node /usr/bin/node
sudo ln -s /usr/local/bin/cordova /usr/bin/grunt
sudo ln -s /usr/local/bin/cordova /usr/bin/cordova

Also make sure all the tools, i.e., Bower, Grunt, Node, NPM, and Yeoman are registered in  the Options window, which is under "Preferences" in the most left menu (named "NetBeans") on Mac OS X. The "Search" buttons won't work, just type in the paths or browse to them.

For me, they were as follows:


And, here with the Darcula look & feel:

Make sure that Bower, Grunt, Node, NPM, and Yeoman are all set in the Options window. (The "Yeoman" tab is not visible in the two Darcula screenshots above, though you can see it in the screenshot above that, the tab on the right of the HTML/JS category, but only if you have the YoOracleJET plugin installed.) Then go to the New Project dialog and use one of the iOS project templates provided by the YoOracleJET plugin.

Don't worry at all about error messages like these, which are simply related to not having Xcode installed, and have no impact at all:

xcrun: error: unable to find utility "simctl", not a developer tool or in PATH
WARN: Skipping following platform as the test command returned an error - ios => xcrun simctl help create with 72 
Error: xcode-select: error: tool 'xcodebuild' requires Xcode, but active developer directory '/Library/Developer/CommandLineTools' is a command line tools instance

You'll need to run "cordova platform add ios" on the command line, in the "hybrid" folder of your application (see step 3 in the previous blog entry about this), since there's no way to do this from within NetBeans IDE. Then run "grunt build --platform=ios" (on the command line or in NetBeans IDE) and "grunt serve --platform=ios --web=true" (on the command line or in NetBeans IDE).

Also, if you're serving from NetBeans IDE, you'll be asked to browse to the location of the "index.html" file when you serve up the application, which should look as follows:

You now have a starting point for creating iOS applications via Oracle JET in NetBeans IDE. Read further here, where you can see how easily you can serve to your connected device via "--destination=device", instead of "--web=true".

Friday May 13, 2016

Working with the Oracle JET Yeoman Generator on Mac OS X 10.9.5

Let's get further with iOS hybrid mobile development, i.e., on Mac OS X (in my case, 10.9.5, my wife's computer, just don't tell her about all the stuff I am installing on it now).

  1. Since we've got Yeoman and several other tools, including Node.js, already installed, we can easily install the Yeoman generator for Oracle JET: 'npm -g install generator-oraclejet'.

  2. Next, run 'yo oraclejet:hybrid hybridiosdrawer --platform=ios --template=navDrawer', where you can replace 'hybridiosdrawer' with any other project name you like.

  3. Once the process completes, go into the newly created 'hybridiosdrawer' (or whatever you've named the project) folder and then go into the 'hybrid' folder. In that folder, i.e., in 'hybrid', run 'cordova platform add ios'.

  4. After which you can run 'grunt build --platform=ios' in the main folder, i.e., on 'hybridiosdrawer'. Just ignore the warning, if you get it, relating to Xcode.

  5. The final step is 'grunt serve --platform=ios --web=true', which should open the browser and display your new application, together with a navigation drawer on the left, when you make the browser small enough to resemble the resolution of a mobile device.

I noticed one or two small problems along the way and ended up doing a lot of the above via NetBeans IDE 8.1, which I'll cover in the next part.

Thursday May 12, 2016

Installing Cordova and Yeoman on Mac OS X 10.9.5

Let's set up Cordova on Mac OS X 10.9.5, after which we'll set up Yeoman, in preparation for setting up the Yeoman generator for Oracle JET so that we can create hybrid Oracle JET applications via Yeoman, after which we can work on setting up the YoNetBeans plugin for iOS.

I'm starting out as a complete newbie to all of this on Mac OS X which, in fact, is my wife's computer.

  1. Start by learning about the command line: http://blog.teamtreehouse.com/introduction-to-the-mac-os-x-command-line

  2. Next, install Node.js. After installation, run 'npm' (without the quotes) on the command line, to make sure that Node.js has been installed. You should see Node.js-related output when you do this.

  3. Next, use 'npm' to install Cordova. Note that I needed to add 'sudo' in front of 'npm install -g cordova' (as well as the other 'npm' commands that follow) and then provide my password. After installation, run 'cordova' (without the quotes) on the command line, to make sure that Cordova has been installed. You should see Cordova-related output when you do this.

  4. Next, use 'npm' to install Yeoman and the other tools needed to work with Oracle JET, i.e., Grunt, Bower, Git, and Grunt-Cli. During the first step on that page, I see in the command prompt that my 'npm' (which I had installed 3 minutes earlier) is outdated and that I need to run 'npm install -g npm'. After doing that, 'npm -g install yo grunt bower git grunt-cli' works fine and all those tools, i.e., Yeoman, Grunt, Bower, Git, and Grunt-Cli are now successfuly installed. After installation, run 'yo' (without the quotes) on the command line, to make sure that Yeoman has been installed. You should see Yeoman-related output when you do this.

That's it, you've set up everything needed to use the toolchain that forms the basis of Oracle JET. Next, we'll work on setting up Oracle JET itself.

Wednesday May 11, 2016

Plugging into Devices with Oracle JET on Cordova (Part 2)

Now let's add real content to the scenario from the previous blog entry.

We start by pushing images from the camera into an observable array:

self.pics = ko.observableArray();
self.takePicture = function () {
    navigator.camera.getPicture(
            uploadPhoto,
            function (err) {},
            {
                quality: 50,
                destinationType: Camera.DestinationType.FILE_URI
            }
    );
};
function uploadPhoto(imageURI) {
    self.pics.push(imageURI);
};

Then, for each pic, bind the "src" attribute of an "input" element to $data, which is the current item from the for each:

<button data-bind="click: takePicture">Take Pictures of Incident</button>
<br/><br/>
<ul data-bind="foreach: pics">
    <li style="list-style: none">
        <input type="image"
               style="border:1px solid black"
               data-bind="attr:{src: $data}"
               width="250"
               height="250"
               alt="No picture taken."/>
    </li>
</ul>

Here's the result, where you can see my device via the Droid@Screen plugin installed into my NetBeans IDE 8.1:

The code above is really a port of the earlier AngularJS scenario created sometime ago that does the same thing. Seriously, much easier and simpler to understand above than via AngularJS.

Tuesday May 10, 2016

Plugging into Devices with Oracle JET on Cordova (Part 1)

In a previous blog entry, I discussed how to create AngularJS applications that access the native resources on devices, such as the camera on Android, via Cordova. Let's now do the same thing with an Oracle JET application. Start by using Yeoman to scaffold your hybrid (i.e. Cordova-based) Oracle JET application. Now you're good to go with the instructions that follow.

Take the following steps:

  1. In the "hybrid" folder in your application, you'll find a file named "config.xml", which is the central configuration file for all your Cordova-related work. Underneath the Cordova Whitelist plugin, add the Cordova Camera plugin, as shown below:
    <content src="index.html" />
    <plugin name="cordova-plugin-whitelist" spec="1" />
    <plugin name="cordova-plugin-camera" spec="1" />
    <access origin="*" />
    Then build the application, as shown in the earlier YouTube clip on this topic, i.e., "grunt build --platform android" and you'll find the "cordova-plugin-camera" folder has been added for you:



  2. Open the "incidents.html" file, which is in "src/js/views", and add a button that has its "click" event bound to a function named "takePicture":
    <button data-bind="click: takePicture">Take Picture!</button>
    
  3. Open the "incidents.js" file, which is in "src/js/viewModels", and add the function that you referenced in your HTML file, making use of the Cordova Camera API:
    self.takePicture = function () {
        navigator.camera.getPicture(
            function (imageURI) {
                //to be done
            },
            function (err) {
                //to be done
            },
            {
                quality: 50,
                destinationType: Camera.DestinationType.FILE_URI
            }
        );
    };

When you serve up the application to the device, using "serve --platform=android --destination=device", you'll be able to click the button and start the camera. After you take a picture, nothing happens, though that's the point of this blog entry—simply to show you how to connect to a resource on a device, subsequent blog entries will show subsequent steps.

Monday May 09, 2016

Adding a Page to a Hybrid Oracle JET Application

By default, the "navDrawer" template for hybrid (i.e., Cordova-based) Oracle JET applications looks like this, with collapsed/expanded offcanvas component on the left/right:

Now, let's add a new page to it and include it in the navigation and router.

Take the following steps:

  1. Start by adding a new JavaScript file in 'src/js/viewModels' and a new HTML file in 'src/js/views'. We'll imagine we're adding a new page for reporting, so name the files 'reports.js' and 'reports.html'. In NetBeans IDE 8.1 with the Oracle JET Support plugin installed, use the "New Empty JET Module" template to create these two files.



  2. Rewrite the 'reports.html' file to the following, which follows the same structure as all the other HTML file in 'src/js/views':
    <div class="oj-hybrid-padding">
      <h3>Reports Content Area</h3>
      <div>
          To change the content of this section, you will make edits
          to the reports.html file located in the /js/views folder.
      </div>
    </div>
  3. Open 'src/js/appController.js' and add your new page to the router:
    // Router setup
    self.router = oj.Router.rootInstance;
    self.router.configure({
     'dashboard': {label: 'Dashboard', isDefault: true},
     'incidents': {label: 'Incidents'},
     'customers': {label: 'Customers'},
     'suppliers': {label: 'Suppliers'},
     'reports': {label: 'Reports'},
     'profile': {label: 'Profile'}
    });
  4. Again in 'src/js/appController.js', add the new page to the navigation:
    var navData = [
     {name: 'Dashboard', id: 'dashboard',
       iconClass: 'oj-navigationlist-item-icon demo-icon demo-dashboard-icon'},
     {name: 'Incidents', id: 'incidents',
       iconClass: 'oj-navigationlist-item-icon demo-icon demo-incidents-icon'},
     {name: 'Customers', id: 'customers',
       iconClass: 'oj-navigationlist-item-icon demo-icon demo-customers-icon'},
     {name: 'Suppliers', id: 'suppliers',
       iconClass: 'oj-navigationlist-item-icon demo-icon demo-suppliers-icon'},
     {name: 'Reports', id: 'reports',
       iconClass: 'oj-navigationlist-item-icon demo-icon demo-suppliers-icon'},
     {name: 'Profile', id: 'profile',
       iconClass: 'oj-navigationlist-item-icon demo-icon demo-profile-icon'},
    

You shouldn't need to refresh your browser (especially with the NetBeans Chrome Connector plugin installed into the Chrome browser). You should see your new page, added to the navigation and router, as follows:

Now, that wasn't much work at all.

Sunday May 08, 2016

YouTube: Hybrid Mobile Development with Cordova and Oracle JET

The promise of Oracle JET is that it makes enterprise JavaScript development a good deal easier. The primary platform for JavaScript nowadays is the browser on mobile devices.

So, the question is, how does Oracle JET facilitate mobile development? Get started answering that question here:

Direct link to the above: https://www.youtube.com/watch?v=a8yzh-Ec38I

The key resources referred to above:

Friday May 06, 2016

Generator for Hybrid Cordova-Based Oracle JET Applications (Part 3)

The "YoNetBeans" plugin is now available in the NetBeans Plugin Portal:

Get it here: http://plugins.netbeans.org/plugin/64070

Thursday May 05, 2016

Generator for Hybrid Cordova-Based Oracle JET Applications (Part 2)

Here's the next step of the generator, which now also includes support for iOS:

Wednesday May 04, 2016

Generator for Hybrid Cordova-Based Oracle JET Applications (Part 1)

I'm working on a handy new plugin for NetBeans IDE that will let you generate hybrid Oracle JET mobile application skeletons, as can be seen below:

Related reading:

When you use the project templates shown above, you can generate the complete scaffolding of a hybrid, i.e., Cordova-based, Oracle JET application, as shown below:

The source code is here and the plugin will be available soon on the NetBeans Plugin Portal:

https://github.com/GeertjanWielenga/YoNetBeans

Tuesday May 03, 2016

New: Pin Debugger Watches in NetBeans Editor

Imagine you're a Java teacher or a presenter talking about Java at a conference. Or simply someone who likes being able to keep focus on a piece of code, rather than needing to look in a variety of windows within the software you're using to code or teach Java. You're using an editor to demonstrate some new Java code. You set a breakpoint and then you start the Debugger to step through the code and then... there's a Watches window that you need to point your audience to and repeatedly refer to, which is kind of hard to look at while at the same time trying to looking at the code.

Of course, you can hover your mouse over the variable and then a small tooltip appears showing the current value and then the tooltip disappears when you move your mouse... but hey... wait a minute... that tooltip appears to have a small pin icon to its left in NetBeans IDE 8.2:

...so that when you click on that pin icon a small dialog appears, which shows the current value of the variable you're watching, and remains there while you step through your code in the Debugger:

And you can set multiple pinned watches, while you can use your mouse to move them comfortably anywhere you like within the editor:

Now press Ctrl-Shift-Enter, which removes all the distractions around the editor, and notice that your development environment looks just like a text editor, with the difference that you have all the powerful features of an IDE, together with your watches pinned wherever you want them to be in the editor:

And that's the tip of the iceberg. Imagine if you were to combine it with the Darcula look and feel, for example:


And what about other languages? Yes, other languages too, e.g., JavaScript debugging works the same way:


Many more related features are described in the New and Noteworthy document for the upcoming NetBeans IDE 8.2 release, which you can already take for a spin and provide feedback:

http://wiki.netbeans.org/NewAndNoteworthyNB82#Pin_Watches

Monday May 02, 2016

New: SQL Profiler in NetBeans IDE

Imagine being able to profile your SQL queries! Anyone developing applications making use of a database backend would be able to quickly and clearly see which SQL query is causing the most contention within an application. Furthermore, if thread dumps and heap dumps could be made, it would allow for easy comparisons and be able to provide detailed information on the underlying SQL invocations.

Well... here it is, a new extension to the already awesome NetBeans Profiler, enabling you to analyze your SQL queries for the first time:

Read all about it in NetBeans Dream Team member Josh Juneau's blog, here:

http://jj-blogger.blogspot.nl/2016/05/netbeans-sql-profiler-take-it-for-spin.html

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

Categories
  • NetBeans IDE
Archives
« May 2016
SunMonTueWedThuFriSat
1
7
15
18
25
26
27
28
29
30
31
    
       
Today