
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 498</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >
</head>
<body>
<style>
body {
		margin:5px 15px 5px 15px;
		font-size: 11px;
		font-family: Verdana, "Verdana CE",  Arial, "Arial CE", "Lucida Grande CE", lucida, "Helvetica CE", sans-serif;
		background-color:#e3eaf1;
		text-align:center;
}

#letter {width:533px;margin-left:auto;margin-right:auto;}
#head {background-image:url("http://services.netbeans.org/appl/shared_images/head.png");width:533px;height:70px;background-repeat:none;}
#issue-date {padding-top:50px;text-align:center; color:white;}
#footer {background-image:url("http://services.netbeans.org/appl/shared_images/footer.png"); width:533px;height:28px;background-repeat:none;}
#footer-text {padding-top:5px;color:#6a6b6d;text-align:center;}
#content {border-right:3px solid #747d9e;border-left:3px solid #747d9e; background-color:white; text-align:left; color:#6a6b6d; padding:13px 20px 13px 13px; }
#letter h1 {font-size: 14px; font-weight:normal; margin:3px 0px 5px 0px; padding:0px;color: #EE6B00; border-bottom:1px solid silver;}
#letter h2 {color:#2C3C79;font-size: 13px; font-weight:normal;margin:0px 0px 2px 0px;padding:0px; border:0px;}
#letter p {padding: 0px;margin:0px; text-align:justify;}
#letter a:link, a:visited { color: #045491; font-weight : normal; text-decoration: none;}
#letter a:link:hover, a:visited:hover  { color: #045491; font-normal : bold; text-decoration : underline;}
.item {margin-left:8px; margin-bottom:9px;}
.bold {font-weight:bold;}
#letter a.orange {color: #EE6B00;}
.align-right {text-align:right;}
.align-center {text-align:center;}
.edited {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>


<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Issue # 498 - Aug 02, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6646">NetBeans IDE 7.0.1 Now Available for Download</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=5960&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans IDE 7.0.1 provides full support for the official release of the Java SE 7 platform, including the ability to run NetBeans IDE on top of JDK 7, and support for the JDK 7 language features.<br><br>NetBeans 7.0.1 is an update to NetBeans 7.0 and also includes integration of recent <a href="http://wiki.netbeans.org/NetBeans7.0PatchesInfo">patches</a>, and performance improvements.<br><br>
To get the recent changes:<ul>
<li><a href="https://netbeans.org/downloads/index.html"><b>Download NetBeans 7.0.1</b></a> OR
<li>If you already have NetBeans IDE 7.0 installed, launch the IDE and an update notification will appear. Click the alert-box to install the updates.</ul>
NetBeans IDE 7.0.1 is available in English, Brazilian Portuguese, Japanese, Russian, and Simplified Chinese.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6644">NetBeans Announces 1,000,000 Active Users!</a></h2>
						<p style="margin-left:8px;">
						"Oracle is committed to the continued success and growth of both the NetBeans and the Java communities," says Ted Farrell, Chief Architect and senior vice president, Tools and Middleware, Oracle. Read the full announcement here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6640">Plugin: Read/Write Access Switcher</a></h2>
						<p style="margin-left:8px;">
						Working in a file in NetBeans IDE... and then you find that it's locked. Install this plugin and you can switch read/write access within the IDE!</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6636">Java Spotlight Podcast: JDK 7, Glassfish 3.1.1, NetBeans IDE 7.0.1</a></h2>
						<p style="margin-left:8px;">
						The combined release of JDK 7, GlassFish 3.1.1, and NetBeans IDE 7.0.1 is celebrated in the latest Java Spotlight Podcast by Roger, Terrence, Alexis, Dalibor, and Geertjan.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6645">Developing Java EE 6 with NetBeans</a></h2>
						<p style="margin-left:8px;">
						Arun Gupta reports from a conference where he delivered a hands-on lab building a complete end-to-end Java EE 6 application using GlassFish and NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6638">Developing in Maven with NetBeans</a></h2>
						<p style="margin-left:8px;">
						After a long hiatus, John O'Conner returns to NetBeans IDE with a Maven project: "Thousands and thousands of lines of code with a dozen subprojects and dependencies just build without a single glitch." Read the details here!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6637">Manufacturing Simulation on NetBeans</a></h2>
						<p style="margin-left:8px;">
						At the RWTH Aachen University, a simulator is being created for gear design manufacuring. A modular system and a docking framework was needed, so that the NetBeans Platform was chosen as the ideal basis for this project. Read about it here and see a cool screenshot too!</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6643">September 19 - 21: NetBeans Training in Munich</a></h2>
						<p style="margin-left:8px;">
						Eppleton, the certified NetBeans Platform training consultancy in Munich, Germany, is organizing yet another one of its highly acclaimeed NetBeans Platform training courses in September. You're coming too, right?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6639">Training Report from RWTH Aachen University</a></h2>
						<p style="margin-left:8px;">
						A large group of students attended a NetBeans Platform course recently, which was led by Toni, Josch, and Geertjan. Students learned how to extend NetBeans IDE and how to create their own desktop applications on top of NetBeans. If you're interested in such a course too, write to geertjan dot wielenga at oracle dot com.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6642">Using NetBeans DataClassG Plugin with Web Applications</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Aristides Villarreal Bravo introduces you to a set of code generators that he has created, which are now available as plugins.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6641">NetBeans API: org.netbeans.spi.project.ProjectIconAnnotator</a></h2>
						<p style="margin-left:8px;">
						You've created a plugin that installs a new framework into an existing project. How to let the user know that the framework has been installed? Annotate the icon of the project! Read this blog entry that introduces you to the very simple and powerful NetBeans API needed for this purpose.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Tinuola Awopetu<br/>If you do not want to receive this newsletter, you can <a href="https://netbeans.org/community/lists/top.html">unsubscribe here</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2011-08-02.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>