<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>Healthcare Quality Assurance Application on the NetBeans Platform</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <link type="text/css" rel="stylesheet" media="all" href="../../../netbeans.css" />
  </head>
  <body>
    <h1>Healthcare Quality Assurance Application on the NetBeans Platform</h1>
    <p>By <em>Geertjan Wielenga</em></p>
    <p> </p>
    <p><img src="../../../images_www/articles/healthcare/javier.png" style="float:right" alt="Javier"/>One
      area where the NetBeans Platform, the world's only modular Swing
      application framework, is well suited is as the basis of an
      enterprise's internal quality testing tools. In
      <a href="http://netbeans.dzone.com/news/chip-validation-applications">Semiconductor
        Validation Engineering on the NetBeans Platform</a>
      , you can read how engineers at
      <a href="http://www.pmc-sierra.com/">PMC Sierra</a> 
      have created Swing applications on the NetBeans Platform to validate
      PMC Sierra's semiconductor products. A similar thing is done at
      <a href="http://www.bbraunusa.com/">B. Braun</a>,
      a healthcare product provider. </p>
    <p>One of the devices made by B. Braun is
      <a href="http://www.bbraunusa.com/index-FBD7BF3B65B05CD0DC2612AD482AD6D9.cfm?uuid=FBD7BF3B65B05CD0DC2612AD482AD6D9">Outlook
        Safety Infusion System</a>, which helps to ensure that
      "the Right patient receives the Right medication in
      the Right dose from an authorized clinician at point-of-care".
      This is what the device looks like:</p>
    <p><img src="../../../images_www/articles/healthcare/outlook400.jpg" alt="Outlook" /> </p>
    <p>Below,  we meet Javier Ortiz from B. Braun, who is in charge of developing
      tools for quality testing of healthcare devices such as the above. </p>
    <p><b>Hi Javier who are you and what do you do?</b>
    </p><p>I'm a software and power engineer from Juncos, Puerto Rico, and
      work as a software quality engineer for BBraun in Carrollton Texas. I
      love wrestling to the point that I've practiced it for a while, love
      video games, and programming is my hobby! Among my software quality
      related tasks, I'm in charge of developing tools for testing purposes,
      perform code reviews, and analyzing programming issues.
    </p><p><b>So, you work in quality assurance in the healthcare industry. What
        kind of software applications are typically required in this area?</b>
    </p><p>Healthcare industries have many requirements due to FDA
      regulations. They use a lot of data gathering software and databases,
      document management systems, training management systems and, as in my
      case, some development tools.
    </p><p>In other instances they want to use open source applications that
      don't comply with FDA regulations. In my case, I joined
      <a href="http://www.xinco.org/">Xinco</a> 
      (more info on that later in this interview) and added
      the <a href="http://www.21cfrpart11.com/">21 CFR part 11</a> 
      functionality to it. After validation, I gave Baxter, my employer at
      the time, a document management system, got the Xinco project to the
      next level, and became its lead programmer on the process.
    </p><p><b>Let's now look at your work at B. Brain.
        There you work on the Outlook ES Interface Tester. What is that exactly?</b>
    </p><p>Outlook ES Interface Tester (OIT for short) is a test framework
      for interfaces of our device the Outlook ES. As part of my duties as
      quality engineer I need to figure out how to test that all requirements
      are met by our product before it is released to the public. Among those
      requirements are communication protocols and data transfer that can be
      too technical for a technician to test.
    </p><p>OIT provides an user friendly GUI to "see" those protocols and
      data transfers, providing parsing and visual aids to ease the
      validation process.
    </p>
    <ul><li>For example, the HIMS module simulates a HIMS system as
        used in hospitals to send data to the medical device for configuration.
        Also parses the outbound data used to collect stats of multiple devices
        within a hospital.
      </li><li>The PCEIS module provides similar testing functionality between
        the device and its configuration software.
      </li><li>The CMAIS module (work in process) provides similar
        functionality between the device and a Configuration Management
        Application to handle configuration of the devices wirelessly.
      </li></ul>
    <p>All huge parts of our device! Here's a screenshot of OIT:</p>
    <p><a href="http://netbeans.dzone.com/sites/all/files/1-javier-import-configuration.png"><img alt="" src="../../../images_www/articles/healthcare/1-javier-import-configuration_small.png" style="border: 1px solid rgb(14, 27, 85);" /></a></p>
    <p><b>When did you start creating it and what were the requirements?</b>
    </p><p>The first tool, HIMS (Health Information Management System),
      started development in 2008 as a Swing based application. The aim was
      simply to provide a visual way of seeing the interaction between
      systems and verify all formatting and data requirements of the defined
      protocol were met at all times.
    </p><p><b>How does the NetBeans Platform help in this scenario?</b>
    </p><p>In time, other interfaces were added to the system and more
      tools like the HIMS were needed. As a regulated environment all
      software, and changes to those softwares, come with a huge amount of
      documentation to comply with FDA regulations. Also, the new interfaces
      would have code that would be shared somehow.
    </p><p>The NetBeans Platform provided a way to merge all those
      applications (and any future ones) as modules into one application.
      Also, many GUI issues I encountered in the early Swing applications
      were already elegantly solved by the NetBeans Platform, so migrating to
      it fixed a lot those issues as well!
    </p><p>Another screenshot:</p>
    <p><a href="http://netbeans.dzone.com/sites/all/files/5-javier-parse-validate.png"><img alt="" src="../../../images_www/articles/healthcare/5-javier-parse-validate_small.png" style="border: 1px solid rgb(14, 27, 85);" /></a> </p>
    <p><b>Do you have some tips and tricks to share with other NetBeans
        Platform developers (maybe an interesting code snippet)?</b>
    </p><p>I found a cool trick in one of the other projects I have (see
      next question) to do database backups using JPA and Derby. This will be
      part of Xinco 3.0 when is released.
    </p><p>To explain the code a little here's a brief:</p>

    <p><u>Assumptions:</u></p>
    <ol><li>You have a database accessed via JPA (all tables).
      </li></ol>

    <p><u>Steps for backup:</u></p>
    <ol><li>Create an Embedded Derby database in a specific path (setting System property
        "derby.system.home" to the desired path).
      </li>
      <li>Retrieve each entity from each table.
        (Remember to lock the database before doing this to avoid further modifications.)</li>
      <li>Detach each entity and persist it into the backup Derby database.</li>
      <li>Perform a 100% comparison of records transferred to check integrity.</li>
      <li>ZIP the Derby database with a timestamp name.
      </li></ol>
    <p><u>Steps for loading:</u></p>
    <ol><li>Create a backup of the current database, just in case something
        goes wrong so we can get back to the original state.</li>
      <li>Clean the target database.</li>
      <li>Retrieve each entity from each table. (And we need to lock the
        database before doing this to avoid further modifications.)</li>
      <li>Detach each entity and persist it into the backup Derby database.</li>
      <li>Perform a 100% comparison of records transferred to check integrity. </li></ol>

    <p>(See attachment <a href="http://netbeans.dzone.com/sites/all/files/XincoBackupFile.java">one</a>
       and <a href="http://netbeans.dzone.com/sites/all/files/XincoBackupManager.java">two</a>
       for the related code.) </p>
    <p><b>Are there other things you're doing with the NetBeans Platform? </b></p>
    <p>I'm working on converting <a href="https://sourceforge.net/projects/xinco/">the
        client of the Xinco application</a>  into a NetBeans Platform application.
      See this screenshot of the current non-RCP application:</p>
    <p><img src="../../../images_www/articles/healthcare/non-rcp_small.png" style="border: 1px solid rgb(14, 27, 85);" alt=""/> </p>
    <p>Also I'll also be using the NetBeans Platform
      <a href="https://sourceforge.net/projects/jwrestling/">in my online game</a>
       as soon as I get out my first alpha version. Below are some screenshots of it so far. </p>
    <p>Game chat room:</p>
    <p><img src="../../../images_www/articles/healthcare/jwrestling_small.png" style="border: 1px solid rgb(14, 27, 85);" alt="" /> </p>
    <p>Main screen:</p>
    <p><img src="../../../images_www/articles/healthcare/mainscreen_small.png" style="border: 1px solid rgb(14, 27, 85);" alt="" /> </p>
    <p>Game screen:</p>
    <p><img src="../../../images_www/articles/healthcare/gamescreen_small.png" style="border: 1px solid rgb(14, 27, 85);" alt="" /> </p>
    <p><b>Please finish this sentence: "If I had known..."
      </b></p><p>If I had known the power of the NetBeans Platform back when 
      I started with Java, I would have used it from day one!</p>
    <p><b>How useful is the NetBeans IDE for both your work and hobby?
      </b></p><p>When I first got started with Java I did so on NetBeans IDE
      5.0. I did try other IDEs like Eclipse but they turned out to be too
      complicated for me. NetBeans IDE was and still is the most user
      friendly, natural way of programming, from your first "Hello World"
      program to a complex application. Probably I wouldn't be where I am at
      right now if NetBeans IDE had not been around all this time.
    </p><p><b>Anything else you want to share?</b>
    </p><p>To all those beginner programmers out there I'd like to say that
      the best way to learn is to see the code of how things really work. So,
      if you are struggling: join an open source project and you won't
      believe how far you'll go! I went from a Java newbie reading "Java for
      Dummies" to a recognized programmer in Germany with the Xinco project
      and the modifications I made to it to comply with the 21 CFR part 11
      regulation:</p><p><img src="../../../images_www/articles/healthcare/xinco_pc-praxis.PNG" alt="" /> </p>
    <p>&nbsp;</p><p>And don't stop at Java. After Java go to JavaFX, JavaME, Ruby, etc.
      Stay as up to date as possible!
    </p><p>
      It is amazing to look back to that summer of 2006, after graduating
      from college, just with my college theory, college experience in C++,
      my love for wrestling, and programming that made me dive head first
      into Java. With the great community and online documentation, I've been
      to places I never dreamt of and I know this is just the beginning! </p>
    <p>&nbsp;</p><p>&nbsp;</p>



  </body>
</html>
