NASA Adopts the NetBeans Platform

Tim Boudreau (pictured, right), Senior Staff Engineer at Sun Microsystems, recently spent some time with engineers at NASA, showing them how to use the NetBeans Platfom.

Below, he reflects on some of the interesting engineering needs that NASA has and how the NetBeans Platform is well suited to respond to these. During the interview, Tom Wheeler, one of the NetBeans Platform's several external contributors, talks about his participation in the course at NASA, too!

So, Tim, you trained NASA to use the NetBeans Platform. Why did they want to do this training?

Tim: Well, they're building the launch control systems for the post spaceshuttle generation of spacecraft. So, if you are watching a launch on TV, you see a room full of people looking at screens showing different measurements. For example, the fuel needs to be transported to the spacecraft, while it also needs to be maintained at a constant pressure and temperature as it travels to the spacecraft. There is monitoring hardware along the pipes that the fuel travels through and these monitors transmit their information to the control room where it needs to be visualized for a human being to monitor. The screens you see someone looking at are initially designed by a hardware engineer who knows where the sensors are and so forth.

NASA needs a designer environment which is simple enough for a non-programmer hardware engineer to use when designing a Swing GUI to show these  various measurements. There are many similar systems that are part of launching a spacecraft that are all in need of human monitoring when the very complex process of preparing a spacecraft for launch is taking place.

That is all well and good. But what does the NetBeans Platform have to do with all of this?

Tim: Well, they are actually reusing a lot of NetBeans IDE. In fact, they are reusing the "Matisse" GUI builder. So, some of what we helped them with was stripping down the user interface of Matisse to hide UI elements that are useful to a programmer but not to someone who is simply designing a screen and mapping components to measurement inputs.

Wait a minute. It's possible to customize Matisse?

Tim: Well, as a matter of fact, I made a few changes to Matisse to make it easier to customize. In particular, you can now globally hide the additional custom property editors that allow you to bind property values to values from other components. In the form editor, everything has a custom editor, where you can choose 'get it from the component' or 'get it from custom code'. Those features are too complicated for a non programmer. And they are also not usful to a non programmer. It is not the job of a hardware engineer to write the logic of the system. We also suppressed a couple of property categories such as those relating to beans binding, since these don't make sense in this context.

Great. Matisse turns out to be customizable. But, these are tweaks, really, are they not? At the end of the day, you still up end generating Java code, right?

Tim: Yes. In fact, they have their own project template and they're reusing the NetBeans built-in support for Java projects. And we also wrote some custom actions for the project which will find the screen class within the project and run it in a test environment with simulated data.

OK, before we continue, what kind of components does NASA have that need to be incorporated into Matisse in this way?

Tim: So, the user interface that they're creating is very visual and should represent the actual hardware. In  other words, if you are monitoring the fueling of a spacecraft, you will actually see a picture of a tank and a pipe leading to a spacecraft which looks like the real thing and is showing you measurements.

That means, their UI visualizes something they're doing up in space.

Tim: No, on the ground, before they launch. This is all before launch time. There are a huge number of things that have to be done exactly right for a spacecraft to be launched successfully. As I understand it, getting a spacecraft off the ground is a lot more complicated than keeping it off the ground.

So, NASA was able to incorporate its own Swing components into Matisse in such a way that these Swing components could be used to model their launch procedures and other similar scenarios?

Tim: Yes. This also involved some custom property editors and a nice new tutorial fell out of this process: Integrated Property Editors in NetBeans.

Tim, I understand that you had some help from a member of the NetBeans community.  Could you talk a bit about that?

Tim: Tom Wheeler has been an active member of the NetBeans community for several years and I know that he's developed several interesting applications on the NetBeans Platform because he gave a presentation about it at JavaOne last year.  I felt that his experience would help augment my training, so I invited Tom to offer his advice to NASA about how they could get off to a good start.

Tom, could you summarize the advice that you gave NASA?

Tom: I'd first like to thank Tim for giving me the opportunity.  Like him, I've always been fascinated by the work they do and I was honored to volunteer my time to help them.

I prepared for this by anticipating the questions they might ask, since I figured they'd be similar to the ones I had when I started working with the NetBeans Platform nearly five years ago.  Here are a few of them:

• How do you determine the best way to split an application into modules?
• Should you strive to have a few large modules or lots of little ones?
• How should we handle configuration management for a platform-based application?
• How do we stay current on changes to NetBeans APIs?
• Is it difficult to set up our own AutoUpdate Center?
• How can we customize our application without changing NetBeans source code?

I wasn't able to attend the training in person on NASA's campus in Florida, so Tim arranged for me to call in to a conference room where he had gathered the development team.  I began by asking if they had any specific questions for me.  It turns out that I had done a good job of anticipating their questions because they asked nearly everything for which I'd already prepared an answer!

Great. In the end, Tim, you guys basically spent some days giving NASA engineers a course about the NetBeans Platform. The topic relating to integration with the Matisse GUI Builder was a big part of that. But what other aspects of the NetBeans Platform were of relevance to their scenario?

Tim: They have a great bunch of really smart folks and they take what they do very seriously. They really wanted to know comprehensively about the NetBeans Platform. I doubt this is the last project where they will end up using it. So we spent three days doing the standard training, and then another two days focusing on the things they were likely to need, and focusing specifically on the functionality they were likely to implement.

Really? NASA was paying Sun for consulting services?

Tim: There are lots of organizations using the NetBeans Platform and I've done consulting with many of them. Generally, what I get asked to do is a few days of training and then sketch the architecture of what they are building and then make sure they know what they need to use and then understand it.

But, wait a minute, NetBeans is a free and open source project! Sun is getting paid for all this?

Tim: Yes, this is Sun making money on open source! And, personally, it was really a thrill to spend time with NASA. One of my earliest memories is watching the moon shots. To be part of all that in a miniscule way is really something special.

How large was the developer team attending this course and the related consultancy?

Tim: There were 10 folks I was working with directly, most of them were working with the launch control system, while others were working on the language integration for a spacecraft control language. And they are discussing creating an internal NetBeans user group for internal users of NetBeans!

Isn't it correct to say that NASA was customizing NetBeans IDE rather than doing anything with the NetBeans Platform?

Tim: If you're customizing the IDE, you're customizing the NetBeans Platform. The only difference is what modules and APIs you expect to be in the environment. It's really the NetBeans Platform all the way down.

What are the next steps that you anticipate your students to take?

Tim: Well, the next steps are to complete their integration with the NetBeans Platform. I helped them get on the path with this, though I didn't write this for them. My job is to give the students the tools they need to be successful. The next steps are to finish creating the components they will use, get them all embedded into modules so they are automatically installed into the Matisse GUI builder's palette, and then start using it in production.

Hopefully the next time you watch the spacecraft used on TV, you will see user interfaces built in NASA's customized NetBeans IDE!