Last week I blogged about the free and open source EPUB Open Toolbox which I am creating for publishers and authors. Officially, it is now known as Fosfor, since it is initially being developed for the Fosfor Uitgeverij, that is, an on-line e-book publisher based in Amsterdam, as a replacement for Sigil. And this is yet another example of how the web and mobile worlds need the desktop—just for fun you should ask a publisher or author some time: "Do you ever see yourself editing and managing books on your mobile phone?"

At the time, when I started working on this, I was using the SHEF framework as the basis of a WYSIWYG editor. That had its shortcomings and I couldn't help thinking that the JavaFX WebView would be a more natural fit.

So, here we are a week later, with the JavaFX WebView doing a superb job rendering the XHTML pages of EPUB projects:

It simply looks awesome. No credit whatsoever for me on that score, since I'm simply reusing the JavaFX WebView, the creation of which I had nothing to do with. Images are rendered, which wasn't the case with SHEF, the performance is great, and the whole thing just looks professional, like a commercial off the shelf product that took years to develop, rather than days. Aside from the rendering, there's a lot of functionality built into the JavaFX WebView, e.g., when you right-click on an image, you get popup menus for opening the image in a new view, when you right-click on a URL, you can open the URL in a new view, etc.

But, I don't want a web browser. I want a WYSIWYG editor. The start is clearly there, i.e., there's a JavaFX toolbar containing JavaFX buttons, each of which will be, once the prototyping phase is over, provided by different NetBeans modules. For example, here's the color chooser in action—select a piece of text, invoke the color chooser, select a color, and immediately the font of the selected text is changed to the selected color:

Still many things to do. Especially, synchronizing changes back into the source file. Once that's done, all the rest should be relatively painless. Not possible, right now, to type in the WebView, but I have a pretty good idea how to solve that. My insight on this is that there's no difference between adding characters and adding colors to selected text. And it's also possible to get hold of the cursor in the JavaFX WebView, so the basics for typing are already included in the app. With that solved, its all about adding more tools, e.g., a bold tool, italics tool, font size, and so on.

I've shared the above pics with Sean Phillips who works on NASA software (he's been mentioned in this blog several times, has a lot of JavaFX/NetBeans Platform articles on NetBeans Zone, and hopefully will be at JavaOne this year) and he responded pretty positively from his perspective at NASA:

Based on what you have said and the limited images I've seen, this could be used as a technical document markup tool. Several of the Ground System missions I am associated with have home brew tools that generate documentation. Office tools like MS Word and the like can't really be used because a significant portion of the documentation is based around data produced by custom mission specific software systems. As a result, someone ends up writing code that generates Latex or HTML as a custom one off. I wonder if there could be a future in a tool like what you are developing that could be used towards a goal like what I have just described.

Part of my reason for blogging about this is to ask—are there developers out there who have tools written in JavaFX (or who would like to start doing so) that are relevant to the above and could be contributed to the free and open source Fosfor project?

Let's say you have a NetBeans Platform application that puts a premium on vertical space.  Maybe a Heads Up Display on a Touch Screen?  Wouldn't it be great to have the menu slide out from the edge of the screen only when you need it?  Well the NetBeans Platform provides slide-in TopComponents, of course, but a JMenu just isn't going to work out so well inside one. Preview...

qSim is a computer network simulator with emphasis on Quality of Service (QoS) mechanisms. It lets you observe how computer networks react to different QoS mechanisms, including network node usage (input/output queues, RX/TX buffers usage), data flow delay time, and packet drop statistics.

13 QoS mechanisms are supported, which can be divided in three groups: packet classification & marking, active queue management, and packet scheduling algorithms.

The network topology is fully customizable, including:

• link bit rate and length (in meters)
• link reliability
• simulation of input/output queues
• simulation of RX/TX buffers
• size of all buffers/queues
• different data flows (TCP/UDP/ICMP protocols supported, various packet sizes, realistic packet generation delays)

The simulations have been tested and compared with real CISCO devices, with positive results.

qSim was developed at the Faculty of Informatics and Information Technologies, Slovak University of Technology, in Bratislava.

Knockout4Java takes the best of two words: The type safety of Java and Knockout.js ability to alter any HTML page in any browser. Write your models in Java (using JSON4Brwsr library) and render them as HTML with the help of Knockout4Java!

--JaroslavTulach 21:32, 16 May 2013 (UTC)

SimuQuest is a Michigan-based software development company that specializes in working with electronic hardware companies that produce electronic controls for such things as car engines or wind turbine generators.

UniPhi is one of SimuQuest's software tools. It is created on the NetBeans Platform. It is a model-based development tool for data management and dependency visualization, enabling consistent, version-controlled management of data (signals and parameters) and rapid visualization of object dependencies (modeled features, signals and parameters). UniPhi is deployed to develop embedded systems using model-based design within a variety of industries such as aerospace, automotive, consumer appliance, and alternative energy.

Further info:

http://www.simuquest.com/products/uniphi

Most modern automation installations, such as controlers of machinery on factory assembly lines, amusement rides, or light fixtures, are driven by Programmable Logic Controllers (PLCs). Low level programming languages that have been used for decades, such as Ladder Diagrams (LD), are still being used to develop new PLC software. Together with the ageing techniques inherent in such programming constructs, there are hidden  penalties, such as the fact that PLC software is brand dependent.

PLC-PROG is the first tool for PLC programming to enable a completely brand independent and user-friendly object oriented approach, resulting in a reduction of development cost and an increase in the reliability of developed programs. It is valid for all PLC brands which comply with the IEC 611131-3 standard, is based on graphical programming methodologies, requires no specific programming skills, and makes it possible to perform both monitoring and visualization from the tool.

PLC-PROG has been developed using the NetBeans Platform, to take advantage of the benefits that its libraries offer. Below you see the PLC-Prog Visual Editor with the rack concept, which is a base element on top of which fuctions and input/output modules can be dragged: 

Other tools, such as a Tree View for tracking programming flow, is shown below:

Further info:

http://www.plc-prog.eu/

Most of the popular acronyms are wrong:

1. SOAP (Simple Object Access Protocol): is neither simple nor object oriented. "SOAP originally stood for 'Simple Object Access Protocol' but this acronym was dropped with Version 1.2 of the standard.[2] Version 1.2 became a W3C recommendation on June 24, 2003. The acronym is sometimes confused with SOA, which stands for Service-oriented architecture, but the acronyms are unrelated…" http://en.wikipedia.org/wiki/SOAP
2. AJAX (Asynchronous JavaScript and XML): Most of AJAX applications are using JSON, not XML. AJAX' core component is the XMLHttpRequest JavaScript object / browser API. Without XMLHttpRequest would be hard to implement an AJAX application...
3. NoSQL: "… Some authors refer to them as "Not only SQL" to emphasize that some NoSQL systems do allow SQL-like query language to be used…" https://en.wikipedia.org/wiki/NoSQL. …and often the offered NoSQL query language is structured and very similar to SQL :-)
4. EJB (Enterprise Java Beans): Well designed JavaBeans are actually not well designed EJBs.
5. YAGNI there should be no acronym for that. Thinking about that may cause endless loops :-)

See you at Java EE Workshops at MUC Airport!

Project News NetBeans IDE 7.3: Power Tools for HTML5 & JavaScript From NetBeans IDE 7.3 onwards, released earlier this year, new features have been introduced to enhance the development experience for HTML5/JavaScript/CSS3 Web applications. In this article, an overview is provided of all the new features encompassing the new tools for HTML5 and JavaScript developers.Legacy ...

This blog post introduces another exciting new feature in the upcoming NetBeans IDE 7.4. Namely, JavaScript debugging and visual CSS editing on Android devices. So without further ado, let's see how it works.

As a prerequisite, you will need an Android 4.x device. Let's do some setup steps that you only need to do once. First, install the Chrome browser on the device. The Chrome browser is available in the Play store.

Next, you will need to turn on USB debugging both at the system level and in the Chrome browser, which can be done in Android's Developer options in the phone settings. Note that on Android 4.2 and newer, Developer options is hidden by default, so we need to unhide it first. To do that, go to Settings > About phone option in settings, and tap Build number seven (7) times. Then return to the previous screen, and you will find Developer options.

Once Developer options are present, you will see the USB debugging checkbox inside this category. Make sure it is checked.

Next, open the Chrome browser, go to Chrome settings, and under Advanced > Developer tools, check the Enable USB Web debugging checkbox.

We will also need to set up the Android SDK and point NetBeans to it. In NetBeans, go to Tools > Options (or NetBeans > Preferences on Mac OS X), choose Miscellaneous > Mobile Platforms, and specify the location of the Android SDK. In case you don't have the Android SDK installed on your machine, the dialog provides a convenient link to the SDK's download page. This completes the one-time setup.

Now, to start developing your web application on your Android device:

• Connect your machine and the Android device with a USB cable
• Connect your developer machine and the Android device to the same Wi-Fi network (this is necessary so the device can access the web server running on your computer)

To run the application in Chrome on your Android device, click the new browser switcher icon in the main NetBeans toolbar, and select Android Device (Chrome).

Next, just run the application, and the application will open in Chrome on your device.

Let's now see how we can tweak the style of this application directly on the device. You will notice that in the IDE, a couple more windows opened: Browser DOM and CSS Styles. The Browser DOM window displays the real DOM tree as rendered by the browser on your device. When you select elements in this window, the CSS Styles window refreshes to show the CSS styling information for the currently selected element.

More interestingly, as you select (or hover over) elements in the Browser DOM, the current element will be highlighted in the page on your device.

Next, we will want to select elements on the device in order to change them. If we were using the desktop version of Chrome, we could do this by turning on Inspect in NetBeans Mode using the menu item provided by the NetBeans Connector for Chrome. But as Chrome for Android does not support extensions, we will do this using the Inspect Mode in the Browser toggle button at the top right of the CSS Styles window.

Once Inspect Mode is on, the interaction now works in the other direction: tap elements in the page on your device, and both Browser DOM and CSS Styles windows will be synchronized. Once we have selected the element whose style we'd like to modify, we can just do so using the bottom part of the CSS Styles window (Property sheet), and the change will be reflected live on the device. For example, this is the result of increasing the font size of the description text from 13px to 22px.

Note that this example is illustrative only - in a real world example we would likely use media queries to achieve good appearance on both mobile and desktop clients. Speaking of which, media queries (as the main tool to do responsive web design) are supported in NetBeans' visual CSS editor.

Next, we may want to debug the application. For example, to see what happens when we click on an individual item in the list of phones in our application, we will place a breakpoint on line 16 in controllers.js. But in order to tap the item, we first need to turn off Inspect Mode using the toggle button in the CSS Styles window. Then after tapping the item on your device, the IDE will stop on the breakpoint.

Now we can inspect the variables, step through the code, see the call stack, and in general use all the features of the NetBeans JavaScript debugger.

All this support will be included in NetBeans IDE 7.4, which will be released later in 2013. However, you can already try this out now in a recent nightly build of NetBeans 7.4.

The Corona SDK lets you build rich mobile apps for iOS, Android, Kindle, and Nook. The Corona SDK uses Lua as its programming language. Lua Glider has been created by M.Y. Developers LLC on the NetBeans Platform and NetBeans IDE as an advanced IDE for Corona SDK professionals and beginners alike. Lua Glider's latest release is 1.9, released 11 May 2013.

Its many features include an advanced debugger, variables explorer, call stack, adaptive auto-complete, built in documentation, real-time breakpoints, split screen support, asset preview, simulator remote, theme switcher, and much more.

YouTube has several videos on Lua Glider (previously known as Corona Cider), including this very inspiring introduction:

Further info:

http://www.coronalabs.com/products/corona-sdk/

http://www.mydevelopersgames.com/Glider/

http://forums.coronalabs.com/topic/34829-lua-glider-v-19-launch-discount-code-included/

http://www.holamariquita.com/?p=136

http://www.raywenderlich.com/22064/how-to-make-a-simple-game-with-corona

The EPUB Open Toolbox (introduced in the last two blog entries) includes a WYSIWYG editor based on the Swing HTML Editor Framework (SHEF), but extended in small ways. For example, keyboard shortcuts can be used for bold, italics, etc.

One of the holy grails of the Java desktop world, that is, WYSIWYG support, can thus be solved via SHEF. Here's the visual pane of SHEF embedded in a NetBeans TopComponent:

And, when you switch to the Source view, the above is shown as follows in the SHEF XML editor:

If I make a change to the source and switch to the view, the view is automatically updated, and vice versa.

Would be cool to replace the editor above with the NetBeans XML Editor. On the other hand, that could have disadvantages too. Not sure how that would figure on the juice/squeeze continuum. 

A new build of Praxis LIVE is now available from the usual place, with Windows (.exe) installer, zip distribution, and of course Linux (.deb) installer. This release has taken a little longer than normal to put together. A project I … Continue reading →

You could build, test and deploy the entire Java EE Application and even create a working application server from scratch with a single mvm clean install command. The only problem is: it will take forever and you will have to repeat the whole process over and over again, even if you were only interested in particular build steps.

If mvm clean install would just execute the unit tests, your feedback will be significantly faster. Instead of waiting hours, you get the first results in seconds.

A series of composable jobs, each executing a goal or maven plugin, could be realized with http://jenkins-ci.org, or a simple shell / batch script on the developer's machine.

Instead of executing all plugins at once by hooking them to the lifecycle, you could implement a series of chained together jobs. E.g.

1. Job: mvm clean install
2. Job: mvn failsafe:integration-test
3. Job: server setup
4. Job: deployment
5. Job: system test execution
6. Job: quality assurance
7. Job: promotion
8. Job: tagging / release
9. ...

The faster the feedback, the more valuable it gets. A monolithic mvn clean install leads to too long builds, less feedback and becomes less valuable for Continuous Integration. CI degrades to nightly builds…

Just start with an essential setup essential and not with a super-pom.

[See also an in-depth discussion in the "Real World Java EE Night Hacks--Dissecting the Business Tier" book, page 136 in, chapter "Continuous Integration and QA"]

See you at Java EE Workshops at MUC Airport (Effective JavaEE)!

In the absence of a WYSIWYG editor in JavaFX WebView, the SHEF project provides a fine alternative. Click to enlarge the image below.

Aside from being to generate to/from EPUB, project templates are provided for creating new EPUB 3.0 and EPUB 2.0 books:

The structure of the app is modular and Mavenized:

One thing I will do is replace all Matisse GUI Builder forms with plain Java classes, so that anyone can work on this application, i.e., in any IDE. The point is that thanks to Maven, the app can be opened in any IDE that supports Maven, but the TopComponents have been generated in NetBeans IDE, hence they use the Matisse GUI Builder forms, which are not supported in other IDEs. It will be simple to replace those with plain Java classes, since in each case the TopComponent only contains one Swing component, i.e., either a BeanTreeView or the SHEF HTML Editor.

Return to part 1...

The start of an open source EPUB editing tool in Java. Right now, you're able to open EPUB files, view their content (the JavaFX WebView is used to display the XHTML content), and even extract the content of EPUB files so that they can be edited in a new EPUB project type, prior to letting you recreate the EPUB file from the project. Click to enlarge the image below.

The Java API used to inspect EPUB files is:

http://www.siegmann.nl/epublib/

Ultimately, the aim is to replicate the EPUB functionality of Sigil and Oxygen. The sources (and binaries) will be available here on java.net (but not yet right now):

https://java.net/projects/epubopentoolbox

The application is modular on the NetBeans Platform, uses the JavaFX WebView, and is built on Maven. Is there a WYSIWYG editor based on the JavaFX WebView out there? Would be great to integrate it, instead of the bare WebView component currently used in this project. Therefore, right now, there's no editing support in the WebView, though the raw XHTML files can be edited, with the support of the standard NetBeans tools, e.g., syntax coloring, code completion, and validation.

Continue to part 2...

Jessiko is robot fish technology created by Robotswim in France. The technology was first exhibited at the French Pavilion at the 2012 World Expo in South Korea. It is currently marketed at events and for luxury decorations, such as at luxury hotels, restaurants, commercial centers, museums, and waiting rooms.

The Robotswim management software, named Jessikommand, offers robotic research teams and teachers a unique development and learning platform with access to cutting edge software and technologies. Together, the originality of an aquatic fish robot, 3D locating capabilities, and inter-robot communication make Jessiko a full and powerful system. Also, Jessiko opens the door to collaboration with biologists, thanks to its capacity to integrate with the living world.

Jessikommand is an integrated environment on the NetBeans Platform. It has been designed for trying out Jessiko features, letting you control aquatic robots, while also enabling you to display real-time status of elements such as robots and beacons:

The main features of Jessikommand are as follows:

• Transmitter control. Connect to the concentrator without any configuration.
• Direct control. Control one or more Jessiko robots using your keyboard.
• World design. Create your own “world” with robots, beacons, and remotes.
• Battery monitoring. Check batteries of active robots.
• Radar view. Check internal vision of robots
• Debug systems. Read reports from internal Jessiko variables.
• Check distance. From elements to beacons, enabling finding of nearest beacon.
• Emergency stop. Immediately disable all active elements within the beacons range.
• Intuitive GUI. You can adapt Jessikommand to your needs using its flexible GUI.
• Cross-platform. Jessikommand is available for Microsoft Windows and Linux.

More info:

http://www.robotswim.com

http://www.robotswim.com/docs/Jessiko_Lab_Technical_Description_April2011.pdf

<p> Hi all! After few weeks we would like to introduce you some new features which will be available in <strong>NetBeans 7.4</strong>. And what is it about? It's about <strong>new framework support</strong>! For <strong>NetBeans 7.4</strong> we added a support for <a href="http://nette.org" target="_blank">Nette Framework</a> with Latte Templates. </p> <p> Not sure if all of you know it, so here is an official introduction: <cite>&quot;A popular tool for PHP web development. It is designed to be the most usable as possible and is definitely one of the safest one. It speaks your language and helps you to easily build better websites.&quot;</cite> </p> <p> If you remember, we wrote about <a href="http://nette.org" target="_blank">Nette Framework</a> few months ago when <a href="https://blogs.oracle.com/netbeansphp/entry/initial_support_for_neon_file" target="_blank">we added a support for the <strong>Neon</strong></a> file type, which is a configuration file type for most of <strong>Nette Framework</strong> applications, and then once again when we <a href="https://blogs.oracle.com/netbeansphp/entry/apigen_support_added" target="_blank">introduced new ApiGen suppport</a>, which is an API generation tool based on <strong>Nette Framework</strong>. </p> <p> <strong>Nette Framework</strong> also has a great and active community, so if you have a problem, don't hesitate to ask on <a href="http://forum.nette.org/en/" target="_blank">an offical Nette Framework forum</a>! You will receive an answer in minutes ;) </p> <p> Ok, so let's look at some features :) </p> <h3>Nette Framework</h3> <p> Let's start with support of the framework part. As usual, Nette Framework has it's own <em>Options tab</em>. You can select a directory with Nette Framework sources and a directory with Nette Framework sandbox. </p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-1.png" title="Nette Framework Options Tab" /></p> <p> These both information are useful when you try to create a new project and in a framework selection step select a <strong>Nette2 Framework</strong>. Then you can decide to copy Nette Framework sources into your project and if you properly set a path to the Nette Framework sandbox directory, then it's automatically created in your new project. </p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-2.png" title="Creating Nette Framework Project" /></p> <p> We try to automatically detect whether the Nette Framework is used in your project to provide some framework specific features (such as custom <code>@persistent</code> annotation, code generator for action and render methods, or <em>Go to View</em> action), but when the detection fails (e.g. due to non-standard directory structure), you can enable whole support manually in <em>Project Properties</em>. </p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-3.png" title="Nette Framework Project Properties" /></p> <h3>Latte Templates</h3> <p> At first, what is <strong>Latte Template</strong>? If you know <strong>Smarty</strong> or <strong>Twig</strong>, then you will exactly know what it is. It's just a HTML file, with a custom extension (<code>.latte</code>), which contains some embedded parts which are &quot;somehow processed by Latte Templating engine&quot;. You can read much more in an <a href="http://doc.nette.org/en/templating#toc-latte" target="_blank">official documentation of Latte Templates</a>. </p> <p> And what we support? For example coloring (of embedded Latte parts, comments and such). But our coloring is a bit clever ;) In <strong>Latte Templates</strong>, you can switch to another Latte delimiters in one file (or in HTML element) without any problem. Just use <code>{syntax ...}</code> macro or <code>n:syntax=&quot;...&quot;</code> tag in a HTML element. NetBeans catches that and colors following source properly :) </p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-4.png" title="Latte Coloring" /></p> <p> And another great thing is code completion. It work for macros, helpers and keywords. And it works for <code>n:tags</code> too ;) </p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-5.png" title="Latte Code Completion" /></p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-6.png" title="Latte Code Completion" /></p> <h3>One more thing</h3> <p> Now all of you know, that <strong>Neon</strong> file type is a common configuration file for Nette Framework applications. It has some special sections like <code>services:</code> and such. And in these sections you will sometimes need to write some PHP types with fully qualified name (to specify factory classes and such). So it would be helpful to have some <strong>code completion</strong> in there, right? Ok, so <strong>it's there!</strong> ;) It's simple, it just lists all of PHP types from your project, but it's better then nothing, isn't it? :) </p> <p><img src="https://blogs.oracle.com/netbeansphp/resource/article_images/nette-latte-7.png" title="Neon code completion" /></p> <p> And that's all for today and as usual, please <a href="http://bertram2.netbeans.org:8080/job/PHP-build/" target="_blank">test it</a> and if you find something strange, don't hesitate to <a href="http://netbeans.org/bugzilla/enter_bug.cgi?product=php" target="_blank">file a new issue</a> (product <em>php</em>, component <em>Nette / Latte / Neon</em>). Thanks a lot! </p>

The Joint Expeditionary Collective Protection (JECP) Program is part of the Joint Program Executive Office for Chemical and Biological Defense, which is the Joint Services single focal point for research, development, acquisition, fielding, and life-cycle support of chemical and biological defense equipment and medical countermeasures.

In developing a family of transportable shelter systems, the JECP provides collective protection to joint expeditionary forces and their assets. These shelter systems range from two-person passive filtration tents to large multiperson shelters that can be combined together to provide active filtration and internal environmental conditioning.

The objective of the JECP System Performance Model (SPM) is to model the collective protection performance of each JECP shelter and predict the level of exposure to chemical and biological (CB) agents experienced by personnel inside the toxic-free area (TFA). Exposure within the TFA can occur as a result of agent infiltration through barrier materials, air locks, closures, seams, filters, and from personnel entering or exiting the TFA.

The SPM provides a cost-effective method for predicting system collective protection performance while interacting within a complex environment, allowing users to create realistic operational scenarios. Also, the SPM improves the test and evaluation (T&E) planning process by simulating results for testing environments that are otherwise too dangerous, complex, or expensive to physically test.

From Leading Edge Magazine - Chemical, Biological, and Radiological Defense, April 2012, page 157: 

The approach taken for SPM development leverages the open source NetBeans application platform. This approach allows for highly modular application development while making extensive reuse of mature software components. In developing any application that has a significant number of capabilities, there are typically a large number of “boilerplate” features that must be implemented in order to make the domain-specific capabilities accessible by the user. Many of these application components are taken for granted by most users (i.e., menus, drag and drop, cut/paste, undo/redo, open/save) but are very time-consuming to develop. The NetBeans Platform provides a large portion of these common application capabilities as reusable components. This drastically reduces the development time required to implement a new application by allowing developers to focus primarily on the domain specific capabilities instead of the "boilerplate" code.

The NetBeans Platform is an open-source framework that has been steadily maturing over the course of almost a decade. NetBeans is most commonly known as the host environment for the highly popular NetBeans integrated development environment (IDE) which, in many ways, outperforms commercial IDEs, such as Microsoft’s Visual Studio. The NetBeans Platform provides a large set of reusable software components that allow for rapid development of highly modular applications. The workflow for developing applications that leverage the NetBeans Platform is built into its IDE, which makes constructing new applications and modules very straightforward. Because of its flexibility and maturity, SPM developers chose to implement SPM capabilities on top of the NetBeans Platform, which affords a great deal of flexibility that can easily accommodate changing requirements and data structures.

The various models and capabilities that need to be managed by SPM can be nicely encapsulated inside NetBeans modules. Each module has well-defined interfaces that govern which portions of the module’s code are exposed to other modules. In addition, modules must specifically state dependencies on other application modules in order to access exposed classes. This ensures that all application dependencies can be quickly determined, thus providing better software maintainability.

Screenshots below, the first shows the JECP SPM interface and the second shows the JMAT Visualization Package:

The JMAT Visualization Package software allows analysts to "playback" a scenario in order to view how contaminants move externally and internally. This visualization, coupled with various reports and plots, allows the user to determine the overall performance of JECP shelters, air locks, and other components when faced with a variety of attacks, configurations, and environmental conditions.

The above and further info is all publicly available here:

Serious Integrated provides hardware, software, and services for front panels. The company focuses on replacing buttons with graphic touch screens. The project is moving along very well. SHIPTide, the related GUI development toolsuite on the NetBeans Platform, was published publicly in beta on the website (at www.seriousintegrated.com/docs) in October 2012 and there are dozens of customers using it.

You can layout your GUI, define events or actions, build your resource library, and create a package that you can upload to your hardware with ease:

What SHIPTide does is similar to Adobe Flash and Flash Builder, but for graphic/touch front panel hardware modules that use very low end 32-bit processors. Some of these have as little as 128KB RAM. Integrated into SHIPTide is SHIPEngine, which is similar to Adobe Flash Player, but fits in <512KB of ROM on the module. SHIPTide is the PC/MAC/Linux based tool that helps you create your GUIs. 

Features of SHIPTide:

• WYSIWYG manipulation of GUI pages.
• Automatic translation of jpg/gif/bmp/tiff/png image files.
• Automatic translation of TTF fonts.
  
• Full UTF-8 support with Multilanguage support for the target GUI, including auto-codeset-subsetting for large fontsets, such as Japanese.
• Built-in ANTLR/BNF grammar and Java-lite-like compiler for our scripting language, SHIPSail.
• Complete GUI compiler (similar to that Adobe would have to build .swf files) that combines layout, resources, compiled code, etc into a single "cargo" file that gets loaded into data-FLASH memory on the target hardware module; this is beginning to include some incremental compiler elements, for instance image compilation is cached so it only happens once.
• Built-in USB connectivity to the target hardware so you can craft/build/download/test in seconds.
• The NetBeans Platform update mechanism is leveraged.
  

Here's a picture of one of the front panel modules that is the "target" for the tool:

The above is is a 4.3" WQVGA (480x272) touch screen module. It is powered by a Renesas RX MCU running at 100MHz, and has 8MB total RAM.

There are a lot of items on the roadmap, including enhanced USB communications, better font management, some level of drag-n-drop in the GUI layout itself, better tools for managing translation(s), and live remote-debugging of SAIL scripts on the target from within SHIPTide.

More info:

http://www.seriousintegrated.com/w/index.php?title=SHIPTide

http://www.padtinc.com/blog/product-development/serious-integrated-modular-touch-screen-panels

Especially the SHIPTide video library is very nice, showing the features of the application in some detail, i.e., showing the features anyone can create in their own applications on the NetBeans Platform:

http://www.seriousintegrated.com/w/index.php?title=SHIP:Video_Training

See also other screencasts at: http://tv.adam-bien.com or subscribe to http://www.youtube.com/user/bienadam.

Thanks for watching and see you at Java EE Workshops at MUC Airport!

Project News Jelastic Announces Integration with NetBeans IDE Jelastic Inc., the creators of a cloud hosting platform for Java and PHP applications, has announced the integration of the Jelastic platform with NetBeans IDE. Full instructions are provided for getting started with the Jelastic plugin in NetBeans IDE.Legacy Sponsored:  unsponsored ...

Let's imagine we're creating simulation software. In other words, we have some kind of XML file (such as a SubSim Simulation File) and we want to process that file, i.e., use it to simulate something. What are the requirements for software that has the above (admittedly vague) description?

Well, first of all, we somehow need to open our file into the simulator or, at least, access it from the simulator in some way. Then, we need to be able to start the simulation and, once it has started, we shouldn't be able to start it again, until it has stopped. While it is running, we should be able to stop the simulation. We should show the current progress of the simulation to the user. We should also be able to run simulations on multiple files at the same time. And, finally, we should create an infrastructure that lets contributors easily plug in new simulations, since our XML files can be used as the basis of multiple different kinds of simulations, i.e., different algorithms or processors or filters need to be applied to our data and we don't know up front what all those simulations are going to be, hence we need a flexible architecture allowing for simple integration of external contributions.

OK. So, all the above is available out of the box and for free right here:

https://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.3/misc/RunStopSimulator

In other words, the above is an infrastructure for your own simulation software, which looks exactly like the below. Right now, only files with "Simulation" as the root element of the XML file are supported but all you need to do to change that is to go to line 38 of the SimDataObject class and change the root element to anything else.

As you can see, the green start button is enabled when a file conforming to the predefined root element has been opened, which can be done via File | Open File or via the Favorites window from the Window menu.

Once the simulation is running, the green start button is automatically disabled, the red stop button is enabled, and the progress bar starts up:

Multiple files can be run and stopped together:

When the red stop button has been clicked for one file, the green start button becomes enabled, but only for the file where the simulation has stopped. For the other files, which are still being handled, the green start button remains disabled.

And the architecture is clear, easy to understand, and modular:

New simulations are added to the simulator by implementing SimulationProcessor and registering it in the NetBeans service registry:

@ServiceProvider(service = SimulationProcessor.class)
public class SimpleSimulationProcessor implements SimulationProcessor {
    @Override
    public void process(FileObject fo) {
        OutputWriter writer;
        InputOutput io = IOProvider.getDefault().getIO(fo.getNameExt(), false);
        io.select();
        writer = io.getOut();
        try {
            List asLines = fo.asLines();
            for (String string : asLines) {
                writer.println(string);
            }
        } catch (IOException ex) {
        }
    }
}

The simple processor, above, does nothing more than print the lines of the XML file into the Output window. But, since you can work with the file in any way you like, i.e., from the FileObject you have access to java.io.File, you can parse it any way you like, or filter it however you need, all within a module dedicated to the specific task for which the filter/parser/algorithm exists.

Feature requests for the simulator infrastructure are more than welcome in the comments to this blog. If someone uses it as the basis of their own simulator software, that would be good to know about!

I'd like to interrupt the relentless stream of data on new NetBeans Platform applications, made possible despite the fact that everyone is supposedly only creating mobile and web apps nowadays, which has been going on consistently one per day in this blog every day for over a month, weekends included, well spotted and supported by Kevin Farnham on java.net and Yolande Poirier in "Everything on the NetBeans Platform", to briefly report on something slightly different. I recently attended JavaOne Russia in Moscow, last month, 23 and 24 April, 2013. Around 2000 attendees, approximately twice as many as last year. That statistic on its own indicates it was a great conference. I attended last year too. Clearly this year was bigger and better.

Duke's Choice Award

The big news from a NetBeans point of view (but also, of course, Java in general) was that one of the three Duke's Choice Award winners was the air traffic control system created in St. Petersburg on the NetBeans Platform. From https://www.java.net//dukeschoice/russia:

VNIIRA created an air traffic control system, consisting of dozens of Java NetBeans modules, that allows tracking of hundreds of flights using primary and secondary surveillance radars. Application features include flight tracking, conflict detection and resolution, data display from various sources, together with playback and recording of all system events and user actions. Using the modular NetBeans Platform, the team was able to compose features from multiple modules to provide the necessary functionality tailored to various roles, from flight executive officer to air traffic controller to combinations of these.

A screenshot:

I discussed this application some time ago here:

https://blogs.oracle.com/geertjan/entry/new_russian_air_traffic_control

Alexandre Teterin and Mikhail Kuznetsov, two of the key developers on the above project, were at the conference too. It was great to meet them. Afterwards, Alexandre pointed me to the link below about the news about the Duke’s Choice Award on the site of the major Russian government news agency ITAR-TASS:

http://www.itar-tass.com/c48/718928.html?utm_source=dlvr.it&utm_medium=twitter

Also, this news was cited by another official agency, INTERFAX:

http://www.almaz-antey.ru/about/press/production/1449.html

Alexandre writes: "Maybe this news will help in hotting up the attention of government (and private) enterprise management to the usefulness of the NetBeans RCP."

Some other applications in and around Russia that have been created on the NetBeans Platform include Platypus Platform, Silver Solution Studio, ObjectsX, Epictetus Database Manager, and a set of reservoir simulator applications.

Unlocking the Java EE Platform with HTML5

I led a hands on lab on the NetBeans IDE tools for creating hybrid Java EE / HTML5 applications, to a packed out room:

In general, I think everyone learnt something from the lab, they were all using NetBeans IDE 7.3, creating Java EE applications (especially using JPA and JAX-RS), and displaying the results in a an HTML5/JavaScript client:

The PDF used in the lab can be found here:

https://blogs.oracle.com/geertjan/resource/HOL1280_UnlockingJavaEEPlatformwithHTML5.pdf

And another way to attain the same result is to follow the instructions in this article:

http://jaxenter.com/from-database-to-restful-web-service-to-html5-in-10-minutes-46064.html

Strategies for Loose Coupling for the Java Desktop

Later in the conference I did a session on loose coupling in Java desktop applications, using patterns and strategies from the NetBeans Platform. Unfortunately, at the same time as my session, Paul and Gail Anderson were doing a very similar session, about the NetBeans Platform and JavaFX. Together, we had about 80 attendees, so we could have had a full room if our attendees hadn't beeen split across two sessions.

Here's an impression from my session, Alexandre Teterin was there too, he talked a few minutes about the air traffic control system that won the Duke's Choice Award. Unfortunately, I didn't take a pic of him while he was talking!

Most of the presentation was a generic introduction to the NetBeans Platform. The reasons for using the NetBeans Platform were covered, many examples were shown, and key concepts, such as "Module" and "TopComponent" and "Node" were touched on:

http://edu.netbeans.org/contrib/slides/netbeans-platform/strategies-for-loose-coupling-j1russia.pdf

I then discussed in detail a real life use case, based on Alexandre's scenario, i.e., an air traffic control system. The imaginary requirement is that an air traffic control system needs to be developed, for managing runways and their engineers, but that the implementations for our two customers, one in Moscow and the other in St. Petersburg, need to be slightly different. The imaginary Moscow airport has multiple runways, while the imaginary St. Petersburg airport only has one runway. Hence, the feature for reassigning engineers to different runways is only relevant to Moscow, not to St. Petersburg.

How to create a codebase that effectively handles the above requirements? I discussed that the starting point would be to create a RunwayFramework, i.e., a suite of modules that provide base functionality for all implementations. Next, on top of that basis, two applications, one for Moscow, one for St. Petersburg, can be created. Each runway (with imaginary names such as "Pushkin") is defined within its own module and loaded into the system at runtime, so that the application can be extended via modules, either at design time or runtime.

The above structure is visualized as follows in the IDE:

And here's the Moscow implementation, each top node in the Runway Viewer showing the available runways, with their engineers, together with a button in the toolbar that is highlighted when an engineer is selected, so that the selected engineer can be reassigned to another runway. Clicking on a runway shows the runway (in the prototype below, each runway is simply an image of course):

Next, here's the St. Petersburg implementation, which only has one runway, hence there's no button in the toolbar (other than the Save button, which is there too in the Moscow implementation) for reassigning engineers to runways:

A few people have expressed an interest in playing with this code and adapting it to other purposes. Here each of the above can be found and downloaded:

https://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.3/misc/RunwayFramework

https://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.3/misc/MoscowATC

https://java.net/projects/nb-api-samples/sources/api-samples/show/versions/7.3/misc/PetersburgATC

In addition to the above, I attended sessions on JavaFX (by Steve Chin and Jim Weaver), as well as a Steve Chin session on the Raspberry Pi. Good times with Paul and Gail Anderson, in particular, too, wandering around a very tall shopping mall on the last night especially.

And, finally, I spent a lot of time at the Tretyakov, I especially liked the collection of late 19th century Russian paintings.

In short, JavaOne Russia was great, I really enjoyed it, great to be in Moscow, and I met a lot of cool Java developers at the same time.

Elster is worldwide market leader and specialist in Flow Measurement & Control Equipment and Systems focused on gas.

enSuite is software created by Elster on the NetBeans Platform for parameterization and maintenance of new Elster meters, such as the EK280 volume converter, flow computer FC1 and ultrasonic meter Q.Sonic-plus. 

More info:

Eurostat is the statistical office of the European Union, situated in Luxemburg. Its task is to provide the European Union with statistics at European level that enable comparisons between countries and regions. 

There are a large number of storage systems at Eurostat, created based on the specific needs of a particular time. Some are very simple, while others are real databases. Generically, Eurostat is organized per type of data, each is called a "domain". There are domains for agriculture, for finance, for unemployment, and so on. Each of them can be seen as a data warehouse, that is, data is collected from countries, checked, stored in a domain, statistical data is created, and then published on the Eurostat site. At Eurostat, many different systems of this kind exist to store and process data. Streamlining and simplifying access to data is a significant challenge in this context.

IsForStat is a system that has been created internally at Eurostat, based on the NetBeans Platform, as a centralized mechanism to provide access to data. Its aim is to standardize access and working methods of Eurostat data users. It enables users to work with a unique and generic tool that is not specialized on a particular database. In that number, many are built on Excel and are very light, while there are also large systems that are more or less deprecated, but are very difficult to evolve due to user force of habit. Therefore, aside from enabling standardized access to data, IsForStat will make it possible for Eurostat to migrate older backend systems to newer ones, without its users being impacted.

The modularity offered by the NetBeans Platform enables services to be added without compromising existing source code. The possibility for a database to dynamically install menus and commands that are specific to that database inside the client, allows standardization of the client. Encapsulation queries enable the system to see a database as a resource, and to standardize access. Via IsForStat, access to mission critical databases at Eurostat, such as Fame (time series and formulas) and Eurocube (Oracle OLAP system), is given, providing a modern application built on the principle of organized desktop areas.

The IsForStat solution, in addition to using the NetBeans Platform as its front end and integration framework, uses Oracle WebLogic too, as part of its solution to integrate systems that are usually built on Oracle technologies. Aside from Oracle OLAP, technologies used include Oracle 10 and other systems usually based on Oracle or Sungard Fame.

AVERT by the ARES Corporation is a 3D security optimization software on the NetBeans Platform for visually depicting, analyzing, and optimizing physical security. It measures security investment costs, evaluates the effectiveness of existing and planned countermeasures, and allows you to make the most of your existing or planned security budgets.

AVERT is the only security optimization software to receive a Department of Homeland Security SAFETY Act Certification, providing additional liability coverage to AVERT’s customers. It provides repeatable, validated, and proven metrics to assess threats and vulnerabilities and increase overall security system effectiveness.

More info:

http://www.arescorporation.com/security/products/avert/

Let's list the many ways to introduce Anton Epple: NetBeans Platform consultant, trainer, developer and author; a blogger; a NetBeans Dreamteam member and recent Java Champion. It's an already impressive profile, yet there's more. Over the years, he has also steadily carved out a niche for himself as a conference organizer. He got his start hosting annual NetBeans Day events in Munich for local...

Podcast Guests: David Konecny, Tushar Joshi, Atul Palandurkar Download mp3: 36 minutes – 29.4 MB Subscribe on iTunes Preview Text:  Podcast Guests: NetBeans senior engineer David Konecny on HTML5 support in NetBeans 7.3; Tushar Joshi and Easy Flow Chart, an open source project using NetBeans' HTML5 support; and a new NetBeans IDE ebook by...

ScreeningAssistant 2 is a free and open-source application on the NetBeans Platform that can be used to perform various simple as well as advanced chemoinformatics analysis around chemical libraries.

The application complements the growing ecosystem of modeling tools by providing a set of chemoinformatics facilities integrated in a database environment. It facilitates the management of chemical libraries through an intuitive and interactive graphical interface and provides a set of advanced methods to analyse and exploit their content.

More info:

http://sa2.sourceforge.net/

http://www.jcheminf.com/content/4/1/20

http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3547782/

With the Process Designer by Consol, you can constantly optimize your business processes. Whether individually based on your needs or on the basis of best practice workflows from over 10 years of project experience, this NetBeans Platform application is a tool for workflow modeling: