<html>

<head>
<title>It Takes a Community to Write Good Software</title>
<meta name="DESCRIPTION" content="How do community members and the NetBeans team work together?">
<meta content="Ruth Kusterer" name="AUTHOR">
<link rel="stylesheet" type="text/css" HREF="../../netbeans.css">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
  <h1>It Takes a Community to Write Good Software</h1>

      <div class="trail-box half-width" style="float:right">
         <div class="trail-box-header">
            <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right">
            <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left">
            <h1>What's in it for me?</h1>
         </div>
         <div class="trail-box-content">
  Our contributors have earned various rewards: Peer recognition, special edition t-shirts,
  USB memories, gift vouchers, LinkedIn recommendations and even job offers.
         </div>
         <div class="trail-box-bottom">
            <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right">
            <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left">
         </div>
      </div>
  <p>
    Looking back to 2005, the NetBeans community has grown significantly:
    The number of active users doubled each year for the past 3 years,
    the IDE has been downloaded over 20.5 million times,
    we have shipped more than 225,000 NetBeans Starter Kits on CDs & DVDs,
    and over 550,000 users from over 130 countries communicate on the NetBeans mailing list.
  </p>
<p><img src="../../images_www/articles/jirka-kovalsky.png" style="float:left;margin-right:10px" alt="Jiri &quot;Jirka&quot; Kovalsky" 
    width="110" height="159"/></p>
  <p>
    How do community members and the <a href="https://netbeans.org/community/teams/">NetBeans 
    teams</a> work together? 
    The Dream Team is an international group of highly skilled
    NetBeans users and contributors acting as 
    a liaison between users, partners, contributors, and engineers.
    The team members work on several self-assigned
    <a href="http://wiki.netbeans.org/NetbeansDreamTeamIdeasAndProjects">hobby projects</a>
    that range from writing magazine and blog articles about the NetBeans IDE,
    to providing user support in forums, or implementing new features as modules.
  </p>
<div style="float:right;width:200;padding:0 0 0 10px;font-size:110%;color:gray"><p>A liaison between users, partners, contributors, and engineers.
</p></div>
  <p>
    Jiri Kovalsky is Sun Microsystem's technical manager for the NetBeans community.
    He is not only the contact person for the NetBeans
    <a href="http://wiki.netbeans.org/NetBeansDreamTeam">Dream Team</a> but also for many activities like
    the NetBeans <a href="https://netbeans.org/grant/">Innovators Grant</a> contest.
    To the community, Jiri is probably best known for coordinating the 
    <a href="http://qa.netbeans.org/processes/cat/65/index.html">NetCAT</a> quality program.
  </p>
  <p>
  Being a member of the Dream Team is only one example how you can be part of your favorite Open Source project. 
  We asked Jiri to look back on the last few months and tell us more about
  the developers and partners that offered their skills and volunteered
  to do quality testing of the IDE and plugins, or to moderate mailing lists and forums.
  </p>


<h2>Public Quality Testing: The NetCAT Program</h2>

<div style="float:right;width:200;padding:0 0 0 10px;font-size:110%;color:gray"><p>Real users working with real projects.</p></div>
    <p>
      Many community members regularly volunteer for the
      NetBeans Community Acceptance Testing program, better known as NetCAT.
      NetCAT participants use daily builds and provide early feedback.
      Their reports are very valuable because they are real users working
      with real projects.
    </p>
    <p>
      For example during NetCAT 6.0, 1362 users filed a total of 6350 bug reports.
      60 of them were NetCAT participants, 273 were Sun employees, and 1029 were other community members.
      As you can see, although only 4% of reporters were NetCAT participants,
      they detected 10% of all issues.
    </p>
<div style="float:right;width:200;padding:0 0 0 10px;font-size:110%;color:gray"><p>The quality acceptance survey determines the "go" or "no go".
</p></div>
    <p>
      Additionally, NetCAT participants get the opportunity
      to be the first to try out new documentation and to test freshly released plugins.
      This year the team already tested the new Eclipse Projects Importer plugin,
      validated tutorials for NetBeans 6.1,
      or they reviewed questions that will be used in the Sun Certified NetBeans IDE Specialist exam.
    </p>
    <p>
      After the testing period is over, NetCAT participants fill in the
      quality acceptance survey.
      The outcome of the survey determines whether the release build
      is given a "go" or "no go". Interested in joining? Learn more from the
      <a href="http://qa.netbeans.org/processes/cat/65/faqs.html">NetCAT program FAQ</a>.
    </p>

<h2>Community Partners: Compatibility Testing</h2>

    <p>
      NetBeans Community Partners are companies or open-source communities
      who endorse NetBeans as a development environment and/or application platform.
      Community Partners may contribute code to the NetBeans code base,
      or they promote NetBeans by giving presentations,
      including it in training, or writing articles or books.
    </p>
<div style="float:right;width:200;padding:0 0 0px 10px;font-size:110%;color:gray"><p>Two issues identified and fixed, no show-stoppers detected.
</p></div>
    <p>
      In March 2008, the NetBeans engineers invited all community partners to a series of
      <a href="http://wiki.netbeans.org/BackwardCompatibilityTesting">backward compatibility tests</a>.
      These tests are designed for developers to verify
      that their product is still compatible with the next version of the NetBeans API.
      Four partners published their <a href="http://wiki.netbeans.org/NB61BackwardCompatibilityTestingReport">test
      results</a> for NetBeans IDE 6.1.
      All in all, two issues could be identified and fixed due to the test,
      no show-stopper incompatibilities were detected.
    </p>
    <p>
      Interested in taking part in the next compatibility test session?
      You too can <a href="https://netbeans.org/community/partners/howto.html">become
      a NetBeans Community Partner</a> and tap into one of the largest development communities.
      If you have questions or feedback about being a NetBeans partner,
      contact the <a href="http://tinyurl.com/3t892t">nb-partner program team</a>.
    </p>

<h2>Plugin Verification</h2>

    <p>
      Over the last year, NetBeans developers contributed over 350 plugins to
      the NetBeans <a href="http://plugins.netbeans.org/">plugins portal</a>. 
      The owner can request that his plugin be added to the 
      <a href="http://wiki.netbeans.org/FaqPluginUpdateCenter">Portal Update Center</a>,
      so it can be installed via the IDE's Plugin Manager.
      But often contributors have no means of testing plugins under realistic conditions,
      such as different operating systems or IDE versions.
      To avoid publishing untested plugins on the Update Center,
      Jiri found eight users volunteering to verify new plugins.
    </p>
<div style="float:right;width:200;padding:0 0 0 10px;font-size:110%;color:gray"><p>Community members evaluate which portal plugins become available via the Plugin Manager.</p></div>
    <p>
      The plugin verifiers install plugins of unknown quality on different operating systems and JDKs,
      and rate them. As part of the verification process,
      they check for bugs, exceptions and broken dependencies
      as well as performance degradation, freezes or crashes.
      They also make certain that the license text is complete,
      that features correspond to the description,
      and that the user experience is smooth.
    </p><p>
      Only if a majority of verifiers gives their OK, and no verifier disagrees,
      the plugin passes the test and becomes available via the Plugin Manager.
      If one verifier reports a serious problem (such as the plugin crashing the IDE),
      the plugin is rejected.
      The plugin owner is informed of the status and
      asked to fix the bug before he can request verification again.
    </p>

<h2>Mailing List Moderation</h2>

<div style="float:right;width:200;padding:0 0 5px 10px;font-size:110%;color:gray"><p>High-traffic support lists are open to questions from anyone, but at the same time remain spam-free. 
</p></div>
    <p>
      Jiri can also report a fourth successful project:
      The main netbeans.org mailing lists are now fully moderated.
      This means that incoming messages from unsubscribed users
      are approved manually to allow them to post, and at the same time,
      spam messages are sorted out.
      That's a lot of work for the list owners!
    </p>
    <p>
      Jiri wanted to improve this process and approached some community members for help:
      He found five volunteers who agreed to moderate incoming messages.
      They live in different timezones, and each of them checks only
      a small set of incoming messages every day, but
      the work load is distributed to a tolerable amount.
      Thanks to this successful team effort, high-traffic 
      <a href="https://netbeans.org/community/lists/">support lists</a> 
      are open to questions from anyone, but at the same time remain spam-free.
    </p>
  </ul>

  <P>Thanks to all community members who contribute to the NetBeans project! You rock!!</P>

<h2>Related Links</h2>
  <ul>
    <li><a href="http://qa.netbeans.org/processes/cat/65/">NetBeans IDE 6.5 NetCAT program overview</a></li>
    <li><a href="https://netbeans.org/community/articles/backward-compatibility-testing.html">NetBeans API backward compatibility testing</a></li>
    <li><a href="http://wiki.netbeans.org/FaqCanIHelpModerate">Support Mailing list moderation</a></li>
    <li><a href="http://wiki.netbeans.org/FaqPluginUpdateCenter">All about the plugin verfication process</a></li>
    <li><a href="http://wiki.netbeans.org/NetBeansDreamTeam">The NetBeans Dream Team</a></li>
  </ul>
</body>
</html>
