<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <link rel="stylesheet" type="text/css" href="../../../netbeans.css"
 media="screen">
  <meta name="author" content="Tinuola Awopetu">
  <meta name="keywords"
 content="NetBeans IDE, NetBeans Platform, Open Source, Software Freedom Day">
  <title>NetBeans Celebrates FOSS 2008</title>
</head>
<body>
<h1>Celebrate Software Freedom Day with NetBeans!</h1>
<br>
Can you imagine not having access to the NetBeans IDE source code? Not
being able to adapt NetBeans IDE to your needs or create NetBeans
plugins for the benefits of other developers? Or contribute your
knowledge to help make the NetBeans IDE the ultimate development
environment? Well, neither can we!
<br>
<br>
On September 20, 2008, the free and open source software (FOSS)
industry will celebrate the virtues of free and open source software in
the annual Software Freedom Day (SFD).
<br>
<br>
<a href="http://softwarefreedomday.org/">Software Freedom Day</a> is an
event with hundreds of teams, from all around the world running local
events—installfests, seminars, product demos, giveaways and more—to
help their communities understand the signicance of Software Freedom
and to encourage the adoption of free software and open standards.
<br>
<br>
As a successful and vibrant open source project, NetBeans is proud to
be a part of Software Freedom Day, and we encourage our community
members to take part in this global celebration by hosting local events
on their campuses, with their user groups and more. To help NetBeans
community members who are interested in spreading the open source
message, we are offering a limited number of free t-shirts and DVDs.
Learn more below.<br>
<br>
<h2>How Can You Get Involved with Software Freedom Day?&nbsp;<br>
</h2>
<h3>Find an Event!</h3>
With more that 300 teams in over 65 countries planning local
events, there is
likely to be an event near you! For existing events:<br>
<br>
<ul>
  <li>Visit the <a href="http://cgi.softwarefreedomday.org/map.shtml">listings
page</a>
on the official Software Freedom Day website.</li>
  <li>Find out where <a href="http://www.sun.com/softwarefreedom">Sun,
its communities and campus ambassadors</a> will be
participating. </li>
</ul>
<h3>Host Your Own Event!</h3>
If you can't find an event near you, and would like to create your own,
here
are two great ways to get started:<br>
<br>
<ul>
  <li>Visit the <a href="http://softwarefreedomday.org/StartGuide">SFD
Start Guide</a>
on the official Software Freedom Day website </li>
  <li>Register your event as a Sun organized event at the Software
Freedom Day <a href="http://cgi.softwarefreedomday.org/register.html">registration</a>
site.</li>
</ul>
Looking for inspiration? Check out Sun Campus Ambassador <a
 href="http://blogs.sun.com/jaysblog/entry/open_source_hut_video_compilation">Jay
Mahadeokar's blog post</a> about his recent Open Source event. <br>
<h3>Promote It!</h3>
Invite your friends and promote Software Freedom Day events via your
blogs and
social networks. (Browse for Software Freedom Day <a
 href="http://www.sun.com/cgi-bin/sun/webdesign/index_banners.cgi?item=awareness:_software_freedom_day">web
banners</a>.)<br>
<h3>Have Fun!
</h3>
Meet NetBeans developers and open source enthusiasts, and learn more
about other
communities. Last, but not least: HAVE FUN!<br>
<br>
<h2>To Order Supplies
</h2>
To receive free NetBeans IDE 6.1 DVD Starter Kits and t-shirts your
event must be listed on the official <a
 href="http://cgi.softwarefreedomday.org/map.shtml">Software Freedom
Day events listing page</a> or on <a
 href="http://maps.google.com/maps/ms?ie=UTF8&amp;hl=en&amp;msa=0&amp;msid=111775096783007817384.000454fba5edd6c12fbf5&amp;ll=39.368279,-114.257812&amp;spn=37.980197,62.490234&amp;z=4">Sun's
Software
Freedom Day website</a>.
<br>
<br>
For shipping purposes only we require the following information:<br>
<br>
First &amp; Last Name
<br>
Contact Telephone Number
<br>
Full Mailing Address
<br>
Name and Date of the Event
<br>
Event URL
<br>
<a
 href="https://netbeans.org/about/contact_form.html?to=2&amp;subject=Software%20Freedom%20Day%20Request"><br>
Order Form</a><br>
<br>
<br>
<br>
<br>
<div style="text-align: right;"><span style="font-style: italic;">(September
2008)</span><br>
</div>
</body>
</html>
