<boardmember id="cunningham" type="addin">

	<name>John Cunningham</name>

	<title>Managing Partner &amp; Founder, Band XI International</title>

	<image>cunningham.jpg</image>

	<email>jc@bandxi.com</email>

	<eclipse_affiliation> <![CDATA[
		Eclipse Solutions Member
	]]> </eclipse_affiliation>

	<vision>  <![CDATA[
		My focus over the past ten years has been applying Eclipse to solve problems in various domains, participating in <i>EclipseCon</i> and <i>Eclipse Summit Europe</i>, but otherwise maintaining a low profile. So, I won’t be at all offended if you’re asking yourself, <i>"Who is this guy?  He doesn’t commit, he isn’t on the forums, etc."</i>.  Within the Eclipse Community, the glory rightly goes to the <i>committers</i>, because they make all of our work possible. Nevertheless, there is also a place for the Solutions Members to have a voice and I’ve been asked to contribute mine to the discussion.
		<br><br>
		I’ve watched Eclipse grow and adapt from the internal corporate skunkworks project <i>LeapFrog</i>, that we adopted early for embedded Java development, into the world’s gold standard for open source, community based development. Eclipse provides so much more than just a tooling platform. For example our firm, Band XI, used Eclipse as the runtime platform for implementing <i>Cyrano</i>, our award winning <i>2008 Best Equinox Application</i> which enabled first responders to connect hazardous materials sensors together for distributed situational awareness. We’ve since done much more with Eclipse as a runtime platform, including using Eclipse to monitor and control heavy mining and construction equipment. As a small company that engineers demanding embedded applications, we have learned many lessons that drive how we use and view Eclipse. We have shared many of our best practices by delivering OSGi workshops at EclipseCon, demonstrating applications at BoF’s and DemoCamps, speaking about some of the lessons learned, and contributing back to the community with code fixes, patches, and samples. 
		<br><br>
		Going forward, I see the vitality and relevance of the Eclipse community growing richer by leading the establishment of new best practices and offering model reference implementations by emphasizing the following:
		<ul>
			<li><b>Deliver Vertical Reach:</b> Continue extending Eclipse into vertical domains that offer reference implementations that showcase Eclipse experts’ best practices for runtime and component architectures so that domain experts can focus on their hard domain problems.</li>
			<li><b>Entrench Runtime Platforms:</b> Establish Eclipse as the <i>de facto</i> robust, scalable, runtime infrastructure on mainstream platforms, from embedded to enterprise systems, to ensure Eclipse’s vitality as more than just a tooling platform for developers.</li>
			<li><b>Reward Innovation:</b> Develop new business models through which innovators, whether individuals or firms, are duly incentivized to share their creations with the Eclipse community. Markets are tough - and the balance of community participation seems to be shifting from larger players to smaller players, so we need to ensure that the rewards of innovation and leadership help the smaller players grow to be larger, so they can in turn bootstrap future innovators.</li>
			<li><b>Look Beyond Java:</b> Although much of what we have done to date relies on Java/OSGi, we’ve begun to look beyond single programming language solutions and see offerings like DLTK and e4 as strategically important elements of future architectures. The community needs these platforms to become first class offerings that are as mature, robust, rich, and capable as the Java tools and runtimes that we use as a reference point.</li>
		</ul>
		Eclipse continues to adapt and grow in response to the demands of the markets and the community. This evolution stems from the quality of the people who comprise the Eclipse community, combining a passion for achievement and a respect for process. Balancing results and process demands a special commitment that seems increasingly rare. Taking an <i>ends justifies the means</i> approach at one extreme destroys community. A navel gazing overemphasis on process results in sclerotic bureaucracy. Both extremes stifle innovation, collaboration, learning, and the overall positive environment that attracts the best and the brightest to join a community. Striking a balance demands good citizenship – respect for the processes, respect for people and their property, readiness to contribute to the community, and a willingness to communicate candidly and politely. The Eclipse Foundation accomplishes this goal remarkably well and I would be honored to serve as a representative to the community with these values and the abovementioned goals in mind.
	]]> </vision>

	<bio> <![CDATA[
		John Cunningham brings a results-oriented, ship-it-on-time pragmatism developed over a quarter century of experience engineering software solutions on platforms ranging from mainframes to embedded controllers. His formal training in mechanical engineering and finance inform his approach to problem solving, where he strives to find repeatable, reliable, cost effective solutions to complex problems.
		<br><br>
		John began his career in New York City as a consultant at Andersen Consulting (now Accenture) and Computer Sciences Corporation (CSC) spearheading the adoption of object-oriented technologies, particularly Smalltalk, within the financial services and utilities industries, before moving on to a line management position at Travelers Insurance to do the same with accountability and a sense of ownership over the outcomes. In the mid 1990’s, he joined Object Technology International (OTI) and was eventually adopted by IBM. It was at OTI that John began to absorb the lessons in software engineering best practices from many of the industry's leading lights and best-kept secrets. For over a decade, Mr. Cunningham served in project leadership roles within IBM, working on financial services, automotive, and embedded Java projects in North America, Europe, and Asia. 
		<br><br>
		In 2005, his desire to construct a dynamic, agile environment for bright, passionate problem solvers led him to start Band XI International together with Brett Hackleman. The firm immediately joined the Eclipse Foundation, believing that participating in the community was essential to their strategic vision. Band XI has been developing embedded systems for defense, mining, construction, asset tracking, health care, and content management domains during its short existence. Most recently, the company spun off Bad Elf, LLC, a purveyor of niche hardware accessories for the iOS platform (iPad/iPod/iPhone).
		<br><br>
		As a small company, Band XI has limited resources that have been largely focused on serving customers. However, they have always understood that satisfying and retaining customers has rested on the leverage afforded by an affiliation with the Eclipse Foundation. The Eclipse Runtime platform critically enabled commercialization of early R&D efforts to applications in the defense, mining, construction, and telematics domains. Band XI contributed back requirements, usage scenarios, patches, fixes, and example code for the Plugin Development Environment and Equinox. From the beginning, modular software and component design has been their focus, enabling them to do more with less, whether in Smalltalk, Java, or any of the dynamic languages that are gaining currency. Band XI is proud of Paul VanderLei’s contributions, in collaboration with Jeff McAffer and Simon Archer, to showcase these best practices in their OSGI & Equinox book, and the associated code base that is available through Eclipse.
		<br><br>
		Mr. Cunningham earned his BS from Columbia University’s School of Engineering and Applied Science (SEAS), MSME from the University of Massachusetts at Amherst, and an MBA in Finance from the University of Connecticut School of Business. He continues an active role in Columbia’s engineering school community, interviewing applicants for admissions and serving as co-President of the Parents’ Council while monitoring the activities of his two daughters (SEAS ‘12, ‘14).
	]]> </bio>

	<affiliation> <![CDATA[ 
		Band XI International, LLC
	]]>
	</affiliation>
		
</boardmember>