
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 571</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 # 571 - Jan 22, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8055">NetBeans Plugin: Velocity Editor Support</a></h2>
						<p style="margin-left:8px;">
						A plugin providing VTL (Velocity Template Language) editor support--syntax-error highlighting, code folding, and braces matching--for the NetBeans IDE.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8046">Using EJB Lite and JPA in a Java SE Application</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7379&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='79' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						EJB Lite is a subset of the features of  EJB 3.1.  An embeddable enterprise bean container supports EJB Lite and can run within a Java SE application in the same JVM. So one can run EJB outside an application server  and a Java SE client can access the EJB locally. In this tutorial, you will develop a Java SE client that invokes a stateless EJB which is running in an embedded container in the same JVM as the Java client.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8050">From Database to RESTful Web Service to HTML5 in 10 Minutes</a></h2>
						<p style="margin-left:8px;">
						Learn to expose data from a database via a JAX-WS RESTful web service and to consume the service in an HTML5 application, using HTML5, JavaScript, and CSS.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8049">Video: Build Java Applications for Mobile Devices</a></h2>
						<p style="margin-left:8px;">
						Learn to build native applications for all mobile devices using Java and NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8054">Video: Entity Beans with NetBeans and Derby</a></h2>
						<p style="margin-left:8px;">
						An introductory look at developing entity beans using NetBeans IDE, Derby and JPA.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8051">Meet a NetBeans Community Member: Ann Maybury</a></h2>
						<p style="margin-left:8px;">
						Ann Maybury is 75 years old and has been involved in all phases of software production for over 50 years. Here she shares her computing history and usage of the NetBeans IDE and NetBeans Platform as the basis of her golf scheduling software.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8052">Benefits of NetBeans as a Drupal IDE</a></h2>
						<p style="margin-left:8px;">
						The top 10 benefits to using NetBeans IDE for Drupal development.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8053">Troubleshooting Tools Part 1: VisualVM</a></h2>
						<p style="margin-left:8px;">
						VisualVM, built on the NetBeans Platform, is discussed in the WebLogic Server blog.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8047">New PrimeFaces CRUD Generator Blog</a></h2>
						<p style="margin-left:8px;">
						Follow Kay Wrobel's new blog on SourceForge, focused on his PrimeFaces CRUD generator for NetBeans IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8048">NetBeans-Praxis LIVE Dark Theme</a></h2>
						<p style="margin-left:8px;">
						Praxis developer Neil C. Smith dabbles with the "dark arts" and creates a plugin that adds the Praxis LIVE look-and-feel to NetBeans IDE.</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/2013-01-22.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>