
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 582</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 # 582 - Apr 08, 2013
		</div>
	</div>
	<div id="content">
	
				<h1>Project News</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8251">Ruby and Rails for NetBeans IDE 7.3</a></h2>
						<p style="margin-left:8px;">
						Congratulations to Tom Enebo and the NetBeans Ruby community for completing the hard work involved in the latest release of the Ruby and Rails plugin. Now available on the NetBeans Plugin Portal, you can try it in NetBeans IDE 7.3 today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8256">Plugin: PHP WordPress Blog/CMS</a></h2>
						<p style="margin-left:8px;">
						The plugin provides New Wordpress Project wizard, create themes, hyperlink navigation and code completion for filter and action functions.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8252">Java EE 7 and JAX-RS 2.0</a></h2>
						<p style="margin-left:8px;">
						Java EE 7 with JAX-RS 2.0 brings several useful features, which further simplify development and lead to the creation of even more-sophisticated, but lean, Java SE/EE RESTful applications. Let Adam Bien explain it all for you in this new full blown tutorial!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8255">New Usages of the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						The infrastructure of NetBeans IDE, i.e., the NetBeans Platform is being used in even more scenarios than previously thought, including as the basis of <a href="https://blogs.oracle.com/geertjan/entry/vending_machine_management_on_the">vending machine software</a>, <a href="https://blogs.oracle.com/geertjan/entry/aquatic_research_processing_software_on">aquatic informatic software</a>, <a href="https://blogs.oracle.com/geertjan/entry/systems_biology_network_visualization_on">systems biology software</a>, and <a href="https://blogs.oracle.com/geertjan/entry/robotic_simulation_interface_on_the">robotic software</a>.</p>
					</div>
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8248">Jarda Tulach on the Slopes</a></h2>
						<p style="margin-left:8px;">
						Tinu from the NetBeans Team has started a new blog. After introducing herself in her first blog entry, she reports on NetBeans API architect Jaroslav Tulach's recent adventures.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8249">Acteur: New Pattern and Framework for Web Applications</a></h2>
						<p style="margin-left:8px;">
						NetBeans Dream Team member Tim Boudreau, after doing some work with Node.js, wanted to find a way to get some of the goodness of its programming model for Java. Read on to find out what happened next!</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8250">Java SE 8 Lambda Quick Start</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=7636&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;'/>
						This Oracle by Example (OBE) provides an introduction to lambda expressions included in Java SE 8. An introduction to anonymous inner functions is provided, followed by a discussions of functional interfaces and the new lambda syntax. Then, examples of common usage patterns before and after lambda expressions are shown.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8254">Video: Working with CSS Style Sheets in HTML5 Applications in NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						A screencast that demonstrates how to use the NetBeans IDE to create and edit CSS in an HTML5 application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=8253">Video: Code Formatting Features in the NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						This screencast demonstrates some important formatting features in the NetBeans IDE.</p>
					</div>
	<div class="edited">
	This issue was brought to you by: Geertjan Wielenga<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-04-08.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>