<!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, NetBeans Achievements">
<title>NetBeans 2006: A Year in Review</title>
</head>
<body>
<h1>NetBeans in 2006: A Year in Review</h1>
<h4>
<h4>2006 was a productive year for NetBeans. It was a year of major 
releases and debuts. NetBeans traveled around the world and picked up a few 
new languages. Partnerships were formed; community involvement and 
outreach expanded. A book was published and a birthday celebrated. 
And amid all the activity, NetBeans acquired a new image. Join us 
for a look back at highlights from a year of achievements.</h4>
<br>
<br>
<!--JANUARY-->
<h2>January</h2>
<h4>NetBeans Podcasts</h4>
Evangelist Roman Strobl launches the <a
href="http://blogs.sun.com/roumen/category/Podcasts">NetBeans
Podcasts</a>. In the first episode, he talks about the
NetBeans ìLook and Feelî competition, using Matisse in NetBeans
Platform, and the upcoming NetBeans WorldTour.
<br>
<br>
    <img alt="NetBeans Evandalists" 
         src="../../images_www/articles/yearinreview06/nb-evandalists.gif"
     style="width: 74px; height: 75px;" align="left">
     <h4>NetBeans Evandalists</h4>
ìThey are cool. They are witty. Spreading Java technology is
their
mission. NetBeans is their IDE.î <br>
Ruth Kusterer introduces the world to
the animated quirks of the <a
href="http://blogs.sun.com/seapegasus/page/Evandalists">NetBeans
Evandalists</a>.
<br>
<br>
<br>
<!--FEBRUARY-->
<h2>February</h2>
<h4>Bring on the Releases: NetBeans 5.0<br>
</h4>
The first group in a slate of releases scheduled for 2006 are made
available: the NetBeans IDE 5.0, NetBeans Platform 5.0, NetBeans
Mobility Pack 5.0 and NetBeans Profiler 5.0.
<br>
<br>
<!--MARCH-->
<h2>March</h2>
    <img alt="Blue Jay" src="http://edu.netbeans.org/bluej/splash.png"
     style="width: 100px; height: 100px;" align="left"><br>
     <h4>NetBeans IDE Blue J Edition</h4>
     Sun Microsystems and the University of Kent collaborate to groom the
next generation of professinal developersóthey announce the <a
href="http://edu.netbeans.org/bluej/">NetBeans IDE/BlueJ Edition</a>.
The new edition offers a seamless migration path for students
transitioning from educational tools to a full-featured, professional
IDE. The NetBeans IDE-BlueJ edition is later released in July.
<br>
<br>
<br>
<br>
<h4>NetBeans IDE 5.0 Localizations</h4>
The NetBeans 5.0 release becomes available in <a
href="../releases/50/relnotes_zh_CN.html">Simplified
Chinese</a> and
<a href="../releases/50/relnotes_ja.html">Japanese</a>.
<br>
<br>
<!--APRIL-->
<h2>April</h2>
<h4>Enterprise Development Tool Project Open-sourced</h4>
Sun Microsystem announces plans to open-source major elements of the Sun
Java Studio Enterprise as a project on NetBeans.org. The new project will be
released as the NetBeans Enterprise Pack.
<br>
<br>
<h4>NetBeans Community
Chat</h4>
NetBeans writers, evangelists and enthusiasts congregate online for the
first ever <a
href="http://qa.netbeans.org/chats/chat_1/transcript.html">NetBeans
community chat</a>!<br>
<a
    href="http://qa.netbeans.org/chats/chat_1/chat_1.png" border="0px" target="_top">
    <img alt="Screen shot of Chat Transcript"
         src="http://qa.netbeans.org/chats/chat_1/chat_1_small.png"
     style="width: 156px; height: 87px; border: 0px;" align="left"></a><br>
<br>
<br>
<br>
<br>
<br>
<br>
<!--MAY-->
<h2>May</h2>
<img alt="NetBeans Day San Francisco"
         src="../../images_www/articles/worldtour/NB_250px.gif"
     style="width: 250px; height: 75px;" align="left">
     <h4>NetBeans Day &amp; JavaOne in San Francisco</h4>
<a
href="javaone/2006/nb-day.html">NetBeans
Day</a> in San Francisco gets bigger and better as over 800 developers
squeeze into the halls of the Argent Hotel. <a
href="http://weblogs.java.net/blog/gsporar/archive/2006/05/netbeans_day_sa.html">NetBeans
experts</a> provide demos of the 5.0 IDE and the 5.5 Beta version.
NetBeans
Day San Francisco also marks the completion of the 2005 NetBeans
World Tour which started in Beijing in September. Watch the <a
href="http://blogs.sun.com/roumen/entry/netbeans_worldtour_movie">recap</a>!<br>
<br>
<br>
<br>
<br>
    <img alt="NB Field Guide"
         src="../../images_www/articles/field-guide-2nd-ed.png"
     style="width: 93px; height: 121px;" align="left">
     <h4>NetBeans IDE Field
Guide, 2nd Edition</h4>
The <a href="http://www.techbookreport.com/tbr0254.html">reviews</a>
are in and the verdict for the second edition of the <a
href="../../kb/articles/books.html">NetBeans
IDE Field Guide</a>? ìÖhighly
recommended.î And readers and NetBeans fans agree. 400
copies are distributed at JavaOne, and the Field Guide still ranks near
the top of the <a
href="http://weblogs.java.net/blog/bleonard/archive/2006/05/netbeans_a_best_1.html">bestsellersí
list</a> at the conference.
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<img alt="Ramon Ramos"
src="../../images_www/articles/yearinreview06/ramon-ramos.png"
style="width: 77px; height: 83px;" align="left"><h4>NetBeans Community
Awards Winners</h4>
They evangelize, blog, contribute code and bug fixes, build modules,
write articles, localize, and so much more. They are ìThe
Most Dedicated NetBeans Community Membersî. And the winners, as decided
by their fellow community members, are: Ramon Ramos (pictured), Wade
Chandler, David Strupl, and Tom Wheeler. They receive new Ultra 20
workstations and certificates signed by Java celebrities.
<br>
<br>
<br>
<br>
<a
    href="../../images_www/mag-01-frontpage.jpg" border="0px" target="_top">
    <img alt="NetBeans Magazine"
         src="../../images_www/articles/yearinreview06/nb-mag1.jpg"
     style="width: 78px; height: 97px; border: 0px;" align="left"></a>
     <h4>NetBeans Magazine
Debut</h4>
NetBeans launches the <a
href="../magazine/issue1.html">NetBeans
Magazine</a>óa handy resource filled with information for beginning and
seasoned programmers. The first issue showcases a wide selection of IDE
and extension features, from desktop and web development to plug-in
module creation. A second issue is published in <a
href="../magazine/">November</a>.
<br>
<br>
<br>
<br>
<br>
<h4>NetBeans 5.5 Beta Released<br>
</h4>
The NetBeans IDE 5.5 Beta is made available. The release also includes
the Mobility Pack 5.5 Beta, Enterprise Pack 5.5 Early Access, and
NetBeans Profiler 5.5 Beta.
<br>
<br>
<!--JUNE-->
<h2>June</h2>
<a href="https://netbeans.org/kb/articles/field_guide/NBFieldGuide_Interview.html" border="0px" target="_top">
    <img alt="NetBeans TV, Patrick Keegan"
         src="../../images_www/articles/yearinreview06/nb-television.png"
     style="width: 119px; height: 89px; border: 0px;" align="left"></a>
<h4>NetBeans TV!</h4>
Another first for NetBeans: Itís NetBeans TV! In the <a
href="../../kb/articles/NBFieldGuide.html">pilot
episode</a>, NetBeans Field Guide author Patrick Keegan sits down with
evangelist Roman Strobl to discuss the recently published second
edition and the IDE.
<br>
<br>
<br>
<!--JULY-->
<h2>July</h2>
<h4>NetBeans 6.0 Milestone 1 Build</h4>
NetBeans announces the release of the first milestone build for
NetBeans IDE 6.0 and NetBeans Profiler 6.0. The build provides a fuller
set of features, more stabilization time for new features introduced in
the trunk, and more time for community feedback. More <a
href="http://wiki.netbeans.org/wiki/view/NewAndNoteWorthy">milestones</a>
are released later in the year.
<br>
<br>
<!--AUGUST-->
<h2>August</h2>
<h4>NetBeans Mobility Pack Open-sourced</h4>
<a href="http://mobility.netbeans.org/">NetBeans Mobility Pack</a>
opens its code to the community.
<br>
<br>
<br>
<a
    href="../../images_www/articles/yearinreview06/nb-german-mag-big.jpg" border="0px" target="_top">
    <img alt="NetBeans on Java Magazin Cover"
         src="../../images_www/articles/yearinreview06/nb-german-mag.jpg"
     style="width: 91px; height: 115px; border: 0px;" align="left"></a>
<h4>NetBeans on <i>Java Magazin </i>Cover<i><br>
</i></h4>
<span style="font-style: italic;">Wie gut ist Dein Deutsch?</span> 
<br>
<br>
NetBeans makes the cover of the August issue of the German-language <i><a
href="http://javamagazin.de/itr/ausgaben/psecom,id,319,nodeid,20.html">Java
Magazin</a></i>. <br>
The issue features interviews with NetBeans director
Jan Chalupa and evangelist Tim Boudreau.
<br>
<br>
<br>
<br>
<h4>NetBeans 5.0 Localization Continues</h4>
NetBeans 5.0 is released in two more languages: Russian and Korean,
adding to the versions of the IDE available in English, Japanese, and
Simplified Chinese. The Russian version is contributed solely by Maxym
Mykhalchuk, one of the founders of the <a
href="http://nblocalization.netbeans.org//">NetBeans Translation
Project</a>. <br>
<br>
<!--SEPTEMBER-->
<h2>September</h2>
 <h4>NetBeans WorldTour 2006 - 2007</h4>
    <img alt="World Tour"
         src="../../images_www/collateral/worldtour-0607/logos/100x60.png"
     style="width: 100px; height: 60px;" align="left">14 cities (and growingÖ), and all the NetBeans you want.
The NetBeans WorldTour returns for a new season and the first stop is in Seattle, Washington. The WorldTour
2006 is
organized around Sun Tech Days; NetBeans fans get the latest about
NetBeans and also about Sun Microsystems.
<br>
<br>
<br>
<h4>NetBeans Wins JDJ Editors' Choice Award</h4>
Editors at <i><a href="http://java.sys-con.com/read/260074.htm">Java
Developer's Journal</a></i> are asked to nominate three products that
have had a major impact on the Java community. Contributing Editor
Jason Bell writes of the NetBeans 5.0 IDE: <i>"ÖI've now become a
convert. Ö"</i>
<br>
<br>
<!--OCTOBER-->
<h2>October</h2>
<h4>NetBeans Turns Eight!</h4>
<img alt="NetBeans Birthday Logo"
         src="../../images_www/articles/birthday-logo.gif"
     style="width: 146px; height: 53px;" align="left"><br>
On <a href="birthday.html">October
26, 1998</a>, a start-up company in the Czech Republic launched
NetBeans
Developer 2.0, and the world, not to mention an American tech giant
called Sun Microsystems took notice. Java and the IDE world have not
been the same ever since.
<br>
<br>
<br>
<h4>NetBeans 5.5 and the Packs</h4>
NetBeans announces the release of <a
href="../../features/">NetBeans IDE 5.5</a>. But the
new version of the IDE comes with extra features
in the form of five add-ons:
the Mobility Pack, Profiler, Enterprise Pack, C/C++ Pack (Beta 3)
and Visual Web Pack (Technology Preview).
<br>
<br>
<h4>NetBeans.org Redesigned</h4>
The <a href="https://netbeans.org/">NetBeans.org</a> website
gets a makeover. The cleaner and friendlier look allows users to easily
find and download code and releases, search for tutorials, NetBeans
news and all the info they need.
<br>
<br>
  <h4>NetBeans Strategic Partner Program</h4>
    <img alt="Strategic Partner Program"
         src="../../images_www/partners/nb_sp_100px.png"
     style="width: 100px; height: 34px;" align="left">
We love to know what other companies are doing with NetBeans products.
The <a href="../partners/">NetBeans
Strategic Partner Program</a> is launched to recognize companies that
are building
add-ons for the NetBeans platform and recommending NetBeans to their
developer communities. Strategic partners include <a
href="http://www.amazon.com/gp/browse.html?node=3435361">Amazon</a>,
<a href="http://www.jboss.com/products/jbossnetbeans">JBoss</a>, <a
href="http://www.collab.net">Collabnet</a>, <a
href="http://sprint.com">Sprint</a><!--http://services.netbeans.org/newsletter/story.php?id=880-->
and more.
<br>
<br>
<h4>NetBeans User Group in Munich</h4>
The very first <a
href="http://blogs.sun.com/geertjan/entry/impressions_from_the_netbeans_user">NetBeans
User Group</a> (NUG) meeting is held in Munich, Germany. NetBeans
experts and NetBeans users gather to exchange knowledge and get
feedback about the IDE.
<br>
<br>
<!--NOVEMBER-->
<h2>November</h2>
<h4>Java Open-sourced</h4>
Sun's Java Development Kit (JDK) is <a
href="http://nb-openjdk.netbeans.org/">open-sourced</a>.
<br>
<br>
<h4>Wanted: NetBeans Dream Team</h4>
There are NetBeans users and then there are NETBEANS USERS. They blog
frequently about NetBeans,
write apps and plug-ins, answer questions on mailing lists, help with
localization, attend NetBeans events, suggest creative
ways to promote NetBeans, and much more. How difficult
would it be to find a group of users like these? Not very. The selected
members will be announced
in January 2007.
<br>
<br>
<!--DECEMBER-->
<h2>December</h2>
<h4>NetBeans 5.5 Multilingual Release<br>
</h4>
The push to make NetBeans a multi-language platform continues with
the release of the <a
href="http://services.netbeans.org/downloads/index.php?rs">NetBeans
5.5 Multilingual</a> in Japanese,
Simplified Chinese, and for the very first time, Brazilian Portuguese,
a version localized by the <a
href="brazil55-release.html">
Brazilian developer community</a>.
<br>
<br>
    <img alt="Visual Web Pack"
         src="../../images_www/v5/product-icons/50/visualweb_35.gif"
     style="width: 25px; height: 25px;" align="left"><h4>NetBeans Visual Web
Pack 5.5<br>
</h4>
    <img alt="C/C++"
         src="../../images_www/v5/product-icons/50/cplus_35.gif"
     style="width: 25px; height: 25px;" align="left"><h4>NetBeans C/C++
Development
Pack
5.5</h4>
<br>
The NetBeans <a href="../../features/web/web-app.html">Visual
Web
Pack</a> and the NetBeans <a
href="../../features/cpp/index.html">C/C++
Development Pack</a> are released as add-ons to the NetBeans IDE.
Visual Web Pack allows users to rapidly and
visually build standards-based web applications, and the C/C++
Development
Pack provides support for C/C++ project types.
<br>
<br>
<a
    href="../../images_www/articles/yearinreview06/bruno-souza-big.jpg" border="0px" target="_top">
    <img alt="Bruno Souza"
         src="../../images_www/articles/yearinreview06/bruno-souza.jpg"
     style="width: 114px; height: 84px; border: 0px;" align="left"></a>
<h4>New NetBeans Community Manager</h4>
Remember the guy at JavaOne walking around with a Brazilian flag
draped around his shoulders? We hire him. His Brazilian heritage is
not the
only thing <a
href="http://blogs.sun.com/roumen/entry/netbeans_podcast_%2319_-_interview">Bruno
Souza</a> enjoys publicizing; he does equally well talking of his
passion for Java,
which he has done since 1995. He brings his evangelizing
talents to NetBeans as the new community manager.
<br>
<br>
<br>
</body>
</html>
