<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <title>Publishing The NetBeans Newsletter</title>
  <link rel="stylesheet" type="text/css" href="../../../netbeans.css">
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<h1>NetBeans Newsletter Publishing Guidelines</h1>
<p>This page is intended as a resource for NetBeans Newsletter Editors
and Contributors, and contains guidelines on the preparation and
distribution of
the <a href="index.html">newsletters</a>.
For additional guidance, visit the <a href="archive.html">Newsletter
Archives</a> and view previous issues.
</p>
<h2>Newsletter Schedules</h2>
The NetBeans Weekly Newsletter is published on Mondays, latest 6pm CET,
with the exception of issues delayed to include information about major
product releases scheduled for Mondays PST time. Localised editions are
published a day or two after the English issue. Current language
editions include <a href="index_pt_BR.html">Portuguese</a>.<br>
<br>
The Edge, the monthly newsletter, is currently defunct.<br>
<br>
<h2>Content &amp; the Newsletter Tool<br>
</h2>
The newsletter is prepared and published using the <a
 href="http://netbeans.info/appl2/?mod=newsletter_admin">Newsletter Tool</a>.
(For login access, please contact the <a
 href="../../../about/contact_form.html?to=1">webmaster</a>.)<br>
<br>
The editor gathers content by selecting items from the NetBeans site,
searching external sites (such as <a href="http://planetnetbeans.org/">PlanetNetBeans</a>)
for NetBeans-related content, and by sending out a content call to a
mailing list of contributors on Fridays, with a submission deadline of
Monday, 1pm CET.<br>
<br>
Contributors can email their items directly to the editor, or
alternatively, use the newsletter tool to submit their items and to
check the stats of their respective entries. Regular contributors are
encouraged to use the tool as it allows them to submit entries at any
time. (For login access, please contact the <a
 href="../../../about/contact_form.html?to=1">webmaster</a>.)
<br>
<br>
All submitted content (via the newsletter tool or email) should include
a title, a referring link and a <span style="font-weight: bold;">detailed</span>
summary of no less than two sentences. Images (110 x 110 pixels) are
optional. Check <a href="index.html">recent editions of the Newsletter</a>
to see examples of typical entries.<br>
<br>
Contributors with "user" rights can submit entries, while editors
with "admin" rights can additionally review, edit and approve
entries
submitted by other users.
<br>
<br>
If a submitted entry is unclear or contains inadequate information, the
editor should/will contact the contributor and ask for more details.
The editor may decide not to use all contributed entries for a current
issue, and instead reserve them for future ones.<br>
<br>
<h2>Formatting the Newsletter<br>
</h2>
The ideal length for the newsletter is 10 - 12 items. The
newsletter
tool offers categories for entries, of which the following six are the
most commonly used:<br>
<br>
<ul>
  <li>Articles - Stories about the NetBeans IDE, press and
reviews,
interviews with users and companies developing with the NetBeans IDE
and Platform<br>
  </li>
  <i><i> </i></i>
  <li>Blogs - Entries that offer useful information about NetBeans such
as IDE tips &amp; tricks and work-arounds, project updates, and event
review<br>
  </li>
  <li>Calendar - NetBeans events, conferences, chats and webinars<br>
  </li>
  <li>Community - NetBeans podcasts, stories about community
members,
community news and more<br>
  </li>
  <li>Project News - Product releases, contests, module
developments
and bug fixes<br>
  </li>
  <li>Training - Tutorials and screencasts (sometimes includes
blog
entries)<br>
  </li>
</ul>
Editors should strive to make the entries concise, detailed and
typo-free. Humor (clean and audience appropriate, please) is highly
welcome! While a newsletter issue is not required to have entries for
all six categories, it is recommended that it contain at least two
tutorials and two blog entries.<br>
<br>
<h2>Publishing</h2>
<ol>
  <li>In the newsletter tool, preview the newsletter (HTML
version),
check for typos and make sure the links work.<br>
  </li>
  <li>Hit the "Publish" button. </li>
  <li><a href="../../../about/contact_form.html?to=1">Ask the
webmasters</a> to approve the issue.</li>
  <li>After the webmasters approve it, the issue will be <a
 href="index.html">published to the NetBeans site</a>, and delivered to
the appropriate mailing list.<br>
  </li>
</ol>
<h2>Translating the NetBeans Weekly Newsletter</h2>
<p>
Join other language communities in translating the news items in
<a href="index.html">The NetBeans Weekly News</a>. The NetBeans web
team has created a user-friendly tool to help you add news items in
your language or translate existing English items. You will then be
able to publish it and automatically have it delivered to your NetBeans
language mailing list. For information on gaining access to this tool,
visit the <a href="http://wiki.netbeans.org/NBWeeklyNewsML">How to
Publish the NetBeans Weekly Newsletter in Your Language</a> web page.
</p>
<h2>External Contributions</h2>
To submit content for the newsletter, please send an email to: <a
 href="mailto:nbnews_contrib@netbeans.org">nbnews_contrib@netbeans.org</a>.<br>
<br>
<br>
<font class="smalltext">Have suggestions or
changes for this page? Please contact the
<a href="../../../about/contact_form.html?to=1">webmaster</a>.</font><br>
<br>
</body>
</html>
