﻿<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Brainshare South Africa Report</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<p class="Header" >Brainshare South Africa Report </p>
<p> -- <a href="mailto:craigaa@openoffice.org">Craig A. Adams</a></p>
<p><a href="/.za/">OpenOffice.org Southern Africa</a></p>
<p>2004-06-01</p>
<p> <a href="http://www.novellevents.co.za">Brainshare South Africa</a> was held at the <a href="http://www.saconvention.co.za/">Sandton Convention Centre</a>, Nelson Mandela Square, Johannesburg, South Africa, from 26 to 28 May 2004. </p>
<p>The event was attended primarily by existing <a href="http://www.novell.com">Novell</a> customers and partners, which included a large contingent of national, regional and local government agencies. A Microsoft presence was also noted.
<p>OpenOffice.org was able to attend thanks to Novell sponsoring a stand for us. Marketing collateral was sponsored by Novell and <a href="http://www.thusa.co.za/">Thusa Business support</a>.
<p><a href="/.za/">OpenOffice.org Southern Africa</a> and the <a href="http://www.lpa.org.za/">Linux Professionals Association</a> (LPA) cooperated with each other for this event by sharing staff and equipment. Mark Stockton of the LPA and I were the two permanent people present, with various other people manning the stand on a roster basis. This roster allowed me to circulate during the conference, but the demands of dealing with OpenOffice.org queries prevented me from attending all but the final keynote address.</p>
<p>Being a Novell event, it was squarely focused on Novell products and road-maps with a great deal of emphasis on OpenOffice.org and, naturally, Novell - <a href="http://www.ximian.com/">Ximian</a> - <a href="http://www.suse.com/">SuSE Linux</a>. Novell have committed themselves to utilising OpenOffice.org as a migration solution and took every opportunity to expound on the capabilities of the suite. It was gratifying to see that a number of Novell presentations incorporated content derived from materials prepared by Erwin Tenhumberg, myself, and others (of course, all material was presented with appropriate attribution).</p>
<p><a href="http://www.oracle.com/">Oracle</a> was also on hand to express their commitment to Open Source Software (OSS) and demonstrate some of their technology. This included their Collaboration Suite which provides some integration with OpenOffice.org. Similarly, <a href="http://www.intoweb.co.za/">IntoWeb</a> demonstrated their web based virtual help-desk and training solution. This software allows on-line, intranet based, OpenOffice.org training and testing of staff in addition to electronic help-desk capabilities.</p>
<p>As with most of these conferences, I was surprised at the degree of uptake and adoption of OpenOffice.org by companies, non-profit organisations, and various national, provincial and local government departments. Very few people or organisations feed information or news regarding their adoption of OpenOffice.org back to the project. This is mainly due to the fact that there are no licence sales to track and that some large organizations prefer to keep a low profile. I am, in fact, aware of a few large adoptions of OpenOffice.org in South Africa, but I am forbidden to name or discuss these in detail.</p>
<p>There were a large number of enquiries regarding the availability of a WordPerfect filter, in answer to which I pointed people to the libwpd and WriterPerfect filters developed by the <a href="http://wp.openoffice.org/"> WP Project</a>. These demands were not surprising, as WordPerfect has been very popular amongst government agencies in South Africa throughout the years.</p>
<p>In Conclusion...</p>
<p>Besides having one of our valuable banners stolen after the main party (it was later surreptitiously returned), the conference went off without any serious issues, events or surprises. Of particular anecdotal interest, was the news that one home user had developed a horse racing system for OpenOffice.org and was selling it to friends. Apparently her system's success rate is nearly 80%.</p>
<p>The conference, overall, was fun, exhausting, informative, and full of some interesting experiences. While it's pleasing to see so much interest in, and adoption of, OpenOffice.org, it is also a constant source of frustration to track it all. So, if you are a Southern African based company uses, or plans to use OpenOffice.org, please let me know.</p>
<p>&nbsp;
<p class="Header">About the author</p>
<p>Craig Adams is the Marketing Project Lead for Southern Africa and continuously strives, within a morass of apathy, to market OpenOffice.org to anyone and everyone, particularly in South and Southern Africa. Whenever possible, Craig tries to attend conferences and exhibitions as a representative of the OpenOffice.org Project, preaching to the converted and evangelising to the oblivious and unwary.</p>
<p>The Southern African Marketing Project maintains the <a href="/.za/">www.openoffice.org.za</a> portal which, optimistically, provides useful information relevant to the local market including links to various types of distributor, consultant and training services.</p>
<p>The Southern African Marketing Project is also the bane of <a href="http://www.translate.org.za/">Translate.org.za</a> which has shouldered the task of translating numerous <a href="http://www.opensource.org/">Open Source</a> and <a href="http://www.fsf.org">Free Software</a> projects into a huge number of Southern African languages.
</body>
</html>
