
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 419</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 # 419 - Dec 08, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4505">NetBeans 6.8 and the NetBeans Platform Support</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Platform is the foundation for the NetBeans IDE and many other applications around the world. Sun Microsystems SVP Jim Parkinson affirms why the platform matters to the NetBeans community, Sun customers and to Sun Microsystems.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4509">NetBeans VOC - Taking the Pulse of the NetBeans Community</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Voice of the Community (VOC) program identifies and manages the needs of the NetBeans Community. Learn more about how the program works and those involved.</p>
					</div>
				<h1>Training</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4500">Screencast: Lombok Meets NetBeans and Java EE</a></h2>
						<p style="margin-left:8px;">
						Lombok is a library that handles boilerplate code typical to Java applications, such as 'getters' and 'setters'; with Lombok, you don't need to create these yourself. Alexis Moussine-Pouchkine made a screencast that shows how Lombok works with NetBeans IDE and GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4502">Wicket, JPA, GlassFish and Java Derby or MySQL</a></h2>
						<p style="margin-left:8px;">
						Carol McDonald's Pet Catalog application is an example of a web application that employs Wicket, JPA, GlassFish and MySQL. See how she modifies a sample application (JSF 2.0, JPA, GlassFish and MySQL) to use Wicket instead of JSF.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4506">How to Combine RESTful Web Services with EJB 3.1</a></h2>
						<p style="margin-left:8px;">
						In a very simple web application, Milan Kuchtiak demonstrates how RESTful web services can be combined with other Java EE technologies, specifically EJB 3.1.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4508">Commercial Digital Video Technology on the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						Miguel García López and his team had already developed a complex Swing application before. So when they evaluated the NetBeans Platform for their next project they preferred some of Platform's solutions over their own. Read on for another testimonial-story about the NetBeans Platform.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4503">Writing Your First Boxee App with NetBeans</a></h2>
						<p style="margin-left:8px;">
						Applications targetting the Boxee media center software are written in Python. This blog shows you how to set up NetBeans to get started with Boxee development, and it contains many pointers to documentation and hosting options.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4504">NetBeans Platform: Implementing a Perforce client</a></h2>
						<p style="margin-left:8px;">
						Aurelian Tutuianu is implementing a Perforce plugin for NetBeans. Learn how he hooked into the existing VersioningSystem SPI, implemented annotations in the IDE's UI, got his plugin listed in the NetBeans option panel, and reused the output window.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4507">NetBeans Loves Mercurial -- With Screenshots</a></h2>
						<p style="margin-left:8px;">
						More and more developers switch to NetBeans IDE every day. Such as, Glen Smith who writes that the NetBeans IDE is his top choice for Grails development because “the Mercurial support is just fantastic (and built into the basic install!).”</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Ruth Kusterer<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/2009-12-08.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>