
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 677</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 # 677 - Feb 24, 2015
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9818">JBoss Forge and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Markus Eisele from Red Hat takes you through the process of getting started generating Java EE Maven applications from scratch with JBoss Forge in NetBeans IDE, from installing the NetBeans plugin by Red Hat, to getting started using it.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9817">PrimeFaces and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						PrimeFaces supplies charting solutions making it easy to add visual representations of your data into web and mobile applications. Combined with RESTful web service data, let's see as Josh Juneau shows how to create custom charts scaling well for both desktop and mobile devices.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9819">EJB Interceptors and NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Interceptors are used, as the name suggests, to intercept EJB methods calls using methods annotated with interceptor annotations. Read Gaurav Gupta's step by step guide via NetBeans IDE and get started using EJB interceptors in your code today.</p>
					</div>
				<h1>Plugin</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9814">Updated: Codename One</a></h2>
						<p style="margin-left:8px;">
						Codename One is a complete open source platform allowing developers to build (visually or using a Swing like API) native applications for Android, iPhone/iPad, Blackberry, Windows Phone 7 etc. It is free for commercial use and includes a GUI builder, simulator and everything you need in a single package. See <a href="http://www.codenameone.com">http://www.codenameone.com</a> for more information.</p>
					</div>
				<h1>Calendar</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9811">25 February: Free Virtual Technology Summit with NetBeans</a></h2>
						<p style="margin-left:8px;">
						The Oracle Technology Network (OTN) is excited to invite you to the Virtual Technology Summit Series for the EMEA timezone. Four times a year come and join us to learn first hand from Oracle ACEs, Java Champions, and Oracle product experts, as they share their insight and expertise on using Oracle technologies to meet today’s IT challenges. Four main content areas covered will be Database, Java, Middleware and Systems.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9812">16 March: NetBeans Day Germany</a></h2>
						<p style="margin-left:8px;">
						After the recently held <a href="https://blogs.oracle.com/geertjan/entry/trip_report_netbeans_day_germany">NetBeans Day Germany</a>, the feeling was that another one should be organized soon. And within a few weeks, all the seats are almost full. Sign up for this free event in Munich today!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9813">17 - 18 April: NetBeans Days Greece</a></h2>
						<p style="margin-left:8px;">
						Join members of the NetBeans community in Athens, have fun, learn about Java and HTML5 with NetBeans, and have nice meals and excursions with great people.</p>
					</div>
				<h1>Tutorials</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9816">Part 1: RESTful Web Services Made Easy</a></h2>
						<p style="margin-left:8px;">
						Watch an excellent video showing how to get started, in detail, with RESTful web services -- and how to consume them in HTML, JavaScript, and CSS</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9815">Part 2: RESTful Web Services Made Easy</a></h2>
						<p style="margin-left:8px;">
						Watch part 2 of an excellent series, introducing Spring Boot and Spring Data JPA, to create a CRUD application, together with Maven, Tomcat, and NetBeans IDE</p>
					</div>
	<div class="edited">
	NetBeans Weekly Newsletter is brought to you by the NetBeans Team.<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>
	<div id="footer">
		<div id="footer-text">
				This newsletter is accessible also at  <a href="https://netbeans.org/community/news/newsletter/2015-02-24.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>