<!-- id is the same as the file name without the extension
     type is one of "committer" or "add-in-provider" -->
<boardmember id="papaioannou" type="add-in-provider">

	<name>Farah Papaioannou</name>

	<title>President and Co-founder, Edgeworx</title>

	<!-- Name of the file containing the image of the candidate; location relative to this file.  -->
	<image>papaioannou.jpg</image>

	<!-- eMail address will be modified before it is included on a webpage so that robots will not harvest it. -->
	<email>farah@edgeworx.io</email>

	<phone>1-909-971-7150</phone>

	<!-- How do we contact you? e.g. postal address -->
	<contact>
		1745 Hicks Ave
		San Jose, CA 95125
	</contact>

	<!-- What do you do with eclipse? -->
	<eclipse_affiliation><![CDATA[
		Eclipse Edge Native Working Group Organizer<br>
		Eclipse ioFog Committer<br>
		Eclipse IoT Working Group Member
	]]></eclipse_affiliation>

	<!-- Feel free to include html tags and what-not between the CDATA tags. -->
	<vision>
		<![CDATA[
			<p>It was an honor to serve my first year on the Board of the Eclipse Foundation, especially as the only female representative. While the Eclipse IDE is a major project of the Eclipse foundation, I spent my first year working to broaden the reputation and brand of the Eclipse Foundation into other technology areas such as Edge Computing. Through the year, I drove an initiative to successfully form, recruit and launch the Eclipse Edge Native Working Group. With a founding group of Intel, Siemens, Bosch, Ad-Link, Huawei, Edgeworx, Eurotech, and Kynetics (and a rapidly expanding list of notable companies wishing to join) the charter of the WG is to be a global leader (by shipping code, not specs!) in the emerging Edge Native landscape. The culmination of the effort was a widely and well received PR launch and website (http://edgenative.eclipse.org) that drove to the heart of my goals to build a wider brand for Eclipse. In addition, I was also fortunate enough to be named as Edge Woman of the Year (https://www.prnewswire.com/news-releases/state-of-the-edge-and-edge-computing-world-announce-farah-papaioannou-as-winner-of-the-edge-woman-of-the-year-award-2019-300974151.html) an honor I am not only humbled to have, but could not have done without the Eclipse Foundation's support of women in tech. I would like to strive to build on this vision by serving another year as a Sustaining Member representative on the Eclipse Board of Directors. I will continue to focus on advancement through the following efforts:</p>			

			<p><strong>Industry Leadership</strong><br>
			Edge Computing is one of the key mega trends in technology. The Eclipse Foundation has already started establishing its position as a leader with the Eclipse Edge Native Working Group. We not only have marquee companies standing alongside the Eclipse Foundation in the Edge Computing space, but they are now starting to commit developers and resources. As a member of the Board of Directors, I will be able to help continue this effort and expand to the next level. We have established oursevles as place for a open source technology that provides real-world solutions. I would like to expand this effort to grow the membership of the companies as well as increase the level of involvement and code contributions from these organizations.
			</p>
			<p><strong>Developers</strong><br>
			Developers are the life blood of all organizations today because companies now succeed or fail based on the quality of their technology. Developers have a unique and growing voice in companies and are increasingly turning to the Open Source to solve problems, understanding vendor lock-in is not the way of the future. The Eclipse Foundation has pioneered a path forwad by focusing on developers and the developer expreience. It is why Edgeworx chose to bring our project ioFog to Eclipse over anyhwere else. The developer centric message is resonating in recruiting other techonologies to Eclipse and we should proudly own that mantle - Eclipse knows developers, developers turn to Eclipse.
			</p>
			<p><strong>Awareness & Adoption</strong><br>
			I have talked to numerous companies about their use of open-source software and have noted how frequently their understanding of the Eclipse Foundation was either non-existent or grossly inaccurate. Many of these companies were only aware of the Eclipse IDE, even though they had immediate needs for other Eclipse projects or were already using Eclipse projects (e.g Hono) without even knowing it was from Eclipse. As a recovering VC turned entrepreneur, I spent my past life focused on finding early stage technologies, investing and growing their markets. I plan to bring this strategic focus to Eclipse, and have already begun recruiting new projects to expand on the existing great foundation of technologies already at Eclipse. I believe increasing awareness of our industry leadership and focus on developers will lead to more projects choosing Eclipse as a home. I believe that increased awareness of the Eclipse Foundation in industry will help fulfill many of the Foundation's goals. If elected, I will be able to serve as a direct channel between the organization and the companies to help grow awareness and adoption.
			</p>
			<p><strong>Membership</strong><br>
			Many companies that I work with as partners, vendors, and customers are good candidates for first-time Eclipse Foundation membership but are not aware of the benefits of membership and the importance of supporting the organization. I see opportunities to expand membership in 2020 and will work to find the most effective methods for achieving significant growth.
			</p>
		]]>
	</vision>

	<!-- Tell us a little bit about yourself. -->
	<bio>
	Farah Papaioannou is the President and Co-Founder of Edgeworx, an Edge Cloud platform company, pionnering 
	Edge Native open-source with Eclipse ioFog. She has over 15 years of experience in the Enterprise 
	software market, both as an Investor and an Operator. Her career has spanned both strategic operational 
	roles in G100 businesses and early stage investing in Silicon Valley and DC venture capital firms. Farah 
	holds three degrees from Stanford University. She graduated with a Bachelors of Science with Honors in 
	Computer Science, a Masters in Communications and Masters in Management Science and Engineering. Farah and her 
	husband, Todd, have 2 kids including a two-week-old. She loves skiing, traveling, and getting a (rare) full night of sleep!
	</bio>

	<!-- Who do you work for? -->
	<affiliation>Edgeworx</affiliation>

</boardmember>
