<?xml version="1.0" encoding="utf-8"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
	<channel>
		<atom:link href="http://developer.motorola.com/news/?rss=1" rel="self" type="application/rss+xml" />
		<title>MOTODEV News</title>
		<link>http://developer.motorola.com/news/?rss=1</link>
		<description></description>
		<lastBuildDate>Wed, 24 Jun 2009 08:48:25 -0700</lastBuildDate>
		<language>en-US</language>
			<item>
				<title>Recap: Silicon Valley Android MeetUp</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/Recap-Silicon-Valley-Android-MeetUp/ba-p/1327</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/Recap-Silicon-Valley-Android-MeetUp/ba-p/1327</guid>
				<pubDate>Thu, 18 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;The meet-up was a well attended and successful event. Learn more about what happened and check out the Android cupcakes!&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/androidmeetup_green.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV Podcast with Wine by the Bar</title>
				<link>http://www.blogtalkradio.com/motodev/2009/06/17/MOTODEV-Podcast</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/06/17/MOTODEV-Podcast</guid>
				<pubDate>Thu, 18 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Listen to Thomas McKay - owner, developer and marketer - talk about Wine by the Bar, an Android phone app.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast_blue.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Create a Barcode Scanning App with Zxing</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/Barcode-Scanning-on-Android-Using-Zxing/ba-p/1284</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/Barcode-Scanning-on-Android-Using-Zxing/ba-p/1284</guid>
				<pubDate>Thu, 18 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Barcode scanning apps are popular on the Android Market. Find out more about using an open-source code called Zxing to create cool barcode scanning apps.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/barcode.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Silicon Valley Android MeetUp</title>
				<link>http://androidsv.ning.com/events/silicon-valley-android-meetup</link>
				<guid>http://androidsv.ning.com/events/silicon-valley-android-meetup</guid>
				<pubDate>Fri, 05 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Attend the Silicon Valley Android MeetUp hosted by MOTODEV on Tuesday, June 16th from 6-8pm. All developers are welcome to participate.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/androidmeetup_green.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV Podcast - Mark Chang from Olin College</title>
				<link>http://www.blogtalkradio.com/motodev/2009/06/03/MOTODEV-Podcast</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/06/03/MOTODEV-Podcast</guid>
				<pubDate>Fri, 05 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Mark Chang from Olin College in Needham, MA joined the MOTODEV Podcast to chat about his mobile app development course that focuses on Android.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast_orange.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Videos from Google I/O 2009</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/Videos-from-Google-I-O-2009/ba-p/1215#A33</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/Videos-from-Google-I-O-2009/ba-p/1215#A33</guid>
				<pubDate>Fri, 05 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;While at the Google I/O Conference, MOTODEV had an amazing opportunity to film some great video interviews.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/chrisfagan.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Recap: Google I/O 2009</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/An-Amazing-Google-I-O/ba-p/1214#A32</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/An-Amazing-Google-I-O/ba-p/1214#A32</guid>
				<pubDate>Fri, 05 Jun 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;MOTODEV had the incredible opportunity to be at the Google I/O 2009 Conference and blog about it, with details on sessions and video interviews with leading Android experts.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/googleio.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>A Great First Day at Google I/O</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/A-Great-First-Day-at-Google-I-O/ba-p/1194#A27</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/A-Great-First-Day-at-Google-I-O/ba-p/1194#A27</guid>
				<pubDate>Fri, 29 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;MOTODEV blogger, Suzanne Alexandra, recaps the first day.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/googleio.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Attend our Keynote at Open Mobile Summit</title>
				<link>http://www.openmobilesummit.com/</link>
				<guid>http://www.openmobilesummit.com/</guid>
				<pubDate>Fri, 29 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Come hear Christy Wyatt, VP, Software Platforms and Ecosystem speak at our keynote, Embracing Open Source with Android on June 11 at 10am.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/openmobilesummit.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Froogloid Demos New Android App - Key Ring</title>
				<link>http://www.youtube.com/watch?v=xJ5CpIpcz9I</link>
				<guid>http://www.youtube.com/watch?v=xJ5CpIpcz9I</guid>
				<pubDate>Fri, 29 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Chris Fagan from Froogloid demos Key Ring, their new barcode scanning app, at Google I/O 2009.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/froogloid_demo.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Handmark CTO, Ted Wugofski, Announces Express News at Google I/O</title>
				<link>http://www.youtube.com/watch?v=AkwMf3j2OEA</link>
				<guid>http://www.youtube.com/watch?v=AkwMf3j2OEA</guid>
				<pubDate>Fri, 29 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Ted talks with MOTODEV blogger, Randy Ksar, about their new Android app and platform.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/wugofksi.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Interview with Michael Mace</title>
				<link>http://developer.motorola.com/platforms/android/distribute/</link>
				<guid>http://developer.motorola.com/platforms/android/distribute/</guid>
				<pubDate>Wed, 20 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Watch our interview with Michael Mace from Rubicon Consulting as he talks about solving tough strategy and marketing problems.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/michaelmace.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Attend the Live Taping of the MOTODEV Podcast</title>
				<link>http://motodevpodcast.eventbrite.com/</link>
				<guid>http://motodevpodcast.eventbrite.com/</guid>
				<pubDate>Wed, 20 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Join us Thursday, May 28, 5:30 pm (PDT), right after the Google I/O Conference, at the Flurry, Inc. headquarters in San Francisco.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast_green.png' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Installing the Android Development Environment</title>
				<link>http://developer.motorola.com/platforms/android/develop/Installing-Android-Dev-Environment/</link>
				<guid>http://developer.motorola.com/platforms/android/develop/Installing-Android-Dev-Environment/</guid>
				<pubDate>Wed, 20 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;A step-by-step guide to configuring your development environment.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/platforms/android/images/install_190.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Silicon Valley Android MeetUp</title>
				<link>http://androidsv.com/events/silicon-valley-android-meetup</link>
				<guid>http://androidsv.com/events/silicon-valley-android-meetup</guid>
				<pubDate>Wed, 20 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Attend the Android MeetUp hosted by MOTODEV in Sunnyvale, CA on June 16, 6-8 pm.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/calendar_green.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Top 6 Mobile Pricing Models</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/Top-6-Mobile-App-Pricing-Models/ba-p/1125#A15</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/Top-6-Mobile-App-Pricing-Models/ba-p/1125#A15</guid>
				<pubDate>Wed, 20 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Mobile pricing models to think about before you begin developing your app.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_money_green.png' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV Blog Launches</title>
				<link>http://community.developer.motorola.com/t5/MOTODEV-Blog/Welcome-to-the-MOTODEV-Blog/ba-p/1055#A1</link>
				<guid>http://community.developer.motorola.com/t5/MOTODEV-Blog/Welcome-to-the-MOTODEV-Blog/ba-p/1055#A1</guid>
				<pubDate>Thu, 14 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Read our first post and comment on what topics you want us to write about.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/blog_orange.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Go Behind-the-Scenes on the Android App ShopSavvy</title>
				<link>http://www.blogtalkradio.com/motodev/2009/05/06/MOTODEV-Android-Podcast-with-Ed-Burnette-Big-in-Japan</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/05/06/MOTODEV-Android-Podcast-with-Ed-Burnette-Big-in-Japan</guid>
				<pubDate>Thu, 14 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Listen to our podcast with Rylan Barnes of Big in Japan, creator of ShopSavvy, and Ed Burnette from ZDNet.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast_blue.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Track &amp;amp; Analyze Your Mobile Apps with Flurry</title>
				<link>http://www.blogtalkradio.com/motodev/2009/05/13/MOTODEV-Android-Podcast-with-Flurry</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/05/13/MOTODEV-Android-Podcast-with-Flurry</guid>
				<pubDate>Thu, 14 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Sean Galligan joined us on our weekly podcast talking mobile analytics and their product called Flurry.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV's Weekly Podcast</title>
				<link>http://www.blogtalkradio.com/motodev/2009/04/29/MOTODEV-Android-Podcast-with-PhoneGap</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/04/29/MOTODEV-Android-Podcast-with-PhoneGap</guid>
				<pubDate>Thu, 07 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Andre Charland &amp;amp; Joe Bowser from Nitobi talk Android app development with PhoneGap.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast_orange.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV is on Twitter</title>
				<link>http://twitter.com/motodev</link>
				<guid>http://twitter.com/motodev</guid>
				<pubDate>Thu, 07 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Are you on Twitter? Follow @motodev and tweet us a link to your blog or web site.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/twitter.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Next Podcast: May 13th at 9am Pacific</title>
				<link>http://www.blogtalkradio.com/motodev/2009/05/13/MOTODEV-Android-Podcast-with-Flurry</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/05/13/MOTODEV-Android-Podcast-with-Flurry</guid>
				<pubDate>Thu, 07 May 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Sean Galligan from Flurry talks with us about mobile analytics for your Android app.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/calendar_orange.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Weekly MOTODEV Podcast</title>
				<link>http://www.blogtalkradio.com/motodev/2009/04/22/MOTODEV-Android-Podcast-1</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/04/22/MOTODEV-Android-Podcast-1</guid>
				<pubDate>Thu, 30 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Interview with Chris Fagan from Froogloid, creator of a2b, a new Android application.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Platform Wars Panel: Outlook of Next Generation Mobile OS</title>
				<link>http://www.youtube.com/watch?v=bhfffhFnPMU</link>
				<guid>http://www.youtube.com/watch?v=bhfffhFnPMU</guid>
				<pubDate>Thu, 30 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Claudia Backus from Motorola previews upcoming GoMobile conference panel being held on May 4, 2009 in San Francisco.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/backus.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Google I/O Conference</title>
				<link>http://code.google.com/events/io/</link>
				<guid>http://code.google.com/events/io/</guid>
				<pubDate>Thu, 30 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Google engineers and web development leaders will lead you through two days full of in-depth breakout sessions on the latest technologies.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/calendar_green.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>What are the prerequisites for learning Android?</title>
				<link>http://www.youtube.com/watch?v=Itk72uuqxSk</link>
				<guid>http://www.youtube.com/watch?v=Itk72uuqxSk</guid>
				<pubDate>Thu, 23 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Find out from Android author and trainer Mark Murphy who answers the question in our video  interview.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/video_blue.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV Studio for Java ME v2.2</title>
				<link>http://developer.motorola.com/docstools/motodevstudio/javame/</link>
				<guid>http://developer.motorola.com/docstools/motodevstudio/javame/</guid>
				<pubDate>Thu, 23 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Target more handsets with Java ME development, from Windows XP/Vista, Mac OS, and Linux hosts.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/studio.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Listen to the Weekly MOTODEV Android Podcast</title>
				<link>http://www.blogtalkradio.com/motodev/2009/04/17/MOTODEV-Android-Podcast</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/04/17/MOTODEV-Android-Podcast</guid>
				<pubDate>Thu, 23 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Most Recent Episode: CEO Brett Butterfield from Pixelpipe talks about their Android app and platform.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast_blue.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Share Your Feedback!</title>
				<link>http://developer.motorola.com/survey/</link>
				<guid>http://developer.motorola.com/survey/</guid>
				<pubDate>Fri, 17 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Tell us how MOTODEV can better serve you. Log in today to fill out a short survey about your mobile application development.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/survey190x135.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Listen to the MOTODEV Podcast #2 on Android  Development</title>
				<link>http://www.blogtalkradio.com/motodev/2009/04/10/Android-Dev-Talk-with-Austin-from-Trilibis-Mobile</link>
				<guid>http://www.blogtalkradio.com/motodev/2009/04/10/Android-Dev-Talk-with-Austin-from-Trilibis-Mobile</guid>
				<pubDate>Fri, 17 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Interview with Austin Teames, product manager at Trilibis Mobile and organizer of the Android Developer  LinkedIn Group (1100+ members).&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/android_podcast.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>RSS Feed</title>
				<link>http://feeds2.feedburner.com/MOTODEVNews</link>
				<guid>http://feeds2.feedburner.com/MOTODEVNews</guid>
				<pubDate>Fri, 17 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Get the latest MOTODEV News via a RSS reader of your choice.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/rss.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Mobile Developer Events Around the World in 2009</title>
				<link>http://upcoming.yahoo.com/user/290661/</link>
				<guid>http://upcoming.yahoo.com/user/290661/</guid>
				<pubDate>Fri, 17 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Network with other developer, share best practices and learn the latest mobile technology.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/calendar_red.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>What Discussion Board Topics Should We Have?</title>
				<link>http://community.developer.motorola.com/mtrl/board/message?board.id=ForumsFeedback&amp;amp;thread.id=9</link>
				<guid>http://community.developer.motorola.com/mtrl/board/message?board.id=ForumsFeedback&amp;amp;thread.id=9</guid>
				<pubDate>Fri, 17 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Tell us your suggestions for topics on our boards now &amp;ndash; we're listening.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/javame_boards.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Share Your Feedback</title>
				<link>http://developer.motorola.com/survey/</link>
				<guid>http://developer.motorola.com/survey/</guid>
				<pubDate>Mon, 06 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Please take just a few moments to fill out a short member survey designed to help us better understand your current development.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/survey/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>New Support from the MOTODEV Community</title>
				<link>http://community.developer.motorola.com/mtrl/?category.id=JavaME</link>
				<guid>http://community.developer.motorola.com/mtrl/?category.id=JavaME</guid>
				<pubDate>Mon, 06 Apr 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;MOTODEV's Java ME Discussion Boards are now available! The community, your peers and Motorola experts are ready to assist you.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/javame_boards.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Motorola at CTIA</title>
				<link>http://developer.motorola.com/eventstraining/</link>
				<guid>http://developer.motorola.com/eventstraining/</guid>
				<pubDate>Tue, 31 Mar 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Join Motorola for four days to learn more about the emerging technologies that enable us to work toward the common goal of taking wireless and broadband communications to yet another level.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/ctia.gif/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Watch video interviews from EclipseCon 2009</title>
				<link>http://www.youtube.com/view_play_list?p=DC63BF0592CDA519</link>
				<guid>http://www.youtube.com/view_play_list?p=DC63BF0592CDA519</guid>
				<pubDate>Fri, 27 Mar 2009 00:00:00 -0700</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Experts from Motorola, DeviceAnywhere, Handmark, and the Eclipse Foundation.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/youtube.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV at Events</title>
				<link>http://developer.motorola.com/eventstraining/</link>
				<guid>http://developer.motorola.com/eventstraining/</guid>
				<pubDate>Fri, 06 Mar 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Motorola has announced its commitment to open source development for mobile platforms. Learn about Motorola's platform strategy on Android by attending our tech talks and keynotes at OSiM USA, Evans Data Developer Relations Conference, and EclipseCon 2009.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/cwyatt.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>From the Fast Track: Digital Map Overview</title>
				<link>http://developer.motorola.com/docstools/articles/ft_March_09/</link>
				<guid>http://developer.motorola.com/docstools/articles/ft_March_09/</guid>
				<pubDate>Fri, 06 Mar 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Over the last two decades, mapping has been extensively transformed by advances in computers and information systems. Today, map data, also referred to as spatial data are the fuel for location-enabled applications.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/navteq.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Christy Wyatt at OSiM USA</title>
				<link>http://usa.osimworld.com/</link>
				<guid>http://usa.osimworld.com/</guid>
				<pubDate>Fri, 06 Mar 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Come hear Christy Wyatt, VP, Software Platforms and Ecosystem, speak at the keynote "Personalisation Through Open Source" on March 11th at 3:10 PM at the ONLY Open Source in Mobile gathering in the USA.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/osim.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Evans Data Developer Relations Conference</title>
				<link>http://www.evansdata.com/drc/2009/</link>
				<guid>http://www.evansdata.com/drc/2009/</guid>
				<pubDate>Fri, 06 Mar 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Come hear Christy Wyatt, Vice President, Software Platforms and Ecosystem, speaks on March 16th from 2:10 - 2:55 PM.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/evans_data_developer_conference.jpg' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>MOTODEV Studio for WebUI v1.0</title>
				<link>http://developer.motorola.com/docstools/motodevstudio/webui/</link>
				<guid>http://developer.motorola.com/docstools/motodevstudio/webui/</guid>
				<pubDate>Thu, 05 Mar 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;MOTODEV Studio for WebUI has moved out of beta and now offers you even more convenient ways to develop interactive Web applications and widgets.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/news_studio_webui.gif' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>On the Cutting Edge: A Year of Innovations</title>
				<link>http://developer.motorola.com/docstools/articles/January_09/</link>
				<guid>http://developer.motorola.com/docstools/articles/January_09/</guid>
				<pubDate>Tue, 13 Jan 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;MOTODEV's technology evangelist looks back at 2008, identifying 5 key areas of innovation and suggesting ways to make your next app stand out from the crowd.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/CE_0109.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Internationalize Your WebUI Application</title>
				<link>http://developer.motorola.com/docstools/articles/Internationalized_WebUI_App.pdf/</link>
				<guid>http://developer.motorola.com/docstools/articles/Internationalized_WebUI_App.pdf/</guid>
				<pubDate>Tue, 13 Jan 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;This article demonstrates two methods of adding multi-language support to a simple app: hard-coding of localized strings and connection to a web-based translation API.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/techarticle_internationalize_webui.png/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>From the Fast Track: Acquiring Venture Capital</title>
				<link>http://developer.motorola.com/docstools/articles/ft_January_09/</link>
				<guid>http://developer.motorola.com/docstools/articles/ft_January_09/</guid>
				<pubDate>Tue, 13 Jan 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;In a tough economy, finding capital for your start-up requires extra preparation. Fast Track partner 151 Ventures provides some real-world advice to get you started.&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/fft_venture_capital.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Get Connected to MOTODEV</title>
				<link>http://developer.motorola.com</link>
				<guid>http://developer.motorola.com</guid>
				<pubDate>Tue, 13 Jan 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;Keep up with the latest updates from the Motorola developer network. Follow MOTODEV at:&lt;br /&gt;
&lt;a href="http://twitter.com/motodev" target="_blank"&gt;Twitter&lt;/a&gt; | &lt;a href="http://www.facebook.com/pages/Motorola-MOTODEV/23911812380" target="_blank"&gt;Facebook&lt;/a&gt; | &lt;a href="http://www.linkedin.com/groups?gid=1052027" target="_blank"&gt;LinkedIn&lt;/a&gt; | &lt;a href="http://www.youtube.com/user/motorolamotodev" target="_blank"&gt;YouTube&lt;/a&gt; | &lt;a href="http://www.flickr.com/photos/motodev" target="_blank"&gt;Flickr&lt;/a&gt;&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/youtube.jpg/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
			<item>
				<title>Discover the Virtual Developer Lab</title>
				<link>http://web.deviceanywhere.com/motodev/welcome.htm</link>
				<guid>http://web.deviceanywhere.com/motodev/welcome.htm</guid>
				<pubDate>Tue, 06 Jan 2009 00:00:00 -0800</pubDate>
				<description>					&lt;table&gt;
						&lt;tr&gt;
							&lt;td width='99%'&gt;DeviceAnywhere and Motorola have teamed up to launch the MOTODEV Virtual Developer Lab. Use a simple desktop interface to test apps on Motorola handsets directly over the Internet!&lt;/td&gt;
							&lt;td&gt;&lt;img src='/admin/rss/template-item-description-w-image/http://developer.motorola.com/news/images/news_vdl.png/' /&gt;&lt;/td&gt;
						&lt;/tr&gt;
					&lt;/table&gt;</description>
			</item>
	</channel>
</rss>
