<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta name="DESCRIPTION" content="NetBeans Birthday Celebration">
<title>The NetBeans' Birthday Celebration</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

<body>

<h1>The NetBeans' Birthday Celebration!</h1>
<br/>
<p>
<img src="../../images_www/articles/birthday-logo.gif" 
style="margin-right:15px; float:left;" alt="NetBeans Birthday">
October 26th is NetBeans' eighth birthday! We are celebrating for the whole 
month of October and YOU get the presents! Join us for stories about the 
history of NetBeans, quizzes, and prizes! The big prize at the end of
the month will be the release NetBeans 5.5 and packs to the developer community! </p>
<br/>
<br/>
<h2>Contests</h2>

<p>We'll have quizzes this month based on NetBeans history
and prizes for the first person to answer each quiz correctly.
Hint: The answers to most quiz questions appear in the articles
on this page. 

<p>
  <ol>
  <li><a href="https://netbeans.org/competition/bday-quiz/history-quiz.html">NetBeans History Quiz</a> -- 5x USB drive and NetBeans 5.5 T-shirt (CLOSED)</li>
  <li><a href="https://netbeans.org/competition/bday-quiz/ide-quiz.html">Feature quiz</a> -- 1x Apple iPod and 5x NetBeans 5.5 T-shirt  (CLOSED)</li>     
  <li><a href="https://netbeans.org/competition/bday-quiz/community-quiz.html">Community Quiz</a> --  5x NetBeans 5.5 T-shirt (CLOSED)</li>
  <li><a href="https://netbeans.org/competition/bday-quiz/contributed-quiz.html">A quiz contributed by community members</a> -- Prizes are <i><a href="https://netbeans.org/community/articles/interviews/NBFieldGuide.html">NetBeans IDE Field Guide</a></i> (2nd Edition) and NetBeans 5.5 T-shirt (CLOSED)</li>
  </ol>  
</p>

<h2>NetBeans History & Features</h2>

<p>

<ul>
<li>NetBeans <a href="https://netbeans.org/about/history.html">History page</a></li>
<li>NetBeans'First <a href="https://netbeans.org/about/press/46.html">Press Release</a>
<li>Interview with one of NetBeans Founders, 
<a href="https://netbeans.org/community/articles/interviews/yarda-tulach.html">Yarda Tulach</a> 
<li><a href="https://netbeans.org/download/flash/why-netbeans-part1/player.html">Why NetBeans? (Part One)</a>
A cool Flash demo by Roman Strobl about the basics of NetBeans (includes NetBeans demos)
<li><a href="https://netbeans.org/download/flash/why-netbeans-part2/player.html">Why NetBeans? (Part Two)</a>
Second part of the cool Flash demo by Roman Strobl with demos of advanced features of NetBeans.
</ul>

<!--
<h2>Write Your Own Quiz</h2>

<p>Write your own quiz about NetBeans! If we use it, we'll send you a copy of 
<i>NetBeans: The Definitive Guide</i> (2nd Edition) and NetBeans 5.5 T-shirt. 
Hurry, we have to review and use it during the month of October!
<a href="https://netbeans.org/about/contact-form.html">Send in a NetBeans Quiz</a>.
Be sure to put "Birthday Quiz" in the subject line.</p>
-->

</body>
</html>
