﻿<html>
<head>
<title>Interview: Alberto Escudero, Open Swahili Localization Project</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<h2>Interview: Alberto Escudero, klnX: The Open Swahili Localization Project</h2>
<p><a href="../lspintro.html">-Louis Suárez-Potts</a></p>
<p>2004-10-25</p>
<p>&nbsp; </p>
<p>Alberto Escudero leads <a href="http://www.kilinux.org/">kInX: Open Swahili Localization Project</a>, which is committed to localizing OpenOffice.org and other open technologies to Swahili, the lingua franca of East Africa. This interview was conducted via e-mail over a couple of days earlier this week.</p>
<p>&nbsp;</p>
<p><em>Your background is interesting and by no means conventional. You received your doctorate in</em> <em>Sweden and now find yourself in Dar es Salaam. What explains the trajectory? And, how did you get involved in the Open Swahili Localization Project?</em> </p>
<p> I have been always very interested in the interaction of humans and technology. I never saw the technology as a goal but rather as a tool for social change. </p>
<p> My involvement with Internet and computers was a lucky &quot;mistake&quot;: I was growing vegetables and I needed some information in how to get rid of some bugs so I ended up dialing to a non-profit BBS in Spain. I got so attracted the idea of the freedom of information in Internet that I worked for some years making that small BBS the largest non-profit ISP in Spain (Nodo50). </p>
<p> During the last ten years, my main concern was not to become a &quot;geek&quot; :-D There seemed to be lots of "free" and challenging work to do for people with technical and human skills so I ended up working in all layers of the "OSI" model, from building wireless infrastructure in Laos or fixing remotely security holes in a ISP in Senegal to localizing open-source software in Tanzania. </p>
<p> I got a Master of Science in renewable energies and a PhD in Internet security and privacy. Localizing Open Source Software to Swahili was obviously a natural step, right? </p>
<p>&nbsp;</p>
<p><em> Tell us about the project--its goals, its composition. Who is working on it? </em></p>
<p> The project's main "technical" goal for this first year is to get both OpenOffice.org and Mozilla localized into the Swahili language. There are many milestones to be accomplished as creating the IT glossary, provide the training and establishing a sustainable team. In the core team we have twelve people, half of them working with the localization itself and the other half dealing with the linguistic aspects. Most members are from the University of Dar es Salaam. </p>
<p> The Swedish International Development Agency (SIDA) is funding most of the project. A big part of the coordination is done by my company IT+46, which is donating a considerable amount of resources to make this happen. </p>
<p>&nbsp;</p>
<p><em> What makes Swahili so important? </em></p>
<p> Swahili is the most widely spoken Bantu language, it is the official language of Tanzania and Kenya and widely used as a lingua franca in East and Central Africa. We are talking about 55 million people here. </p>
<p>&nbsp;</p>
<p><em> The project has had impressive successes. For instance, earlier this month you released "Jambo OpenOffice build 6," as well as the Swahili IT glossary! Both are considerable accomplishments and both are open source, with the glossary released under one of the increasingly popular <a href="http://creativecommons.org/about/licenses/">Creative Commons licenses</a>. What sort of work went into creating the glossary? </em></p>
<p> Our methodology can be summarized in three phases: </p>
<ul>
  <li> During the first phase a selected list of IT terms were sent to our panel of Kiswahili experts. To encourage discussions, the members of the panel were requested to work with the list of terms separately. </li>
  <li> The second phase consisted in compiling all the different inputs from the panel into a database. With the help of the database and other auxiliary online resources, we have had a set of face-to-face meetings where the terms where discussed in the presence of computer scientists. Our multidisciplinary group composed by an average of ten people has spent a total of 30 hours in face-to-face meetings. </li>
  <li> The last phase before a broad release of the IT Glossary to the public domain consisted in requesting a small group a "grading" of our proposal. </li>
</ul>
<p>&nbsp;</p>
<p><em>And, how do you work with the OpenOffice.org community and project? </em></p>
<p> That has a simple answer, the Open Swahili Localization Project (klnX) would not exist without the community. I have never seen such a group of committed 'busy' people helping in all aspects of our project. We have received support and advice from all over the world. We actually try not to forget anyone and we have a section in our website to acknowledge all of them. </p>
<p> We have receive help from Sweden, United States, Norway, Czech Republic, South Africa, Cambodia, Malawi and Tanzania. <a href="http://www.kilinux.org/kiblog/ack.html">http://www.kilinux.org/kiblog/ack.html</a>. Thanks again. </p>
<p>&nbsp;</p>
<p><em> Your work with OpenOffice.org raises a corollary point. Would you want a Swahili project established in the OpenOffice.org manifold? </em></p>
<p> Yes, indeed. There is still an endless amount of work to do, such as creating a network of people around the project. Unfortunately here in Tanzania things are not as simple like in another parts of the world. Simple things need time, there are power cuts, limited bandwidth and and a lack of skilled human resources, etc. </p>
<p>&nbsp;</p>
<p><em> The work you and your team has done is impressive, it is, however, but a start. Do your team plan on handling more substantial coding? </em></p>
<p> I do not think that the klnX team is ready to contribute code to OpenOffice today. We are focusing in creating tools to help the localization, we need software in Swahili first and the skills needs to be communicated with Swahili software. </p>
<p> Nevertheless, IT46 is releasing 'KiPot' an online tool to facilitate glossary development to the community this week under GPL. Keep an eye on: <a href="http://www.it46.se/kipot/">http://www.it46.se/kipot/</a></p>
<p>&nbsp;</p>
<p><em> We (OpenOffice.org) have begun work, as you may know, with various university groups. The idea is to get students to learn coding, localization, etc., with OOo--the source and project. They would get college credit for the work they do, while learning invaluable skills from the best developers in the world. Are you interested? </em></p>
<p> I am definitely interested, and I believe that through localization work the others skills can be developed as well. </p>
<p>&nbsp;</p>
<p><em> Back to Jambo OpenOffice... Can you tell us something about it? I presume it is OpenOffice.org modified. is it? If so, in what way has it been modified? Have the patches, changes, been contributed back to OpenOffice.org? On what platforms does it run? </em></p>
<p> Jambo OpenOffice is just our internal build of OpenOffice 1.1.3 under Linux. The builds are done to support our localization work. We want to see the results of the localization into the software as soon as possible so we have our build system here in Dar. The build system is based on Pavel Janík's build system , Translate.org.za localization tools and IT46's own hacks to integrate Swahili. </p>
<p> Pavel Janík, Dwayne Bailey and David Fraser have been of great help during this phase. A description of our build system environment will be contributed to OpenOffice.org community soon. </p>
<p>&nbsp;</p>
<p><em> Who do you expect to use a Swahili version of OpenOffice.org? That is, who are the beneficiaries?, and How do you envision the final build being distributed? </em></p>
<p> All Swahili speakers worldwide of course. </p>
<p> At the end of December 2004 we should have a pre-release of OO.o 1.1.3, final release is schedule for Q1 2005. Distribution will follow the traditional channels: 'net and CDs. </p>
<p>&nbsp;</p>
<p><em> I note you are receiving aid from a Swedish company, IT +46. Can you speak to its reasons for participating? Do you also receive government help? If so, from only the Tanzania government, or others? </em></p>
<p> IT+46 is the company that I founded to deal with the Swedish Tax Authorities. SIDA is funding some of the 'consulting work' that we are doing here. Unfortunately, it is more to do that we get funded for. No other governments are funding the project. </p>
<p> So, why IT+46 is doing this? We (my partner and myself) can cover our costs and do something that we believe in. No great business but definitely something that we can tell our grandchildren about. After saying this, i can not avoid saying that funding for our 'free' work is still welcome so we can do other 'free' work. </p>
<p>&nbsp;</p>
<p><em> Okay, final question: How can we help you?</em></p>
<p>I will like to have the chance to get all the localization teams together to work face-to-face in technical and social issues. They are welcome in Tanzania. We still need to get a build system for other platforms that are not Linux. Hardware? Software? </p>
<p> But if you want something very concrete: send us lots of OpenOffice T-shirts to Dar es Salaam, so people start to see that Jambo Office is coming soon.</p>
<p>&nbsp; </p>
<p><a href="index.html">Back to Editorial Index</a></p>
</body>
</html>
