<html>
<head>
<title>Interview: Alexandro Colorado, XpoLinux, Mexico</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<h2>Interview: Alexandro Colorado, Co-Lead Español Project </h2>
<p><a href="../lspintro.html">-Louis Suárez-Potts</a></p>
<p>2004-11-30</p>
<p>Early in November the city of Monterrey, Mexico, hosted the XpoLinux conference in the impressive Cintermex hall. With over 25 booths and three days of technical and general presentations, hundreds of visitors and attendees, the conference was a significant success. Thanks go to Alexandro Colorado, David Granados, and their team for putting on the project, arranging panels, presentations, meetings, discussions, and everything else that goes toward making a successful conference. I was fortunate to present at the conference on OpenOffice.org, and I thank Alexandro for making that possible. We all look forward to next year, and expect the conference in 2005 to be even more important. Why? Because it is time, even necessary for Mexico to recognize open source.</p>
<p>(For a good (English) account of the conference, see <a href="http://dot.kde.org/1100683960/">Duncan Mac-Vicar Prett's blog</a>.)</p>
<p>The following interview of Alexandro, who is the Co-Lead of the <a href="http://es.openoffice.org/index.html">Español or Spanish Language  Project</a> (ES) and a longtime member of OpenOffice.org, was conducted via email this November, after extensive in-person discussions. Questions and answers were in English.</p>
<p><em>Let's begin with the question I usually start with: Tell us about yourself, what you do with OpenOffice.org, and what you do outside of OpenOffice.org.</em></p>
<p>My involvement with OpenOffice.org started about two years ago. I realized one day that OpenOffice.org was the de facto application that all free software users will eventually use. Ever since then I started doing various work documenting the community and involving more with OpenOffice.org different projects which includes marketing, dba, xml, udk, marketing-education, native-lang, authors, website and of course OpenOffice.org Espa&ntilde;ol.</p>
<p>Outside of OpenOffice.org I am currently working in Romania for a company named <a href="http://www.interaktonline.com/">InterAKT</a>. I work as a marketing and sales representative. I use OpenOffice.org to generate reports and marketing research and papers. The company is very keen on open source and I am getting lots of experience with tech companies on development economies. I am currently on a one-year contract with them and after that I would be looking for other job and business opportunities in Europe or Asia ;-) </p>
<p><em>In conversation, you mentioned that open source is fairly marginal in Mexico. What explains that marginality?</em></p>
<p> The pressure Microsoft has put on our government to "sell-out" under the <a href="http://www.e-mexico.gob.mx/">project e-mexico</a>. E-Mexico is the program that pretends to massively move the Mexican society to the 'information age'; it works in conjunction with <a href="http://www.e-mexico.gob.mx/wb2/eMex/eMex_Ubica_tu_CCD">CCD</a>, which are in the same train of thought as the <a href="http://www.telecentros.sp.gov.br/english/index.php">Telecentros</a> in Brazil. However the Mexican version all run on Windows, as Mr. Gates <a href="http://www.infoworld.com/articles/hn/xml/02/06/12/020612hnemexico.html">donated</a> almost 500,000 licenses to the project. The contract between the Mexican government and Microsoft was published in <a href="http://www.cofradia.org/">Cofradia</a> (Mexican Slashdot) <a href="http://cofradia.org/modules.php?name=News&amp;file=article&amp;sid=11322">just a few weeks ago</a>. (The document was scanned under "Pagina *".) </p>
<p> This places Linux farther away from the Mexican market, simply because the size of this project represents a major shift in the way society participate in technology. Hopefully not all is lost, as companies such as <a href="http://www.linspire.com">Linspire</a> has, with significant success, taken the Linspire desktop to the masses, as they engage with serious technology vendors in Mexico such as <a href="http://www.linspire.com/espanol/hogar.php">Elektra</a>, even to the point of providing an announcement on national TV. Elektra also <a href="http://www.linspire.com/lindows_michaelsminutes_archives.php?id=114&amp;all=1">announced</a> selling all their stock on the Linspire PCs, which also caused more controversy in the community, as the Gartner report suggested that most PCs with Linux installed were then re-installed with pirated Windows. A great article that gets all the facts together was recently published stating how Mexico's trade with Microsoft is another '<a href="http://cainista.blogspot.com/2004/11/mandandose-un-kagazo.html">gold-for-mirrors</a>' (it has been said that the Aztec trade with spanish Conquistadores gold for mirrors). </p>
<p><em>In particular, you focused on the lack of a developer culture, such as exists, say, in Spain, or for that matter in Germany. What can be done by OpenOffice.org (OOo) to increase the depth of that culture?</em></p>
<ul>
  <li>Increase development documentation</li>
  <li>Online hacking courses on OOo</li>
  <li>Easy to access CVS</li>
  <li>Translation of code sources</li>
  <li>Develop RAD to extend OOo</li>
  <li>Push all this to the community </li>
</ul>
<p> As for the overall developer way of thinking: </p>
<ul>
  <li>Mexico has been lagging a lot on generating real developers. We have looked in depth at this problem and we found not just one reason but a whole array of scenarios that draw engineers to focus on non-developer tasks: </li>
  <li>Lack of demand for native development - Whether out of skepticism or plain anti-nationalism (<i>malinchismo</i>) companies prefer foreign development over local. This has to do with fear from efficiency of a local company (local developer companies might disappear with no extended support). </li>
  <li>Lack of math-related subjects - Some universities focus mainly on hardware, marketing and non-coding subject leaving students either with archaic development language (Pascal, Turbo-C) or with a mindset of (coding is hard). </li>
  <li>User vs. Developer - Even in the open source community, people tend to manage software rather than developing on it. Most guys just get stuck on 'advocacy' and never make the jump into real development. </li>
  <li>Lack of groupwork - Mexicans still need to learn how to work in groups; individuals are usually more effective than teams. </li>
</ul>
<p><em><a href="http://es.openoffice.org/">The ES Project</a> is very large and the center of all Spanish language development. It coordinates, thus, work being done in Spain, Mexico, Peru, and other parts of Latin America. As one of the leads, along with Richard Holt, of the project, what would you estimate are the most important issues facing it?</em></p>
<ul>
  <li>Lack of skilled developers. </li>
  <li>Valued content is buried deep in the website</li>
  <li>Poor navigability</li>
  <li>Page not accepting dynamic scripting making content very static and old </li>
  <li>Steep learning curve on hacking OpenOffice.org </li>
  <li>On-line bureaucracy (SSH2, access to CVS, lack of Linux machines from the dev. etc.) </li>
  <li>Not being able to help users in realtime has made it that many members give up trying to do even elemental enhancements like write-proofing the website. And translations are usually done through emailing content managers -- 'Richard [Holt] or me'. </li>
</ul>
<p><em>What countries in Latin America use open source?</em></p>
<p> Argentina, Chile, Peru, Bolivia, Cuba, Costa Rica, Uruguay, Brazil, </p>
<p> <em>What businesses in Mexico?</em></p>
<p> CFE (electricity company) is a very well known Linux user, PEMEX has been very skeptical but.... It's take on Linux has been conflicted, so.... Telmex has also been more friendly to Linux users, as the support team doesn't hesitate when you tell them you are running Linux for your connection. The problem is of course, lack of Linux companies, as they can't afford large-scale promotion and advertisement. (XpoLinux might be a THE solution.) </p>
<p><em>You were one of the key persons who organized the very successful XpoLinux conference; who was your partner?</em></p>
<p> David Granados was my partner in putting together the event; he did most of the dirty job of convincing people and companies to sponsor the event. I admire him a lot since even though XpoLinux demand a lot of his time he still manage to expand to new business ventures. </p>
<p><em> The conference targeted businesses. Do you think they got the message?</em></p>
<p> Testimonials have been great; and research done by Cintermex (the place we held XpoLinux) showed an outstanding 80% of people agreed to come next year. Also we found that more than 70% participants made some kind of business covering their expenses and are more than happy to sponsor next year's event. We also have got several proposals for new projects. We are currently working on some interesting projects that might just make XpoLinux bigger and better. We expect XpoLinux to keep making news beyond the actual event, as we will not only release a video of the event but also work on some XpoLinux-related side projects. </p>
<p><em>What would you want for the next conference?</em></p>
<p> XpoLinux was a unique event in many ways: it appealed both to businesses and students. For the next conference, we would like to show some "on-site" Linux solution. Most of the business people that attended the event knew something about Linux; others worked with Linux or were considering opportunities to move to Linux. But we need concrete examples. Having knowledgeable people explaining solutions and making economic sense out of deploying Linux will make their open source strategy easier to grasp. </p>
<p>I would also want more technical content that would appeal to the system administrators of companies. The SysAdmin is usually the key front-man to turn a company onto open source. Government should also be conscious about file accessibility, open standards. I'd like finally for there to be a taste of what is going on with open source and open formats across the world. </p>
<p>&nbsp; </p>
<p><a href="index.html">Back to Editorial Index</a></p>
</body>
</html>
