
<!DOCTYPE html>
<!--
 Generated by Apache Maven Doxia at 2016-10-27
 Rendered using Reflow Maven Skin 1.1.1 (http://andriusvelykis.github.io/reflow-maven-skin)
-->
<html  xml:lang="en" lang="en">

	<head>
		<meta charset="UTF-8" />
		<title>Apache Flex® - Community Faces</title>
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<meta name="description" content="" />
		<meta http-equiv="content-language" content="en" />

		<link href="./css/bootstrap.min.css" rel="stylesheet" />
		<link href="./css/bootstrap-responsive.min.css" rel="stylesheet" />
		<link href="./css/docs.css" rel="stylesheet" />
		<link href="./css/reflow-skin.css" rel="stylesheet" />

		<link href="http://yandex.st/highlightjs/7.5/styles/default.min.css" rel="stylesheet" />

		<link href="./css/lightbox.css" rel="stylesheet" />

		<link href="./css/site.css" rel="stylesheet" />
		<link href="./css/print.css" rel="stylesheet" media="print" />

		<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
		<!--[if lt IE 9]>
			<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
		<![endif]-->


		
<link rel="icon" href="img/favicon.ico" type="image/x-icon"/>
<link rel="apple-touch-icon" href="img/apple-touch-icon-60.png"/>
<link sizes="76x76" rel="apple-touch-icon" href="img/apple-touch-icon-76.png"/>
<link sizes="120x120" rel="apple-touch-icon" href="img/apple-touch-icon-120.png"/>
<link sizes="152x152" rel="apple-touch-icon" href="img/apple-touch-icon-152.png"/>
	</head>

	<body class="page-about-people project-flex-site" data-spy="scroll" data-offset="60" data-target="#toc-scroll-target">

		<div class="navbar navbar-fixed-top">
			<div class="navbar-inner">
				<div class="container">
					<a class="btn btn-navbar" data-toggle="collapse" data-target="#top-nav-collapse">
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
					</a>
					<div class="nav-collapse collapse" id="top-nav-collapse">
						<ul class="nav pull-right">
							<li ><a href="index.html" title="Home">Home</a></li>
							<li class="dropdown active">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">About Flex <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="about-whatis.html" title="What is Flex?">What is Flex?</a></li>
									<li ><a href="about-features.html" title="Features">Features</a></li>
									<li ><a href=".html" title="Tour de Flex">Tour de Flex</a></li>
									<li ><a href="about-licensing.html" title="License & Trademarks">License & Trademarks</a></li>
									<li class="active"><a href="" title="The Team">The Team</a></li>
									<li ><a href="about-history.html" title="Project History">Project History</a></li>
									<li ><a href="about-assets.html" title="Logo and Assets">Logo and Assets</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Community <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="community-getinvolved.html" title="How to get involved">How to get involved</a></li>
									<li ><a href="community-mailinglists.html" title="Mailing Lists">Mailing Lists</a></li>
									<li ><a href="community-showcase.html" title="Flex Showcase">Flex Showcase</a></li>
									<li ><a href="community-3rdparty.html" title="Third-Party">Third-Party</a></li>
									<li ><a href="https://cwiki.apache.org/confluence/display/FLEX/Apache+Flex+Wiki" title="Wiki" class="externalLink">Wiki</a></li>
									<li ><a href="http://blogs.apache.org/flex/" title="Blog" class="externalLink">Blog</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Development <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="dev-faq.html" title="Developer FAQ">Developer FAQ</a></li>
									<li ><a href="dev-sourcecode.html" title="Source Code">Source Code</a></li>
									<li ><a href="https://issues.apache.org/jira/browse/FLEX" title="Bug-Tracker" class="externalLink">Bug-Tracker</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Documentation <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="doc-getstarted.html" title="Getting Started">Getting Started</a></li>
									<li ><a href="doc-videos.html" title="Videos">Videos</a></li>
									<li ><a href=".html" title="Flex ASDocs">Flex ASDocs</a></li>
									<li ><a href=".html" title="FlexJS ASDocs">FlexJS ASDocs</a></li>
									<li ><a href="http://help.adobe.com/en_US/flex/using/index.html" title="Documentation Reference (Old)" class="externalLink">Documentation Reference (Old)</a></li>
									<li ><a href=".html" title="FlexUnit Tutorials">FlexUnit Tutorials</a></li>
									<li ><a href=".html" title="FlexUnit ASDocs">FlexUnit ASDocs</a></li>
									<li ><a href="doc-website.html" title="Contributing to the Flex Website">Contributing to the Flex Website</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">About Apache <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="http://www.apache.org" title="The Apache Software Foundation Website" class="externalLink">The Apache Software Foundation Website</a></li>
									<li ><a href="http://www.apache.org/foundation/contributing.html" title="Donations" class="externalLink">Donations</a></li>
									<li ><a href="http://www.apache.org/foundation/sponsorship.html" title="Sponsorship" class="externalLink">Sponsorship</a></li>
									<li ><a href="http://www.apache.org/foundation/thanks.html" title="Thanks" class="externalLink">Thanks</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Download Flex <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="download-installer.html" title="SDK Installer (For Application Developers)">SDK Installer (For Application Developers)</a></li>
									<li ><a href="download-source.html" title="SDK Source Code (For SDK Developers)">SDK Source Code (For SDK Developers)</a></li>
									<li ><a href="download-binaries.html" title="SDK Binaries (For SDK Developers)">SDK Binaries (For SDK Developers)</a></li>
									<li ><a href="download-flexjs.html" title="FlexJS 'beta' (For Application Developers)">FlexJS 'beta' (For Application Developers)</a></li>
									<li ><a href="download-flexunit.html" title="FlexUnit (For Application Developers)">FlexUnit (For Application Developers)</a></li>
									<li ><a href="download-blazeds.html" title="Blaze DS Source Code">Blaze DS Source Code</a></li>
									<li ><a href="download-tourdeflex.html" title="Tour De Flex Source Code">Tour De Flex Source Code</a></li>
									<li ><a href="download-squiggly.html" title="Squiggly Spell Checker">Squiggly Spell Checker</a></li>
									<li ><a href="download-utilities.html" title="Flex Utilities">Flex Utilities</a></li>
									<li ><a href="download-archive.html" title="Previous Versions">Previous Versions</a></li>
								</ul>
							</li>
						</ul>
					</div><!--/.nav-collapse -->
				</div>
			</div>
		</div>

	<div class="container">

	<!-- Masthead
	================================================== -->

	<header>
	<div class="jumbotron subhead">
		<div class="row" id="banner">
			<div class="span12">
				<div class="pull-left">
					<a href="http://flex.apache.org/" id="bannerLeft"><img src="img/logo-flex.png" alt='"'Apache Flex'"' /></a>
				</div>
				<div class="pull-right">
					<a href="http://www.apache.org" id="bannerRight"><img src="img/logo-asf.png" alt='"'An Apache Project'"' /></a>
				</div>
			</div>
		</div>
	</div>
	</header>

	<div class="main-body">
	<div class="row">
		<div class="span12">
			<div class="body-content">
				<div class="page-header">
 <h1>Community Faces</h1>
</div>
			</div>
		</div>
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Alex_Harui">Alex Harui</h4>
<p>aharui (C+P)</p>
<p><img src="img/team/aharui.jpg" alt="aharui" class="img-circle about-image" /></p>
<p><b>PMC Chair of Apache Flex</b></p>
<p>Alex Harui has been working on the Flex SDK since he joined Macromedia in 2002. He is now spending most of his time on a next-generation of Flex called FlexJS that cross-compiles MXML and ActionScript into JavaScript so your Flex apps can run without Flash and AIR.</p>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Carlos_Rovira">Carlos Rovira</h4>
<p>carlosrovira (C)</p>
<p><img src="img/team/carlosrovira.jpg" alt="carlosrovira" class="img-circle about-image" /></p>
<p>Carlos Rovira is a technologist, entrepreneur and businessman. He is passionate about advanced web interfaces and rich multi-device business applications. He is extremely happy when their applications are useful for people, combining functionality and usability. He’s founder of various companies including carlosrovira.com in 2007 and <a class="externalLink" href="http://www.codeoscopic.com">Codeoscopic</a> in 2009. He’s the technical leader behind the <a class="externalLink" href="http://www.codeoscopic.com/tecnologia/riality/">Riality</a> Flex/JEE Platform and other successful insurance software products like <a class="externalLink" href="http://www.directwriter.es">Direct Writer</a> and <a class="externalLink" href="http://www.avant2.es">Avant 2</a>.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/carlosrovira">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="http://www.github.com/carlosrovira">Github</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://es.linkedin.com/in/carlosrovira/">LinkedIn</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/115670167046758349523">Google Plus</a></li> 
 <li class="rss"><a class="externalLink" href="http://www.carlosrovira.com/blog/feed/">RSS</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Carol_Frampton">Carol Frampton</h4>
<p>cframpton (C+P)</p>
<p><img src="img/team/cframpton.jpg" alt="cframpton" class="img-circle about-image" /></p>
<p>Carol is a software engineer at Adobe, based outside of Boston. She worked on Adobe Flex for about five years - FTE and TLF text with Gordon, Spark DataGrid, mirroring and the top bug fixer for the last couple of years - then transitioned with Flex to Apache. Release manager for Apache Flex 4.8.0. Being a generalist, she’s worked on a wide variety of software, including ColdFusion and JRun, kernel-level networking code and distributed networking software.</p>
<ul class="social-icons"> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/carolframpton">LinkedIn</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Chema_Balsas">Chema Balsas</h4>
<p>jbalsas (C)</p>
<p><img src="img/team/jbalsas.jpg" alt="jbalsas" class="img-circle about-image" /></p>
<p>Web application developer. Focusing on JS right now and trying to help with Falcon and FalconJS as an Apache Flex Commiter.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/jbalsas">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="http://www.github.com/jbalsas">Github</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/jbalsas">LinkedIn</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/109872083963647761639">Google Plus</a></li> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Christofer_Dutz">Christofer Dutz</h4>
<p>cdutz (C+P)</p>
<p><img src="img/team/cdutz.jpg" alt="cdutz" class="img-circle about-image" /></p>
<p>Christofer is a software engineer secialized on Flex, Java, Spring and Maven. He is the lead developer of the <a class="externalLink" href="https://flexmojos.atlassian.net/wiki/display/FLEXMOJOS/Home" target="_blank">Flexmojos</a> project (Maven plugin for building Flex applications) after taking over from Velo in 2012. His main areas of contribution to the Apache Flex project is creating a tool for creating Mavenized versions of Flex SDKs, continuing to advance Flex’ Maven support.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://de.twitter.com/ChristoferDutz">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="http://github.com/chrisdutz">Github</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/pub/christofer-dutz/49/9b6/424">LinkedIn</a></li> 
</ul>
<div class="section">       
</div>
		</div>
		<div class="span3">
			<h4 id="Chris_Martin">Chris Martin</h4>
<p>chrsmrtn (C+P)</p>
<p><img src="img/team/chrsmrtn.jpg" alt="chrsmrtn" class="img-circle about-image" /></p>
<p>Chris has been doing Flex UI development since Flex 2 and is very excited to be apart of the Apache Flex Team. With the Apache Flex Team, he feels that the Flex SDK has a bright future. He looks to help with the flex sdk bug verification and patching.</p>
<p> 
 <!-- Social Icons --> </p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/chrsmrtn">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="http://www.github.com/chrsmrtn-">Github</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://es.linkedin.com/in/chrsmrtn/">LinkedIn</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/+chrismartinplus">Google Plus</a></li> 
 <li class="wordpress"><a class="externalLink" href="http://chrsmrtn.azurewebsites.net">Blog</a></li> 
</ul>
<div class="section">          
</div>
		</div>
		<div class="span3">
			<h4 id="DarkStone_">DarkStone (周戈)</h4>
<p>darkstone (C)</p>
<p><img src="img/team/darkstone.png" alt="darkstone" class="img-circle about-image" /></p>
<p>DarkStone has been doing Flash since 2002, doing Flex since 2006, doing PHP since 2007, he is both a designer and a developer.</p>
<p>He had several jobs, last job he was a product manager for 3 years, had done several RIA products.</p>
<p>Since 2013 he quit his job and started his own studio, forging his own path.</p>
<p>Now he’s goal is to develop mobile and desktop platform apps (using Flex and PHP etc.) and sell them to the AppStore.</p>
<p>Basically, make the money first, and try to change the world later ; )</p>
<p>He is now living in Wuhan city of China.</p>
<div class="section">     
</div>
		</div>
		<div class="span3">
			<h4 id="Douglas_Arthur">Douglas Arthur</h4>
<p>dougarthur (C+P)</p>
<p><img src="img/team/dougarthur.jpg" alt="dougarthur" class="img-circle about-image" /></p>
<p>Douglas passed away in May, 2012. He is deeply missed within our community.</p>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Erik_de_Bruin">Erik de Bruin</h4>
<p>erikdebruin (C+P)</p>
<p><img src="img/team/erikdebruin.jpg" alt="erikdebruin" class="img-circle about-image" /></p>
<p>Erik is a software engineer (Flex/Flash, PHP, Delphi, Authorware, to name a few), e-learning consultant and occassional project manager. For the Apache Flex project he is a committer and part of the PMC. He has contributed the SDK Installer Badge, was contributor and co-release manager on the first release of the SDK Installer and is currently busy getting the FalconJx and FlexJS projects off the ground.</p>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Espen_Skogen">Espen Skogen</h4>
<p>espenskogen (C+P)</p>
<p><img src="img/team/espenskogen.jpg" alt="espenskogen" class="img-circle about-image" /></p>
<p>Espen is a Vice President at JP Morgan, where he is leading the development of client facing trading technology. Espen was one of the initial committers and PMC members of Apache Flex.</p>
<ul class="social-icons"> 
 <li class="linkedin"><a class="externalLink" href="http://uk.linkedin.com/in/espenskogen">LinkedIn</a></li> 
</ul>
<div class="section">      
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Frdric_Thomas">Fr&eacute;d&eacute;ric Thomas</h4>
<p>fthomas (C+P)</p>
<p><img src="img/team/fthomas.jpg" alt="fthomas" class="img-circle about-image" /></p>
<p>Freelancer, software architect, Apache Flex PMC Member, trying to make the Flex world better.</p>
<p>(French)</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/webdoublefx">Twitter</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/116545614452242070442/posts">Google Plus</a></li> 
</ul>
<div class="section">        
</div>
		</div>
		<div class="span3">
			<h4 id="Gordon_Smith">Gordon Smith</h4>
<p>gordonsmith (C+P)</p>
<p><img src="img/team/gordonsmith.png" alt="gordonsmith" class="img-circle about-image" /></p>
<p>Gordon is currently working on completing MXML support in the new Falcon compiler. He lives in San Francisco and works for Adobe.</p>
<p>Gordon was one of the original four engineers on a 2002 Macromedia project that became Flex, and worked on the Flex framework for eight years:</p>
<ul> 
 <li>Developed components for Flex 1.0.</li> 
 <li>Built a customer application with Flex 1.5.</li> 
 <li>Led the port to AS3 for Flex 2.</li> 
 <li>Designed and implemented the ResourceManager for Flex 3.</li> 
 <li>Integrated the FTE and TLF text technologies into Flex 4.</li> 
</ul>
<p>Since 2010 he has been part of the compiler team at Adobe.</p>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Harbs">Harbs</h4>
<p>harbs (C+P)</p>
<p><img src="img/team/harbs.jpg" alt="harbs" class="img-circle about-image" /></p>
<p>Harbs comes from a print background and his primary interest is in publishing. He keeps himself busy with his multiple technology businesses: <a class="externalLink" href="http://in-tools.com">In-Tools</a>, <a class="externalLink" href="http://printui.com">PrintUI</a> and <a class="externalLink" href="http://unhurdle.com/">UnHurdle</a>. All three businesses rely heavily on Flex as one of the active technologies, so Harbs has a strong interest in Flex.</p>
<p>Harbs also spends his time studying Talmud, and with his wife and kids. If there’s any time left, he gets a bit of sleep.</p>
<ul class="social-icons"> 
 <li class="facebook"><a class="externalLink" href="http://www.facebook.com/gharbs">Facebook</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/profile/view?id=46698545">LinkedIn</a></li> 
 <li class="github"><a class="externalLink" href="https://github.com/Harbs">GitHub</a></li> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/intools">Twitter</a></li> 
</ul>
<div class="section">       
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Jeffry_Houser">Jeffry Houser</h4>
<p>jhouser (C+P)</p>
<p><img src="img/team/jhouser.jpg" alt="jhouser" class="img-circle about-image" /></p>
<p><a class="externalLink" href="http://www.jeffryhouser.com">Jeffry Houser</a> is a technical entrepreneur that likes to share cool stuff with other people. Jeffry is the Brains behind <a class="externalLink" href="http://www.flextras.com">Flextras</a>, a library of Open Source Flex Components including a Calendar, AutoComplete, and a Mobile DropDownList. </p>
<p>Jeffry is one of the initial contributors to Apache Flex and his primary interest lies in<br />expanding the component library, especially for use in mobile applications. </p>
<p>In his spare time, Jeffry runs <a class="externalLink" href="http://www.dot-com-it.com.">DotComIt</a>, a consulting firm developing Rich Internet Applications. He has spoken all over the US, is author of three books, over 30 articles, and hundreds of podcasts.</p>
<ul class="social-icons"> 
 <li class="facebook"><a class="externalLink" href="http://www.facebook.com/reboog711">Facebook</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/jeffryhouser">LinkedIn</a></li> 
 <li class="github"><a class="externalLink" href="https://github.com/Flextras/FlextrasComponents/">GitHub</a></li> 
 <li class="rss"><a class="externalLink" href="http://www.jeffryhouser.com/rss.cfm?mode=full">RSS</a></li> 
 <li class="rss"><a class="externalLink" href="https://www.flextras.com/blog/rss.cfm?mode=full">RSS</a></li> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/reboog711">Twitter</a></li> 
</ul>
<div class="section">       
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Jeremy_Tellier">Jeremy Tellier</h4>
<p>jtellier (C+P)</p>
<p><img src="img/team/jtellier.jpg" alt="jtellier" class="img-circle about-image" /></p>
<p>Macromedia/Adobe Technology evangelist, architect, engineer, Jeremy has implemented a slew of Flash, Flex, &amp; AIR based solutions for startups to fortune 100 companies over the past 15 years.</p>
<p>Jeremy works as a consultant at <a class="externalLink" href="http://www.actieve.com" target="_blank">Actieve</a> for Rich Mobile, Desktop &amp; Web Based projects in which Flex is at the top of his preferred technology stack.</p>
<p>On a more personal note…. Jeremy feels awkward writing about himself in the third person.</p>
<ul class="social-icons"> 
 <li class="facebook"><a class="externalLink" href="http://www.facebook.com/JeremyTellier">Facebook</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/jeremytellier/">LinkedIn</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/115560858703396246574">Google+</a></li> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/jtellier">Skype</a></li> 
 <li class="skype"><a href="skype:JeremyTellier?chat">Skype</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Jose_Barragan">Jose Barragan</h4>
<p>josebarragan (C)</p>
<p><img src="img/team/josebarragan.jpg" alt="josebarragan" class="img-circle about-image" /></p>
<p>Jose Barragan is a Software Architect, with over 10 years experience in the enterprise sector. Has a big experience in design, development and implementation of high performance software in corporate environments. Has an extensive knowledge of Flex, Java, Spring, Hibernate, Maven, Git, being the technical co-leader behind the <a class="externalLink" href="http://www.codeoscopic.com/tecnologia/riality/">Riality</a> Flex/JEE Platform and other successful insurance software products like <a class="externalLink" href="http://www.directwriter.es">Direct Writer</a> and <a class="externalLink" href="http://www.avant2.es">Avant 2</a>. Restless mind and enthusiast of new technologies. Always learning from everything and everyone.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/morphx">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="http://github.com/pepebarragan">Github</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://es.linkedin.com/in/pepebarragan/">LinkedIn</a></li> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Joseph_Labrecque">Joseph Labrecque</h4>
<p>josephlabrecque (C)</p>
<p><img src="img/team/josephlabrecque.jpg" alt="josephlabrecque" class="img-circle about-image" /></p>
<p>Joseph Labrecque is primarily employed by the University of Denver as a senior interactive software engineer specializing in the creation of expressive desktop, web, and mobile solutions. He is also the proprietor of Fractured Vision Media, LLC. Joseph is an Adobe Education Leader and Adobe Community Professional.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://twitter.com/josephlabrecque">Twitter</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/josephlabrecque">LinkedIn</a></li> 
 <li class="rss"><a class="externalLink" href="http://www.lynda.com/JosephLabrecque">Lynda.com</a></li> 
 <li class="amazon"><a class="externalLink" href="http://www.amazon.com/-/e/B0057R7UO0">Amazon</a></li> 
 <li class="behance"><a class="externalLink" href="https://www.behance.net/JosephLabrecque">Behance</a></li> 
 <li class="facebook"><a class="externalLink" href="https://www.facebook.com/joseph.labrecque">Facebook</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://google.com/+JosephLabrecque/">Google+</a></li> 
 <li class="github"><a class="externalLink" href="https://github.com/josephlabrecque/">Github</a></li> 
 <li class="youtube"><a class="externalLink" href="https://www.youtube.com/channel/UCOznZ0dg3BwfhxwO2p90ejQ">YouTube</a></li> 
 <li class="rss"><a class="externalLink" href="http://inflagrantedelicto.memoryspiral.com/feed/">In Flagrante Delicto!</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Josh_Tynjala">Josh Tynjala</h4>
<p>joshtynjala (C+P)</p>
<p><img src="img/team/joshtynjala.jpg" alt="joshtynjala" class="img-circle about-image" /></p>
<p><a class="externalLink" href="https://twitter.com/joshtynjala">Josh Tynjala</a> is the author of the open source <a class="externalLink" href="http://feathersui.com/">Feathers</a> user interface components for Starling Framework. In addition to improving the Apache FlexJS compilers, Josh teaches developers how to transpile ActionScript on his website, <a class="externalLink" href="http://nextgenactionscript.com/">NextGen ActionScript</a>.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="https://twitter.com/joshtynjala">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="https://github.com/joshtynjala">Github</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Jun_Heider">Jun Heider</h4>
<p>junheider (C+P)</p>
<p><img src="img/team/junheider.jpg" alt="junheider" class="img-circle about-image" /></p>
<p>Helping Apache Flex grow through mentoring and community awareness. An officer of the Open Spoon Foundation. Cross-platform Flex mobile developer at RealEyes Media with a focus in video and multiuser applications. Adjunct Faculty at University of Denver, University College teaching students how to build native applications with Adobe AIR.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://twitter.com/coderjun">Twitter</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/junheider">LinkedIn</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Justin_Mclean">Justin Mclean</h4>
<p>jmclean (C+P)</p>
<p><img src="img/team/jmclean.jpg" alt="jmclean" class="img-circle about-image" /></p>
<p>Experienced web application developer, certified trainer, international conference speaker and Arduino tinkerer. Interesting in making Apache Flex more international and work on a wider range of platforms. Added international postcode support and locales to Apache Flex 4.9.0. Release manager for Apache Flex 4.9.0.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://twitter.com/JustinMclean">Twitter</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/justinmclean">LinkedIn</a></li> 
 <li class="github"><a class="externalLink" href="http://www.github.com/justinmclean">GitHub</a></li> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Mahmoud_Ali">Mahmoud Ali</h4>
<p>akamud (C)</p>
<p><img src="img/team/akamud.jpg" alt="akamud" class="img-circle about-image" /></p>
<p>.NET and Apache Flex developer, working on Web and mobile applications. One of the creators of the <a class="externalLink" href="https://github.com/akamud/FlatSpark">FlatSpark</a> skin, a project to bring a more clean and modern look to Apache Flex applications, recently donated to Apache Software Foundation. His goal as a committer is to continue improving and creating new Skins and components for Flex.</p>
<p>Always interested in learning and sharing about new technologies. In his spare time wanders around the internet looking for open source projects that need help. </p>
<p>Also feels weird describing himself in the third person.</p>
<ul class="social-icons"> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/akamud/en">LinkedIn</a></li> 
 <li class="github"><a class="externalLink" href="https://github.com/akamud">GitHub</a></li> 
 <li class="twitter"><a class="externalLink" href="http://twitter.com/akamud">Twitter</a></li> 
 <li class="wordpress"><a class="externalLink" href="http://www.akamud.com.br/">Blog</a></li> 
 <li class="rss"><a class="externalLink" href="http://www.akamud.com.br/feed">RSS</a></li> 
</ul>
<div class="section">       
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Maurice_Amsellem">Maurice Amsellem</h4>
<p>mamsellem (C+P)</p>
<p><img src="img/team/mamsellem.jpg" alt="mamsellem" class="img-circle about-image" /></p>
<p>Maurice has been working for <a class="externalLink" href="http://www.systar.com">Systar</a> since 1996 in various positions, and since 2009 as a software engineer on a Flex-based BAM application development framework.</p>
<p>Maurice is professionally interested in GUI design in general, and personally in clay modeling.</p>
<p>He is based in Paris area, France.</p>
<ul class="social-icons"> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/pub/maurice-amsellem/1/50a/b64">LinkedIn</a></li> 
</ul>
<div class="section">       
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Maxim_Solodovnik">Maxim Solodovnik</h4>
<p>solomax (C)</p>
<p><img src="img/team/solomax.jpg" alt="solomax" class="img-circle about-image" /></p>
<p>Maxim developing desktop and mobile applications working with video components.</p>
<p>The main contribution so far was Russian translation of various Flex components</p>
<p>He currently lives in Novosibirsk, Russia.</p>
<ul class="social-icons"> 
 <li class="github"><a class="externalLink" href="https://github.com/solomax">GitHub</a></li> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/solomax666">Twitter</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://www.google.com/+MaximSolodovnik">Google Plus</a></li> 
 <li class="linkedin"><a class="externalLink" href="https://www.linkedin.com/in/maximsolodovnik">Linkedin</a></li> 
</ul>
<div class="section">        
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Michael_Schmalle">Michael Schmalle</h4>
<p>mschmalle (C+P)</p>
<p><img src="img/team/mschmalle.jpg" alt="mschmalle" class="img-circle about-image" /></p>
<p>Past; ActionScript since 2001 and ui component developer. Created a read/write DOM for ActionScript in AS3 and Java, familiar with parsers and compilers.</p>
<p>Future; Working creating a framework to make synths and sequencers for techno music in Android and also Unity3D, WebAudio and JavaScript.</p>
<p>Leading the development of FalconJx to finally put the last nail in the Flash Player for myself.</p>
<p>I don’t claim to be anything I’m not, the third person scares me.</p>
<ul class="social-icons"> 
 <li class="github"><a class="externalLink" href="https://github.com/teotigraphix">GitHub</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/pub/michael-schmalle/4/409/980/">LinkedIn</a></li> 
 <li class="rss"><a class="externalLink" href="http://blog.teotigraphix.com/feed">RSS</a></li> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/teotigraphix">Twitter</a></li> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Nicholas_Kwiatkowski">Nicholas Kwiatkowski</h4>
<p>quetwo (C+P)</p>
<p><img src="img/team/quetwo.jpg" alt="quetwo" class="img-circle about-image" /></p>
<p>Working on components, website, marketing.</p>
<ul class="social-icons"> 
 <li class="facebook"><a class="externalLink" href="http://www.facebook.com/quetwo">Facebook</a></li> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/quetwo">Twitter</a></li> 
 <li class="blogger"><a class="externalLink" href="http://www.quetwo.com">Blogger</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/106376488955804514674/">Google Plus</a></li> 
 <li class="deviantart"><a class="externalLink" href="http://quetwo.deviantart.com">DeviantART</a> </li> 
</ul>
<div class="section">       
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Olaf_Krueger">Olaf Krueger</h4>
<p>okrueger (C)</p>
<p><img src="img/team/okrueger.png" alt="okrueger" class="img-circle about-image" /></p>
<p>Olaf believes in the power and beauty of simplicity in all respects.</p>
<p>Employed at a leading automotive supplier for hinge systems he creates software for internal use. For many years and still with great passion.</p>
<p>Olaf would like to help to bring the Material Design to Flex/FlexJS</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/openoli">Twitter</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Omar_Gonzalez">Omar Gonzalez</h4>
<p>s9tpepper (C+P)</p>
<p><img src="img/team/s9tpepper.jpg" alt="s9tpepper" class="img-circle about-image" /></p>
<p>Apache Flex committer and PMC member. Test driven development enthusiast. Wrestles code all day. Developing Flash since 2000, Flex since version 2 beta. Senior Architect for <a class="externalLink" href="http://almerblank.com" target="_blank">almer/blank</a> developing front-ends and back-ends in HTML5, JavaScript, Flash, Flex, Node.js, PHP, MySQL and MongoDB, just to name a few. Interested in expanding Apache Flex beyond the Flash Player plugin as well as other random experiments.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/s9tpepper">Twitter</a></li> 
 <li class="github"><a class="externalLink" href="https://github.com/s9tpepper">GitHub</a></li> 
 <li class="rss"><a class="externalLink" href="http://omar.gy/rss">RSS</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://plus.google.com/109288512951904372418">Google Plus</a></li> 
</ul>
<div class="section">     
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="OmPrakash_Muppirala">OmPrakash Muppirala</h4>
<p>bigosmallm (C+P)</p>
<p><img src="img/team/bigosmallm.jpg" alt="bigosmallm" class="img-circle about-image" /></p>
<p>Om ‘bigosmallm’ Muppirala is a UI architect with years of experience building Flex and Flash based applications. He has been working on various tools and utilities aimed at making life easier for Apache Flex developers and users(SDK Installer, OneClick Mustella, etc.) Also interested in contributing more web and mobile Flex components.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://twitter.com/bigosmallm">Twitter</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/omprakashm/">LinkedIn</a></li> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row columns columns4">
		<div class="span3">
			<h4 id="Peter_Elst">Peter Elst</h4>
<p>peterelst (C+P)</p>
<p><img src="img/team/peterelst.jpg" alt="peterelst" class="img-circle about-image" /></p>
<p>Peter is a Web Solutions Engineer at Google, an author of multiple ActionScript books, speaker at various industry events and longtime supporter of Flex as a platform.</p>
<p>In his spare time, you can find him blogging at <a class="externalLink" href="http://www.peterelst.com">www.peterelst.com</a>.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/peterelst">Twitter</a></li> 
 <li class="googleplus"><a class="externalLink" href="https://www.google.com/+peterelst">Google Plus</a></li> 
 <li class="linkedin"><a class="externalLink" href="http://www.linkedin.com/in/peterelst">Linkedin</a></li> 
</ul>
<div class="section">      
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Piotr_Zarzycki">Piotr Zarzycki</h4>
<p>piotrz (C+P)</p>
<p><img src="img/team/piotrz.jpg" alt="piotrz" class="img-circle about-image" /></p>
<p>Piotr has been working with Flex since 2008 in various project. He always stays open for self-development opportunity.</p>
<p>He currently lives in Cracow, Poland.</p>
<ul class="social-icons"> 
 <li class="linkedin"><a class="externalLink" href="http://pl.linkedin.com/pub/piotr-zarzycki/52/535/92a/">Linkedin</a></li> 
 <li class="skype"><a href="skype:zarzycki10?call">Skype</a></li> 
</ul>
<div class="section">    
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Stephan_Plath">Stephan Plath</h4>
<p>splath (C)</p>
<p><img src="img/team/splath.jpg" alt="splath" class="img-circle about-image" /></p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/xplath">Twitter</a></li> 
</ul>
<div class="section">       
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span3">
			<h4 id="Tom_Chiverton">Tom Chiverton</h4>
<p>tomc (P+C)</p>
<p><img src="img/team/tomc.jpg" alt="tomc" class="img-circle about-image" /></p>
<p>Tom has been building internet applications since before the term RIA, and was part of the community contributing to Flex while it was looked after by Adobe.</p>
<p>Within Apache Flex his focus is on making sure the experience on Linux is on par with the other supported platforms, as well as pitching in keeping the Jenkins servers running.</p>
<p>He currently lives in Manchester, UK.</p>
<ul class="social-icons"> 
 <li class="twitter"><a class="externalLink" href="http://www.twitter.com/thefalken">Twitter</a></li> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row">
		<div class="span12">
			<div class="body-content">
				<h1>Our Mentors</h1>
			</div>
		</div>
	</div>
	<div class="row columns columns3">
		<div class="span4">
			<h4 id="Bertrand_Delacretaz">Bertrand Delacretaz</h4>
<p>bdelacretaz (C+P)</p>
<p><img src="img/team/bdelacretaz.jpg" alt="bdelacretaz" class="img-circle about-image" /></p>
<p>I’m happy to have been able to help Flex incubate at Apache, the team did a great job in creating a successful Apache project. I left the PMC on graduation to free some time for other podlings, wishing Flex a bright future!</p>
<ul class="social-icons"> 
</ul>
<div class="section">      
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span4">
			<h4 id="Dave_Fisher">Dave Fisher</h4>
<p>Project Mentor wave (C+P)</p>
<p><img src="img/team/wave.jpg" alt="wave" class="img-circle about-image" /></p>
<p>I’m fascinated by the communities that develop around projects at Apache I really enjoy the spirit here in the Apache Flex project. I am particularly interested in documents and am on the Apache POI and OpenOffice PMCs. Apache Flex for office documents anyone?</p>
<p>I live in San Francisco where the weather is mild.</p>
<ul class="social-icons"> 
</ul>
<div class="section">    
 <!-- Social Icons -->  
</div>
		</div>
		<div class="span4">
			<h4 id="Greg_Reddin">Greg Reddin</h4>
<p>Project Mentor greddin (C+P)</p>
<p><img src="img/team/default-male.jpg" alt="greddin" class="img-circle about-image" /></p>
<ul class="social-icons"> 
</ul>
		</div>
	</div>
	<div class="row">
	</div>
	<div class="row">
		<div class="span12">
			<div class="body-content">
				<h1>Not pictured above:</h1>
<p>Bruno Pacola (C), Cosma Colanicchia (C), Christophe Herreman (C+P), Chuck Mastrandrea (C+P), Cyrill Zadra (C+P), Darrell Loverin (C), Ryan Frishberg (C+P), Igor Costa (C+P), Iwo Banas (C+P), Jeff Tapper (C+P), Jo&atilde;o Fernandes (C), Judah Frangipane (C), Jonathan Campos (C), Kevin Godell (C), Kevin Korngut (C+P), Michael Labriola (C+P), Leif Wells (C+P), Sebastian Mohr (C+P), Martin Heidegger (C+P), Mihai Chira (C+P), Michael Jordan (C+P), Mark Kessler (C+P), Michelle Yaiser (C+P), Neil Madsen (C), Peter Ent (C+P), Rui Silva (C+P), Roland Zwaga (C), Scott Guthmann (C+P), Scott Delamater (C+P), Stephen Downs (C+P)</p>
			</div>
		</div>
	</div>
	</div>

	</div><!-- /container -->

	<!-- Footer
	================================================== -->
	<footer class="well">
		<div class="container">
			<div class="row">
				<div class="span4 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">About Flex</li>
						<li >
							<a href="about-whatis.html" title="What is Flex?">What is Flex?</a>
						</li>
						<li >
							<a href="about-features.html" title="Features">Features</a>
						</li>
						<li >
							<a href=".html" title="Tour de Flex">Tour de Flex</a>
						</li>
						<li >
							<a href="about-licensing.html" title="License & Trademarks">License & Trademarks</a>
						</li>
						<li class="active">
							<a href="#" title="The Team">The Team</a>
						</li>
						<li >
							<a href="about-history.html" title="Project History">Project History</a>
						</li>
						<li >
							<a href="about-assets.html" title="Logo and Assets">Logo and Assets</a>
						</li>
						<li class="nav-header">Community</li>
						<li >
							<a href="community-getinvolved.html" title="How to get involved">How to get involved</a>
						</li>
						<li >
							<a href="community-mailinglists.html" title="Mailing Lists">Mailing Lists</a>
						</li>
						<li >
							<a href="community-showcase.html" title="Flex Showcase">Flex Showcase</a>
						</li>
						<li >
							<a href="community-3rdparty.html" title="Third-Party">Third-Party</a>
						</li>
						<li >
							<a href="https://cwiki.apache.org/confluence/display/FLEX/Apache+Flex+Wiki" title="Wiki" class="externalLink">Wiki</a>
						</li>
						<li >
							<a href="http://blogs.apache.org/flex/" title="Blog" class="externalLink">Blog</a>
						</li>
					</ul>
				</div>
				<div class="span4 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Development</li>
						<li >
							<a href="dev-faq.html" title="Developer FAQ">Developer FAQ</a>
						</li>
						<li >
							<a href="dev-sourcecode.html" title="Source Code">Source Code</a>
						</li>
						<li >
							<a href="https://issues.apache.org/jira/browse/FLEX" title="Bug-Tracker" class="externalLink">Bug-Tracker</a>
						</li>
						<li class="nav-header">Documentation</li>
						<li >
							<a href="doc-getstarted.html" title="Getting Started">Getting Started</a>
						</li>
						<li >
							<a href="doc-videos.html" title="Videos">Videos</a>
						</li>
						<li >
							<a href=".html" title="Flex ASDocs">Flex ASDocs</a>
						</li>
						<li >
							<a href=".html" title="FlexJS ASDocs">FlexJS ASDocs</a>
						</li>
						<li >
							<a href="http://help.adobe.com/en_US/flex/using/index.html" title="Documentation Reference (Old)" class="externalLink">Documentation Reference (Old)</a>
						</li>
						<li >
							<a href=".html" title="FlexUnit Tutorials">FlexUnit Tutorials</a>
						</li>
						<li >
							<a href=".html" title="FlexUnit ASDocs">FlexUnit ASDocs</a>
						</li>
						<li >
							<a href="doc-website.html" title="Contributing to the Flex Website">Contributing to the Flex Website</a>
						</li>
					</ul>
				</div>
				<div class="span4 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">About Apache</li>
						<li >
							<a href="http://www.apache.org" title="The Apache Software Foundation Website" class="externalLink">The Apache Software Foundation Website</a>
						</li>
						<li >
							<a href="http://www.apache.org/foundation/contributing.html" title="Donations" class="externalLink">Donations</a>
						</li>
						<li >
							<a href="http://www.apache.org/foundation/sponsorship.html" title="Sponsorship" class="externalLink">Sponsorship</a>
						</li>
						<li >
							<a href="http://www.apache.org/foundation/thanks.html" title="Thanks" class="externalLink">Thanks</a>
						</li>
						<li class="nav-header">Download Flex</li>
						<li >
							<a href="download-installer.html" title="SDK Installer (For Application Developers)">SDK Installer (For Application Developers)</a>
						</li>
						<li >
							<a href="download-source.html" title="SDK Source Code (For SDK Developers)">SDK Source Code (For SDK Developers)</a>
						</li>
						<li >
							<a href="download-binaries.html" title="SDK Binaries (For SDK Developers)">SDK Binaries (For SDK Developers)</a>
						</li>
						<li >
							<a href="download-flexjs.html" title="FlexJS 'beta' (For Application Developers)">FlexJS 'beta' (For Application Developers)</a>
						</li>
						<li >
							<a href="download-flexunit.html" title="FlexUnit (For Application Developers)">FlexUnit (For Application Developers)</a>
						</li>
						<li >
							<a href="download-blazeds.html" title="Blaze DS Source Code">Blaze DS Source Code</a>
						</li>
						<li >
							<a href="download-tourdeflex.html" title="Tour De Flex Source Code">Tour De Flex Source Code</a>
						</li>
						<li >
							<a href="download-squiggly.html" title="Squiggly Spell Checker">Squiggly Spell Checker</a>
						</li>
						<li >
							<a href="download-utilities.html" title="Flex Utilities">Flex Utilities</a>
						</li>
						<li >
							<a href="download-archive.html" title="Previous Versions">Previous Versions</a>
						</li>
					</ul>
				</div>
			</div>
		</div>
	</footer>

	<div class="container subfooter">
		<div class="row">
			<div class="span12">
				<p class="pull-right"><a href="#">Back to top</a></p>
				<p class="copyright">Copyright &copy;2016 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All Rights Reserved.</p>
				<p><a href="http://github.com/andriusvelykis/reflow-maven-skin" title="Reflow Maven skin">Reflow Maven skin</a> by <a href="http://andrius.velykis.lt" target="_blank" title="Andrius Velykis">Andrius Velykis</a>.</p>
			</div>
		</div>
	</div>

	<!-- Le javascript
	================================================== -->
	<!-- Placed at the end of the document so the pages load faster -->
	<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

	<script src="./js/bootstrap.min.js"></script>
	<script src="./js/lightbox.min.js"></script>
	<script src="./js/reflow-scroll.js"></script>
	<script src="http://yandex.st/highlightjs/7.5/highlight.min.js"></script>

	<script src="./js/reflow-skin.js"></script>

	</body>
</html>
