<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xml:lang="en" xmlns="http://www.w3.org/1999/xhtml" lang="en">
  <head>


    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>Interview: Modular Thesaurus Analysis Software on the NetBeans Platform</title>
    <meta name="author" content="Geertjan Wielenga" />
    <meta name="description" content="Interview with Kai Eckert who develops Semtinel,
          an application framework for the semi-automatic creation, maintenance and analysis
          of hierarchical concept schemes (thesaurus, classification or ontology).
          Semtinel is built on top of the NetBeans Platform." />
    <link href="../../../netbeans.css" rel="stylesheet" type="text/css" />
  </head>
  <body>

    <h1>Interview: Modular Thesaurus Analysis Software on the NetBeans Platform</h1>

    <p>Published on <a href="http://netbeans.dzone.com/thesaurus-analysis-on-netbeans-rcp">NetBeans Zone</a>
      by <em>Geertjan</em>, <em>2010/03/26</em></p>

    <p>
      <img alt="Kai Eckert"  src="../../../images_www/articles/interviews/thesaurus-analysis/7a80b96dc5.jpg" align="right" />
      <em>Kai Eckert is a subject specialist for math and
      computer science at the University Library Mannheim. He is a computer
      scientist and before his work for the library he was a researcher
      at the Chair of Artificial Intelligence at the University of Mannheim.
      During this time, he started the development of Semtinel,
      which is the subject of this interview.</em>
    </p>

    <h2>Hi Kai, what is Semtinel and how did you get started developing it?</h2>

    <p>Semtinel
      is a research prototype for the analysis of thesauri in order to
      support their semi-automatic creation, modification, and maintenance.
      Thesauri and other hierarchical concept schemes, like taxonomies, are
      widely used in the library field to classify and describe the subject
      of resources (like books). The maintenance of these thesauri is
      cumbersome and time-consuming and questions about the quality of a
      thesaurus and its suitability for a specific purpose are not easy to
      answer.
    </p><p>
      To answer such questions was my motivation to think
      about new ways for the analysis and visualisation of thesauri and
      finally to develop Semtinel.
    </p>
    <p><a href="http://netbeans.dzone.com/sites/all/files/semtinel_0.png"><img alt="Semtinel screenshot"
          src="../../../images_www/articles/interviews/thesaurus-analysis/semtinelSmaller_0.png" /></a></p>

    <p>&nbsp;</p>

    <h2>What are the main problems Semtinel tries to solve and how is it unique?</h2>
    <p>
      Semtinel,
      while definitely being a research prototype, is an extendable
      framework, that allows the import of data (thesauri, documents, and
      links between both) in various formats and provides several
      visualisations and statistical analyses that can interactively be
      combined by the user. It is also possible to develop new visualisations
      or analyses. We try to keep the interface and the framework as simple
      and intuitive as possible, focused on our specific tasks.
    </p><p>
      Some of the functionality is comparable to similar frameworks, like
      <a href="http://protege.stanford.edu/">Protege</a>
      for ontologies. But Protege, for example, is very complex and uses a
      more general approach.
    </p>

    <h2>How did you decide to base this application on the NetBeans Platform?</h2>

    <p>The
      very first prototype of Semtinel was actually developed in C# using the
      .NET framework. After the first successful presentations of the
      prototype at conferences, I thought about a clean reimplementation.
      During this time, I decided to switch to Java, mainly due to the fact
      that much more (open source) software in the research community is
      based on Java and more researchers, including our own students, are
      used to it.
    </p><p>
      For me, it was clear that I had to use a rich client
      platform for further development, as my first prototype already was too
      complex and otherwise I would have needed too much time for the
      development of the actual user interface.
    </p><p>
      The decision between
      Eclipse and NetBeans was not so easy. I had some experiences with
      Eclipse RCP and used the Eclipse IDE for years. To make a long story
      short, the reasons for the NetBeans Platform were:
    </p>
    <ul><li>
        I had NO experience with the NetBeans Platform (usually a bad reason,
        but a good one, if you are curious...).
      </li><li>
        100% Swing based (arguable, if this is an advantage, but I liked it).
      </li><li>
        And
        finally and most important: the very good graphical GUI editor. Almost
        as good as Visual Studio and the lack of such a (free) editor in
        Eclipse was always a pain for me.
      </li></ul>
    <p>
      Of course, I checked by
      feature comparison, a lot of reading and some tests, that the NetBeans
      Platform is as powerful as Eclipse RCP and that there is no major
      drawback. My conclusion here was that there is no better or worse, both
      seemed to be very good and stable. That's why I based this far reaching
      decision on the abovementioned minor points.
    </p>

    <h2>What are 3 ways in which you have benefited from the NetBeans Platform?</h2>

    <ol><li>
        Easy implementation of all these things that are usually "forgotten" in
        software implemented by researchers: background tasks, progress bars,
        menus...
      </li><li>
        The NetBeans Platform influenced the way I developed
        Semtinel. It encouraged (or forced, but that sounds negative) a
        consequent modularization which kept the code manageable. The
        modularization is especially great for Semtinel because we have
        students who develop their own modules as part of their theses. This
        way, they do not disturb the main development of the application.
      </li><li>
        Umm, I just like it, does that count?&nbsp; :-)
      </li></ol>

    <h2>Was there anything that pleasantly surprised you about the NetBeans
      Platform while you were working with it?</h2>

    <p>Nothing
      special, rather a lot of small things. In general, I found it very
      pleasant that after a (not so hard) learning phase, the development was
      really straightforward and fast. So I definitely saved a lot of time
      in the long run by using the NetBeans Platform, even if it needed some
      investment at the start.
    </p>
    <h2>Anything that could/should be improved about the NetBeans Platform?</h2>
    <p>
      The main thing: incremental builds! That is something that is definitely
      better solved in Eclipse. I know, it is due to Ant and using Ant has a
      lot of advantages. But I admit, I am a "small change, compile, test,
      small change, compile, test" developer and then it is really annoying.
      Module reloading and using a module suite on top of the Semtinel core
      modules helps sometimes, but not always.
    </p>

    <h2>Do you have a few
      tips (e.g., code snippets or hidden features) that you think other
      NetBeans Platform developers should definitely know about?</h2>

    <p>
      I developed a quick and dirty NetBeans Update Center in PHP and described it here: 
      <a href="http://blog.kaiec.org/2009/07/17/nbmcenter/">http://blog.kaiec.org/2009/07/17/nbmcenter/</a>
    </p><p>
      For
      me, this is very useful, as my students can just upload their new
      modules and distribute them this way to other students.
    </p>
    <p><a href="http://blog.kaiec.org/2009/07/17/nbmcenter/"><img alt="students can upload and distribute modules"
            src="../../../images_www/articles/interviews/thesaurus-analysis/nbmcenter.png" style="border: 1px solid ;" /></a></p>
    <p>
      I need no
      special infrastructure other than a PHP enabled webserver. And as much
      as I like Java, usually there is no application server running on
      university department servers.
    </p>

    <h2>What's the future of the application and can the open source Java community contribute in some way?</h2>
    <p>
      Currently
      we are (still) working on a release version for the interested public.
      But anyone who is already interested can get a current version of
      Semtinel and the source code. I hope that the development will go on,
      it mainly depends on researchers and motivated students who are willing
      to do their research with it. I talked to several libraries who
      maintain thesauri and who are willing to test Semtinel and give me some
      feedback. The ultimate goal of course would be a user community who
      indeed uses Semtinel in a productive environment.
    </p>
    <h2>Anything else you'd like to add?</h2>
    <p>
      I would like to thank the developers and users of NetBeans who gave me
      this great piece of software, as well as the necessary knowledge how to solve
      my problems, whenever I searched for it on the web. And more than one
      time I found a solution on your <a href="http://blogs.sun.com/geertjan">blog</a>,
      so I also want to thank you personally for your efforts.
    </p>
    <h2>Thanks Kai and all the best with the ongoing work on Semtinel!</h2>

    <p>Learn more:</p>
    <ul>
      <li><a href="http://www.semtinel.org/">Semtinel Homepage</a></li>
      <li><a href="http://sourceforge.net/projects/semtinel/">Semtinel on Sourceforge/</a></li>
    </ul>

  </body>
</html>