
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 515</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 # 515 - Nov 28, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6954">NetBeans IDE 7.1 Release Candidate 1 Download & Survey</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=6278&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						The first release candidate build of NetBeans IDE 7.1 is now available for download, which means the general release is almost here. But first, help the NetBeans team make sure 7.1 is on track: <a href="http://download.netbeans.org/netbeans/7.1/rc1/"><b>Download the RC1 build</b></a>, test it and give your feedback in the <a href="https://netbeans.org/community/netcat/ca_survey_71.html"><b>NetBeans Community Acceptance Survey</b></a>. <i>(Survey deadline: December 7th.)</i></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6958">NetBeans Plugin: Prolog Editor</a></h2>
						<p style="margin-left:8px;">
						Updated for NetBeans 7.x, this module provides Prolog language support in the NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6952">Preorder: NetBeans Plugin Development Guide Book</a></h2>
						<p style="margin-left:8px;">
						Coming soon from Packt Publishing and authored by NetBeans Dream Team member Tushar Joshi: A comprehensive guide to developing plugins for the NetBeans IDE. Step-by-step instructions that take you through the NetBeans APIs, creating patches, and more.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6953">Website Development with HTML5, CSS3 in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A video tutorial series that demonstrates how to create a website from scratch using HTML5 and CSS3 in the NetBeans IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6955">Project Preachan: Synergizing the NetBeans IDE and the iPad Twitter Client</a></h2>
						<p style="margin-left:8px;">
						Created by software developer Kevin Doyle using the NetBeans IDE, Préachán is a Java-based Twitter client. Check out the project and discover how well-suited NetBeans IDE is for developing RESTful applications.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6951">Poll: What Would Encourage You to Contribute to NetBeans?</a></h2>
						<p style="margin-left:8px;">
						The "Community Spirit" poll series continues! First we asked how often you contributed to open-source projects; then in what ways you contributed to NetBeans itself. Now we want to know: What would move you to contribute <b>more, or at all</b> to NetBeans?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6956">Wanted: Code Brainteasers for Java Magazine</a></h2>
						<p style="margin-left:8px;">
						Calling all Java riddlers and teasers! Submit your best Java code brainteasers to Java Magazine's "Fix It" column. Visit the OTN-Java blog for submission guidelines and deadlines.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6950">Debate: Desktop Development's PR Problem</a></h2>
						<p style="margin-left:8px;">
						Is desktop app development a thing of the past, or simply the victim of poor PR? Geertjan Wielenga and others tackle this hot topic.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6957">Trip Report: It Happens Only at Devoxx</a></h2>
						<p style="margin-left:8px;">
						GlassFish evangelist Arun Gupta reports back on his first-ever Devoxx conference, with observations about what makes this popular European conference so unique.</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-11-28.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>