<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" media="screen" href="/~d/styles/rss2full.xsl"?><?xml-stylesheet type="text/css" media="screen" href="http://feeds2.feedburner.com/~d/styles/itemcontent.css"?><rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:feedburner="http://rssnamespace.org/feedburner/ext/1.0" version="2.0">
	<channel>
		
		<title>MOTODEV News</title>
		<link>http://developer.motorola.com/news/?rss=1</link>
		<description />
		<lastBuildDate>Thu, 07 May 2009 13:13:19 -0700</lastBuildDate>
		<language>en-US</language>
			<atom10:link xmlns:atom10="http://www.w3.org/2005/Atom" rel="self" href="http://feeds2.feedburner.com/MOTODEVNews" type="application/rss+xml" /><item>
				<title>Weekly MOTODEV Podcast</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/6jwznR8hD_g/MOTODEV-Android-Podcast-1</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/6jwznR8hD_g" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.blogtalkradio.com/motodev/2009/04/22/MOTODEV-Android-Podcast-1</feedburner:origLink></item>
			<item>
				<title>Platform Wars Panel: Outlook of Next Generation Mobile OS</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/E5InjsUwtBk/watch</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/E5InjsUwtBk" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.youtube.com/watch?v=bhfffhFnPMU</feedburner:origLink></item>
			<item>
				<title>Google I/O Conference</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/JEP-OqbBmns/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/JEP-OqbBmns" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://code.google.com/events/io/</feedburner:origLink></item>
			<item>
				<title>What are the prerequisites for learning Android?</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/zv29LQlBsoI/watch</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/zv29LQlBsoI" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.youtube.com/watch?v=Itk72uuqxSk</feedburner:origLink></item>
			<item>
				<title>MOTODEV Studio for Java ME v2.2</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/8SP-ZzsV6CI/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/8SP-ZzsV6CI" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/docstools/motodevstudio/javame/</feedburner:origLink></item>
			<item>
				<title>Listen to the Weekly MOTODEV Android Podcast</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/IAd3b1CZtvw/MOTODEV-Android-Podcast</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/IAd3b1CZtvw" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.blogtalkradio.com/motodev/2009/04/17/MOTODEV-Android-Podcast</feedburner:origLink></item>
			<item>
				<title>Share Your Feedback!</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/CUNV_1-cRCo/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/CUNV_1-cRCo" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/survey/</feedburner:origLink></item>
			<item>
				<title>Listen to the MOTODEV Podcast #2 on Android  Development</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/E7RWqfkFf8Y/Android-Dev-Talk-with-Austin-from-Trilibis-Mobile</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/E7RWqfkFf8Y" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.blogtalkradio.com/motodev/2009/04/10/Android-Dev-Talk-with-Austin-from-Trilibis-Mobile</feedburner:origLink></item>
			<item>
				<title>RSS Feed</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/9T_G-4sswLQ/MOTODEVNews</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/9T_G-4sswLQ" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://feeds2.feedburner.com/MOTODEVNews</feedburner:origLink></item>
			<item>
				<title>Mobile Developer Events Around the World in 2009</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/ZVeY0KeqF_4/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/ZVeY0KeqF_4" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://upcoming.yahoo.com/user/290661/</feedburner:origLink></item>
			<item>
				<title>What Discussion Board Topics Should We Have?</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/f_WDi0x6uAI/message</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/f_WDi0x6uAI" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://community.developer.motorola.com/mtrl/board/message?board.id=ForumsFeedback&amp;amp;thread.id=9</feedburner:origLink></item>
			<item>
				<title>Share Your Feedback</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/CUNV_1-cRCo/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/CUNV_1-cRCo" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/survey/</feedburner:origLink></item>
			<item>
				<title>New Support from the MOTODEV Community</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/JCFcgq4IMts/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/JCFcgq4IMts" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://community.developer.motorola.com/mtrl/?category.id=JavaME</feedburner:origLink></item>
			<item>
				<title>Motorola at CTIA</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/_LPc7y3sIBU/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/_LPc7y3sIBU" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/eventstraining/</feedburner:origLink></item>
			<item>
				<title>Watch video interviews from EclipseCon 2009</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/3XiZ-32GyjM/view_play_list</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/3XiZ-32GyjM" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.youtube.com/view_play_list?p=DC63BF0592CDA519</feedburner:origLink></item>
			<item>
				<title>MOTODEV at Events</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/_LPc7y3sIBU/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/_LPc7y3sIBU" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/eventstraining/</feedburner:origLink></item>
			<item>
				<title>From the Fast Track: Digital Map Overview</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/1_vwD3scSWg/</link>
				<guid isPermaLink="false">http://developer.motorola.com/fromfasttrack/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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/1_vwD3scSWg" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/fromfasttrack/March_09/</feedburner:origLink></item>
			<item>
				<title>Christy Wyatt at OSiM USA</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/jtIPqht30ks/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/jtIPqht30ks" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://usa.osimworld.com/</feedburner:origLink></item>
			<item>
				<title>Evans Data Developer Relations Conference</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/H-TAWLMXUJ0/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/H-TAWLMXUJ0" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://www.evansdata.com/drc/2009/</feedburner:origLink></item>
			<item>
				<title>MOTODEV Studio for WebUI v1.0</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/Ic5qfuBiHg8/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/Ic5qfuBiHg8" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/docstools/motodevstudio/webui/</feedburner:origLink></item>
			<item>
				<title>On the Cutting Edge: A Year of Innovations</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/pAtAkoFRMsI/</link>
				<guid isPermaLink="false">http://developer.motorola.com/cuttingedge/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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/pAtAkoFRMsI" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/cuttingedge/January_09/</feedburner:origLink></item>
			<item>
				<title>Internationalize Your WebUI Application</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/xANewABou9o/</link>
				<guid isPermaLink="false">http://developer.motorola.com/docstools/technicalarticles/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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/xANewABou9o" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/docstools/technicalarticles/Internationalized_WebUI_App.pdf/</feedburner:origLink></item>
			<item>
				<title>From the Fast Track: Acquiring Venture Capital</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/r0OavtoQtZ0/</link>
				<guid isPermaLink="false">http://developer.motorola.com/fromfasttrack/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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/r0OavtoQtZ0" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com/fromfasttrack/January_09/</feedburner:origLink></item>
			<item>
				<title>Get Connected to MOTODEV</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/vPXO5ulVd-Q/</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/vPXO5ulVd-Q" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://developer.motorola.com</feedburner:origLink></item>
			<item>
				<title>Discover the Virtual Developer Lab</title>
				<link>http://feedproxy.google.com/~r/MOTODEVNews/~3/NQ5b56Cq1B8/welcome.htm</link>
				<guid isPermaLink="false">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;&lt;img src="http://feeds2.feedburner.com/~r/MOTODEVNews/~4/NQ5b56Cq1B8" height="1" width="1"/&gt;</description>
			<feedburner:origLink>http://web.deviceanywhere.com/motodev/welcome.htm</feedburner:origLink></item>
	</channel>
</rss>
