PlanetJava

Hi all,

There's a lot a great discussions going on at dev@usersguide.netbeans.org. Why don't you join it? It's the email alias for community members who want to:

1. Contribute documentation to the NetBeans Community.
2. Play a more active role in the NetBeans Community.
3. Provide input and feedback necessary to make important decisions regarding NetBeans documentation.
4. All of the above, of course.

Interested? It's easy to sign up. Just do the following:

1. Go to the NetBeans Mailing Lists Page and log on with your user name. (If you don't have one, just click Login. Then you can register for one.)
2. Scroll down to the dev@usersguide.netbeans.org mailing list. Click subscribe and a subscription request will be sent.
3. Within a few seconds, an email will arrive asking you to confirm the subscription. Just send an empty email back.

That's it! You're now a subscriber. Go ahead and start thinking of ways you can get involved.

Can't wait to see you there!

--James

A picture of snow-covered mountains from our bedroom window.

The ski-ers are looking happy these days.

Shot with the 70-210 Tamron telephoto, you can’t actually see this view from that window unless you’ve got surgically modified eyes.

It’s starting to happen. There’s a long way to go between successfully executing a bit of Rails and actually making the sucker run usefully, as the JRuby guys will tell you. But speaking of JRuby, there are some eerie similarities: a language-platform project that was promising, then drifting, now revitalized. The ecosystem gets more interesting all the time.

What happened was, a sudden email from Sun PR went around about fifteen minutes to Christmas saying “SYS-CON wants predictions for 2008; right now would be good.” It happened that I was in the middle of doing three months and ten trips’ worth of expenses, thus bored out of my mind, thus happy to prognosticate. I gave them five, but, given the urgency, not much more than sound-bites. I think each of them is worth a little exegesis.

1. RIA vs. AJAX: below, in this fragment.

2. Windows Looks Bad.

3. Rails Rules.

Prediction

The short version:

There's a major struggle going on between “RIAs” (Rich Internet Applications) and AJAX, which tries to do everything in the browser using just what the browser ships with. RIA frameworks are AIR (“Flash, the Next Generation”), Silverlight (“Microsoft wants in”) and JavaFX (“Isn't open-source better?”) I'm not brave enough to predict who wins, but I do predict that 2008 will be a crucial year; either RIAs enter the mainstream, or they start to smell like a red herring left in the sun.

Suspicion

Ever since we’ve had the Web, we’ve had those who say it’s Not Good Enough. I’ve long been among the RIA skeptics, for a couple of reasons. First, let me quote myself, from here:

This notion, that the Web GUI is insufficiently interactive and we need something richer, is widely held among developers and almost never among actual users of computers, and it’s entirely wrong. I can remember when people were forced to use compiled Windows and X11 applications, and most of them were extremely bad because it’s really hard to design a good interactive UI; when the Web came along, more or less everyone abandoned those UIs in favor of the Web, almost instantly and with shrieks of glee. Yes, Web UIs are drastically constrained, offer a paucity of controls, and enforce a brutally linear control flow; and these are good things. I remember, in the early days, people saying “Once you know how to use one Windows app, you know how to use them all”. Ha ha ha. But you know what? Once you know how to use a browser, you are well on the way to being able to use most Web apps. The best AJAX apps are still very Web-like (as in, the Back button always works); but they’re faster and more responsive and nicer to look at. The worst AJAX apps are like bad Nineties VB.

I stand by my point: the people who want to add UI “richness” to the Web are always developers, never users. Doesn’t mean they’re wrong; after all, the users weren’t clamoring for the Web before it arrived, either.

My other problem is that while I like my Internet applications to be rich, I have this old-fashioned notion that “richness” is mostly about compelling words and pictures and sounds and especially, most especially, interaction with living people.

On The Other Hand

I use Rich Internet Applications all the time. Mail. iTunes. In fact all rich applications have become Internet applications: I can publish ongoing fragments with a keystroke in Emacs, and create a Web slide-show from Lightroom.

But that’s not what they mean when they say RIAs; they mean “Whatever lies in the direction that Flash is pointing.” Which puzzles me, because near as I can tell, Flash is most useful for watching movies portably (a la YouTube) and cool casual games like N and Desktop Tower Defense.

But I Could Be Wrong

I’ve always seen it as a big problem that at the end of the day, Flash is proprietary. So is Silverlight (although it’s damn interesting that it runs on OS X). JavaFX tries to remove that problem. Maybe if we unleash the creativity of all the people who just don’t want to be sharecroppers on someone else’s plantation, we’ll see some RIAs that are actually interesting to business.

But don’t kid yourself that it’ll be easy. The browser already offers what most people (who aren’t software developers) consider an excellent user experience, and AJAX, done well, makes it even better.

This is the third of five predictions for 2008, expanded from the short form generated on short notice as described here.

Prediction

The short version:

Rails will continue to grow at a dizzying speed, and Ruby will in consequence inevitably become one of the top two or three strategic choices for software developers. But at the same time, other frameworks and tool-sets are learning its lessons, so Rails will get some serious competition.

I Hear a Very Gentle Sound

I don’t know anyone who’s actually doing methodologically respectable head-counts of Web developers, so any opinion from anyone is based on anecdotal evidence at best. But these days, based on my anecdotal evidence, everything I see and smell, the white-hot pace of Rails adoption isn’t slowing down at all.

Rails drags Ruby along behind it, and good programmers who are exposed to Ruby tend to become addicted pretty quickly.

Who’s Watching

There is one group of technologists who are now 100% familiar with Rails. I’m speaking of the developers of competitive Web frameworks, many of whom felt somewhat smacked upside the head by Rails’ sudden noisy chomp into their market share.

By and large, they’re not stupid. They may not have been as quick to notice the things that DHH and the other Railsists noticed, but they’ve noticed them now, and more or less every other piece of the Web ecosystem has something “Rails-like” in hot development or in production. Some of the names to watch are Django (based on Python), lift (based on Scala), and Grails (based on Groovy). But I predict fearlessly that there will be a Real Important Web-framework grabbing mindshare a year from now that’s learned Rails’ lessons but ain’t one of those.

I Could Be Wrong

Maybe the population of developers will wake up, shake their heads, and say “Nah, going back to PHP, it’s faster” or “Actually, now I see that Java EE’s XML configuration files are da bomb”.

But I don’t think so.

NetBeans sources will be moving shortly to a different version control system - Mercurial. The details of the migration are detailed here. Tonda is in charge, so send him feedback. If you are not familiar with distributed version control systems, take a look at this article. Here is how I configured my own instance of NetBeans 6 to use Mercurial and point to the new repository.

Nota bene: I am running on a Mac - Leopard + Java 1.5.0_13.

• Get Mercurial (it will require Python)
• Python 2.5.1 for Macintosh OS X
• Mercurial 0.9.5-bc475d1f74ca for OS X 10.5 (supported version is 0.9.4)
  
  
• Install the Mercurial plugin from the NetBeans update center (Tools | Plugins) and get familiar with the documentation.
  
  
• Point NetBeans (assuming that you are using NetBeans to build and develop) to the repository (Versioning | Mercurial | Clone Other ...): http://hg.netbeans.org/main
• If you are looking for instructions on how to clone a repository from the command line, I found this document to be useful
  
  

The process for getting from ‘great idea’ to ‘component in an eclipse.org project’ is an evolving one. In its tireless approach to making process simpler, the EMO will now accept (as of Oct 20, per Ecore Tools, Emfatic, and Servus) a wiki doc proposal instead of a zip with HTML files, css & images.

As EMFT becomes a very popular place for new components to be planted and to blossom, others may want to copy our model and provide similar services within their projects. Other open-source contributors may want to propose components to be added to other projects, and wonder, how in Bjorn’s name do I do so?

So… as a service to others, here’s some references on how to navigate the treacherous waters. Note that with all Eclipse.org processes, docs are subject to change without prior notice.

• Component Creation (roles and responsibilities, in process order)
• Currently Proposed EMFT Components

See also:

• Project Lifecycle
• IP Process In Cartoon Form
• A Guide to the Legal Documentation for Eclipse-Based Content
• Committer Due Diligence Guidelines
• Yet More Process & Governance Docs

Here is a mini-tutorial for creating a Popup window for the user to lookup values. One scenario that you might use this for is when the page visitor needs more information then can be displayed in a drop-down list.

This is a rewrite of a previous blog entry that was written for the Sun Java Studio Creator IDE. I have modified the steps so that it works for the NetBeans 6.0 IDE.

1. Create a web application project with the Visual Web JavaServer Faces framework.
   
   
   
   
2. Add a page named Popup.
   
   
   
   
3. Add a Table component to the page.
   
   
   
   
4. Drag VIR > Tables > State from the Services window and drop it on the table.
   
   
   
   
5. Right-click the Table component and choose Table Layout from the pop-up menu.
   
   
   
   
6. In the column for the STATE.STATEID database field, set the Component Type to Hyperlink, and click OK.
   
   
   
   
7. Select the Hyperlink component so that its properties appear in the Properties window.
   
   
   
   
8. Set the value for the onClick property to doSave('#{currentRow.value['STATE.STATEID']}')
   
   
   
   (I got the value to pass to doSave() from the Value Expression in the Table Layout dialog).
   
   
   
   

<webuijsf:script binding="#{Popup.script1}" id="script1">
<![CDATA[
function doSave(val) {
 window.opener.setVal(val);
 window.close();
}]]>
</webuijsf:script>

<webuijsf:script binding="#{Form1.script1}" id="script1">
<![CDATA[
function doPopup(destination) {
 popup = window.open("", "popup",
 "height=300,width=200,toolbar=no, menubar=no,scrollbars=yes");
 destinationElement=document.getElementById(destination);
 popup.focus();
}

function setVal(val){
 destinationElement.value=val;
}]]></webuijsf:script>

Hi all,

Just to let you know, I've added two new tutorials to the NetBeans Web Apps Learning Trail:

• Using Java Persistence API Within a Visual Web Application
• Modifying Database Table Rows with the Java Persistence API

Enjoy them!

--James

One way to gage success of product or technology is to look at the job trends that call for relevant skills. Honza recently pointed me to this site, that helps professionals search for jobs. I was pleasantly surprised to see the recent surge of jobs that call for NetBeans. I suspect that the industry has realized by now that NetBeans the best IDE for Ruby, Web Services and Swing application development.

December is usually a slow month and this shows in the number of posts at USERS@gf (927, down from 1359); but not in the latest GeoMap (thanks, Jamey), which shows more IP hits (218715 up from 171182) and only slightly fewer IP addresses (34926, down from 36082). Early indications from registrations (see [1]) suggest good Download Statistics.

As a reference, I checked on USERS@Tomcat and their posts also went down in December but not as much as with GlassFish, which I attribute to the larger percentage of enterprise users in GlassFish, but, we will see...

The data from the Admin console has the usual overcount/undercount problems. Now that the UpdateCenter machinery (see intro blog) is working properly in GFv2UR1 we should be able to get more accurate adoption statistics; I'll report back in a few weeks.

• last JDK-1.4 release (next release will be Java 5 based)
• first Apache release: renamed packages to org.apache.wicket
• simplified several core APIs
• now works with zero-config behind a proxy server using relative URLs
• added Google Guice support
• use your Wicket pages directly in a portal without changing a line of code (JSR-168/JSR-286 support)
• switched logging API from commons-logging to slf4j
• integrate velocity templates as panels in your pages
• YUI-calendar and Joda time based date picker (wicket-datetime)
• contribute new javascript dependencies to the page header using an Ajax requeset
• improved, more robust header contributions
• scale to extremely large numbers of users with stateless pages and components
• improved AjaxTree/AjaxTreeTable
• hybrid URL encoding to make search engines and your users happy
• create form panels and use them anywhere without worrying about the nesting of form tags
• minimized session use by storing component hierarchy in file system (DiskPageStore)

[ Category : Apache Wicket ]

The other enhancements were related to or caused by the changed status:

• WebFrameworkProvider.getConfigurationPanel() and FrameworkConfigurationPanel were deprecated and replaced with WebModuleExtender. The main reason for this change was the unclear lifecycle of FrameworkConfigurationPanel. Imagine calling WebFrameworkProvider.getConfigurationPanel() twice: what should the method return on the second call? The panel returned by the first call? A new panel? The WebModuleExtender solves this problem.

• WebFrameworkProvider.extend() was deprecated and replaced with WebModuleExtender.extend(). Again, the reason was the unclear lifecycle.

• The API is not linked to the wizard API anymore (FrameworkConfigurationPanel used to extend WizardDescriptor.Panel). This fixes a design flaw in the API which made it hard to extend a web module from the project customizer, where there is no wizard available.

• ExtenderController was introduced to allow a framework implementor to set error messages for the configuration UI.

I want to make use of the changed API soon and, when I do, I will report here on my findings. To see these changes in action already, should you need to do so, see the Struts and JSF framework support classes in the NetBeans sources, which have been upgraded. However, in order to avoid losing history, they weren't renamed. So, even though the Struts class should be called StrutsWebModuleExtender, it is still called StrutsConfigurationPanel.

Of course, the first and best place to read about NetBeans APIs is the related Javadoc:

org.netbeans.modules.web.spi.webmodule.WebFrameworkProvider

Thanks to NetBeans engineer Andei Badea for providing all this information.

Groovy 1.0 is one year old. Version 1.5 has been released since and while Sun has been more focused on JRuby, Groovy and Grails are fairly well supported in both NetBeans and GlassFish.

Metro 1.1 was released last month. This blog describes how to install Metro 1.1 on GlassFish v2 UR1 (which comes with Metro 1.0 baked in) and use it with NetBeans IDE.

1. Download & Install Metro 1.1.
2. Download, Install & Configure GlassFish (detailed instructions)
   1. Download GlassFish v2 UR1.
   2. Install GlassFish by giving the command:
      
      
      
      ant -f setup.xml
   3. Set AS_HOME to the location of GlassFish v2 UR1 directory and install Metro 1.1 by giving the following command in Metro 1.1 directory:
      
      
      
      ant -f wsit-on-glassfish.xml install
      
      
      
      This will install the latest Metro 1.1 binaries in the GlassFish Application Server instance.
   4. Configure GlassFish in NetBeans 6 by going to the "Services" tab and right-clicking on "Servers" node and selecting "Add Server...".
3. Create a simple Metro Web service by following this tutorial. Create a Secure and Reliable Web service following screencast #ws7. The complete tutorial to add WS-* capabilities to your endpoint is available here.

Please leave suggestions on other TOTD that you'd like to see. A complete archive is available here.

Technorati: totd webservices metro glassfish netbeans

Our traditional (well, this is the third in four years) New Year’s Day social went off very nicely, thank you. We had RSVP’s from 40 or so adults with at least ten kids. Things that we kept the same: Cordon Rouge, gazpacho, lentil soup, and coffee cake. Innovation: hiring a real babysitter to hang out upstairs with the kids. Emma was great but went home looking frazzled; there are still a few nerf darts on the ceiling.

Here’s a shot of part of our front hall once things were well under way.

Thanks everyone for coming, and if our invite went astray or you slipped our minds, sorry.

We’re thinking of maybe shifting it to the summer solstice when it’s not so dark and cold and awful and the kids can go out in the yard.

This is the second of five predictions for 2008, expanded from the short form generated on short notice as described here.

Prediction

The short version:

The strain due to the fact that most business desktops are locked into the Microsoft platform, at a time when both the Apple and GNU/Linux alternatives are qualitatively safer, better, and cheaper to operate, will start to become impossible to ignore.

Experience

Around our house, we have screens connected to Windows XP, OS X, and Ubuntu GNU/Linux. Ubuntu and OS X are easier to install, less trouble to maintain, and more pleasant to use. If we were tracking the time we spend maintaining these things, I’m willing to bet that Windows takes more care & feeding than the other two put together. Down the road we’ll have Windows only for games, I think.

We also provide tech support for our mothers, a local Pilates studio, and various random friends, local and remote. Wherever we can, we’re steering them to OS X just because they’ll experience less pain and be more productive.

Pain

These days, when you live mostly on OS X & Ubuntu, XP is just incredibly irritating. There’s always something pestering you to update it: Adobe, Java, Norton, whatever. Plus random other whining from the bottom right corner of the screen, about unused icons and firewall security and so on.

As for my family & friends who aren’t pros, and who haven’t been under the tutelage of one either, their Windows boxes are mostly smoking, diseased, quivering heaps of goo. Who’s got the time to deal with that shit?

Why I Might Be Wrong

I haven’t spent any time with Vista. Possibly, after a couple of releases, it’ll make Windows competitive again.

From the Business Point of View

I talk to the individuals and small businesses who are still running Windows, and I compare them to those who’ve escaped, and it’s just not close. Recently I was helping Mairin get her system set up—a Mac mini, which BTW is a fabulous computer for a small business—and was showing her how to do something and she said “But that’s so easy? Why?” and I said “Well, that’s how things work on this system” and she said “Well, why are people still using Windows then?”

The Future

Microsoft’s continuing extraction of monopoly rents is dependent, near as I can tell, on just two things:

1. MS Office staying good enough that people don’t mind paying the fearful Windows tax that goes with it. Except for, Office runs better on OS X than on Windows.

2. The Exchange/Outlook lock-in. This seems the big one to me.

Like I Said

This problem is becoming increasingly impossible to ignore. Especially now that nearly everyone has someone in the family with a Mac.

• NetBeans 6.0 for Linux, Mac OSX, Solaris, Windows
• NetBeans 6.0 Source Code
• JDK 1.6 update 3
• Selected Java Tutorial Trails
• "Java Programming with Passion" course
• A screencast demo showing NetBeans in action
• Java Platform API Specification

The latest JSF Components from Project Woodstock are now available via the GlassFish Update Center client at INSTALL/updatecenter/bin/updatetool. What you download is equivalent to the Online Preview; check out Dick's Writeup.

Coincidentally, Ken, Jason and Rick just published an article on Using JSF Templating and Woodstock. And you may also want to read previous articles at TheAquarium on Woodstock and UpdateCenter.

Two of my BIRT sessions were accepted for EclipseCon 2008 so I’ll see you all in Santa Clara in March.

One session is called “Advanced BIRT Report Customization” and deals quite a bit with scripting in BIRT.  I’ll be co-presenting with Jason Weathersby.  Detailed information is available at http://www.eclipsecon.org/2008/index.php?page=sub/&id=207.  (P.S.  There is still time to shape this session so if you want to see something specific around BIRT scripting included, email me soon)

The other session is called ”Amazon Web Service Report” and is a fast-paced 10 minute look at using the BIRT Designer to create a report from a Web Service.  Detailed info is available at http://www.eclipsecon.org/2008/index.php?page=sub/&id=209

If you haven’t already done so, you can register for EclipseCon by clicking on the image below.

Only yesterday I discovered that the Code Template Tools module was not working with NetBeans 6.0 FCS. I have fixed the issue and uploaded the module on NetBean Plugin Portal. The older, NetBeans 5.x compatible module can be downloaded from here.

UPDATE: I have improved the Surround With... Action (Ctrl+J T) for interactive use. Now it shows a pop up dialog with a list of templates. You can select a template and type ENTER or double click to insert the template in the editor. If the editor has some selected text then the templates using the ${selection} parameter are shown at the top of the template list. You can just type the template prefix to select a matching template quickly.

 

If you haven’t already, be sure to read Steve Yegge’s post on his experience of dealing with large code bases (it’s a bit long post but an excellent read).

He explains the maintenance nightmare of his 500.000 lines of code game written in Java and quite correctly concludes that code size is a crucial problem for big software projects.

My minority opinion is that a mountain of code is the worst thing that can befall a person, a team, a company. I believe that code weight wrecks projects and companies, that it forces rewrites after a certain size, and that smart teams will do everything in their power to keep their code base from becoming a mountain. Tools or no tools. That’s what I believe.

I know this seems too much at first, but it’s actually quite common for projects that are developed over the few years period. Especially when you have a team that changes team members (even juniors) on regular basis, fast development pace and limited amount of resources for project management (aren’t there always?).

Steve goes then on explaining how, from his point of view, refactoring doesn’t help much in this case since it will only enlarge a code base and actually make things even worse. I don’t see it that way, since a better organized code is definitely more readable and easier to maintain. The other problem I often see with refactoring is team’s reluctance to perform them for two reasons: laziness and fear. Both of these are psychological and related with “if ain’t broken don’t fix it” approach. So the team see the part of the system as “not ideal” but working and usually dedicates resources to “new features” and customer demands.

The “fear” part means that people (in general) are not eager to take responsibility for doing risky modifications which can possibly break the whole system. I find this especially hard in cases when modifications include data layer (database schemes) and a huge amount of “live” data. This kind of “refactoring” impose a big risk on the current system, since you have one chance to do it right, it can be very time consuming and if something goes wrong it’s hard to go back (if it is possible at all). Badly designed database schemes tend to live in systems for the long time, so be sure to put an extra effort trying to make them as good as possible in the first place.

In the end, Steve decided to reimplement the whole application using Rhino (JavaScript for the JVM) and try to keep the code base under the 200.000 lines of code (which is by some theories an upper boundary of how much one developer can handle).

So taking for granted today that VMs are “good”, and acknowledging that my game is pretty heavily tied to the JVM - not just for the extensive libraries and monitoring tools, but also for more subtle architectural decisions like the threading and memory models - the rational answer to code bloat is to use another JVM language.

One nice thing about JVM languages is that Java programmers can learn them pretty fast, because you get all the libraries, monitoring tools and architectural decisions for free.

While I agree that JVM languages are one of the greatest advantages of JVM as a development platform, I would take Ola Bini’s side on this matter, who says in his post

Now, if I would have tackled the same problem, I would never reimplement the whole application in Rhino - rather, it would be more interesting to try to find the obvious place where the system needs to be dynamic and split it there, keep those parts in Java and then implement the new functionality on top of the stable Java layer.

That’s exactly why I think dynamic languages and frameworks (APIs) for their integration in Java should be an important tool in every developer’s tool box. There are places in your application where both programming approaches makes more sense over the other and the possibility to combine them to make a better architecture of your project can only be a good thing. And of course, it would improve maintainability of your projects as well, both in code size and ability to make appropriate refactoring and improvements while you go.