Chad Dorkin is a Product Validation Design Engineer from PMC Sierra, a semiconductor design company. Chad's division is primarily focused on designing and validating storage area network protocol chips.
He uses the NetBeans Platform to build validation applications used to test PMC Sierra products. The applications make up a set of tools designed to help the validation engineers go through a typical validation workflow. This includes creating tests, executing them, logging the results, analyzing the results, and of course, debugging when necessary.
Hi Chad. Firstly, what are some typical needs that chip validation applications have?
The first thing that comes to mind is scalability. Our validation applications are not "write once up front and use forever" type of applications. We know from the very beginning that they will need to morph and expand over time. If all goes well, these applications will never be complete because we will always have new products to validate with them. As you can tell, it is critical that we have a solid scalable framework to build on.
Another important feature is modularity. Since our validation applications are not used to validate a single product, it is necessary that we separate out the logic for each of them. However, it is equally important to be able to leverage common components that are useful to the validation of many products.
Finally, the applications also require that we have a rich user interface and an extensive logging/output system to help guide the validation engineers through their typical workflow.
How does the NetBeans Platform help?
Scalability and modularity are both solved with the NetBeans Platform
modular architecture. At PMC we were
able to separate out the common non product-specific
functionality of our testing environment into a set of "core" modules, and
create module plugins for each of the products that we
need to test. This means that our core
application does not need to grow massively out of control, even if thousands
of products were added. A validation
engineer needs only load the core modules and the modules specific to the
product they want to test. The NetBeans
Platform makes this extremely easy.
In addition, in terms of UI, we have a lot of different windows floating around to help with the different parts of the validation workflow. So the NetBeans window system really helps out. We utilize window groups so that the user can open up different sections of the applications to perform different tasks. It’s also really important for the engineers to be able to configure the arrangement of the windows to best suit their needs.
Also, the global selection management in the NetBeans Platform really helps because we have all these different windows. Before switching over to the NetBeans Platform, I had originally utilized a third party windowing system, created my own global selection management system, and many other necessary components such as a custom Options dialog.
Here are some screenshots to give an impression of "Executor", which is used by system validation engineers to execute their tests. The first screenshot focuses on the customized About box, as well as details of the application behind it. (Click to enlarge each of the screenshots below.)
Executor test run results:
Executor system list:
By the way, after porting over to the NetBeans Platform, I was
able to rip out probably 30% of my own code just from the
And that's also code that you won't need to maintain and test anymore, right?
That's correct. What's also great is that the libraries that I ported our code to have a rich feature set and are well tested by the community.
Plus, for example, by the NetBeans IDE engineering team, who need those same libraries for NetBeans IDE! Do you use NetBeans IDE for development or something else?
Definitely the NetBeans IDE. Can you even do NetBeans Platform development without NetBeans IDE?
Definitely! Less easy than with NetBeans IDE, but certainly possible and many are doing so. For example, Maven projects are openable in any IDE. Another approach is to generate your NetBeans API artifacts in NetBeans IDE and then edit those artifacts somewhere else.
But why would you even want to do something like that?
Right. Stick with NetBeans IDE! So, when did you first get started with the NetBeans Platform?
Well, the current project I have been working on at PMC, we have been developing for about 3 years. But I've only recently ported it to the NetBeans Platform... because I got sick and tired of developing and maintaining all of the application boilerplate code. I would either develop the code myself or, for each type of functionality, I would pull in a third party library. And it just seemed silly to keep going that path when I could get everything out of the box from the NetBeans Platform.
Since that first application, I'm now in a team of 8 NetBeans Platform engineers, developing another NetBeans Platform application. And the second time round it's even faster and easier.
Which parts of the NetBeans Platform have you found to be most useful?
I think mostly all of it. But the part that the users see the most and are most impressed with is the windowing system.
However, under the hood there are many great features that have saved me loads of time. For example, I have been able to replace my old persistent user preferences scheme, which consisted of custom properties files or XML files. It is now implemented making use of the NetBeans Platform preferences system, where I don't have to worry about saving or restoring files myself.
Another feature that the user's love is the fact that they download the application once and have the application autoupdate for them forever.
So, you're using Java web start?
No, we build the ZIP via a script and then host it on a web server. After that, users download the application once and then get updates from our update server. For example, all of the bug fixes we distribute like that. Also, that's how we distribute new functionalities to match the new functionalities that we get in our chips, as well as general overall enhancements.
One of my personal favorites of the NetBeans Platform is the single-click to build a ZIP distribution of the application and of course the fact that it can also be executed from the command line with Ant. Previously, I had to jump through hoops trying to get my application bundled properly so that it could be distributed effectively.
What would you say to somebody considering getting started with the NetBeans Platform? How much frustration are they likely to encounter, during the first steps of their journey?
Well, the first thing I personally did was get the book "Rich Client Programming: Plugging into the NetBeans Platform" and now I'd get the latest book "The Definitive Guide to NetBeans Platform".
From the examples in these books, it is possible to port your application, if you choose little pieces at a time. For example, I started by porting all of my top level windows into TopComponents and then moved on to the Options window (tutorial here).
So, you're saying that porting is a process and not something that is ever really complete?
I would say that every month I find something in our application that would be better implemented by one of the NetBeans APIs, so I make changes continually based on that!
Finally, here's another of our applications on the NetBeans Platform. It is our TestBase application, here showing performance results:
TestBase registration form:
TestBase Vector Generator:
Thanks for the interview and cool screenshots, Chad. Keep us updated on your applications' continuing growth and evolution!