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
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
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
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