
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 669</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 # 669 - Dec 09, 2014
		</div>
	</div>
	<div id="content">
	
				<h1>Community</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9716">16 New NetBeans Dream Team Members!</a></h2>
						<p style="margin-left:8px;">
						The NetBeans Dream Team has expanded massively over the past week! Sixteen new members have joined, from many corners of the world. Read all about them here.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9717">Plugin: Jelastic Cloud Platform Integration</a></h2>
						<p style="margin-left:8px;">
						The Jelastic Cloud Platform Plugin lets you manage your Jelastic environments, deploy applications, get log files, and perform other operations right within your favorite IDE.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9718">Tweet of the Week: @AntholoJ</a></h2>
						<p style="margin-left:8px;">
						<i>Starting a 4 days JavaEE workshop. Thanks to all the community and specially @netbeans and @WildFlyAS for the great open source software.</i></p>
					</div>
				<h1>Partners</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9715">Second DevFest Istanbul: A Great Success</a></h2>
						<p style="margin-left:8px;">
						Mark Stephens, founder and lead engineer of NetBeans partner IDRsolutions, describes the recently held DevFest in Istanbul. IDRsolutions presented their technologies at a booth and Mark held a session focused on the key features of NetBeans IDE.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9711">Financial Software and the NetBeans Platform</a></h2>
						<p style="margin-left:8px;">
						"I can't say enough great things about the NetBeans Platform. It really does make the impossible easy. With the first application behind us, we now have an incredible amount of infrastructure to leverage, and we will be doing just that using the NetBeans Platform."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9712">Web Services with NetBeans and Maven</a></h2>
						<p style="margin-left:8px;">
						"In my opinion NetBeans has far the best integration of Maven. You don't have to configure both your IDE and Maven because NetBeans relies on the configuration in the POM file."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9713">Spring 4 Web MVC with NetBeans and Maven</a></h2>
						<p style="margin-left:8px;">
						Read a new article that goes through the steps required to set up a basic Spring 4 MVC web application using NetBeans and Maven. The Spring 4 project is configured using annotations and plain Java, rather than XML.</p>
					</div>
				<h1>Reviews</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9719">Trip Report: NetBeans Day, Munich, Germany</a></h2>
						<p style="margin-left:8px;">
						Despite having been arranged at the last minute, and undermined a bit by Lufthansa strikes and Deutsche Bahn hiccups, the room was filled to almost maximum capacity, certainly around 100 attendees were present. Find out what you missed if you weren't there!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=9714">Trip Report: DevFest Istanbul, Turkey</a></h2>
						<p style="margin-left:8px;">
						Mark Stephens did a great session entitled "5 Reasons Why NetBeans Should Be In Every Developer's Toolkit" and Geertjan Wielenga followed with "Coding for Desktop and Mobile with HTML5 and Java EE 7", which showed many features in NetBeans, such as the HTML5 tools, Chrome integration, AngularJS features, and Java EE code generators.</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/2014-12-09.html">netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive.html">newsletter archive</a>
		</div>
	</div>

</body>
</html>