<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
	<meta HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
	<title></title>
	<meta NAME="GENERATOR" CONTENT="OpenOffice.org 1.9.130  (Unix)">
	<meta NAME="AUTHOR" CONTENT="Erwin Tenhumberg">
	<meta NAME="CREATED" CONTENT="20051012;11503700">
	<meta NAME="CHANGEDBY" CONTENT="Erwin Tenhumberg">
	<meta NAME="CHANGED" CONTENT="20051012;22521700">
	<style>
	<!--
		@page { size: 8.5in 11in; margin: 0.79in }
		P { margin-bottom: 0.08in }
		H1 { margin-bottom: 0.08in }
		H1.western { font-family: "Albany", sans-serif; font-size: 16pt }
		H1.cjk { font-family: "Mincho"; font-size: 16pt }
		H1.ctl { font-family: "Lucidasans"; font-size: 16pt }
		H2 { margin-bottom: 0.08in }
		H2.western { font-family: "Albany", sans-serif; font-size: 14pt; font-style: italic }
		H2.cjk { font-family: "Mincho"; font-size: 14pt; font-style: italic }
		H2.ctl { font-size: 14pt; font-style: italic }
	-->
	</style>
</head>
<body LANG="en-US" DIR="LTR">
<div ID="Table of Contents1" DIR="LTR">
	<div ID="Table of Contents1_Head" DIR="LTR">
		<p STYLE="margin-top: 0.17in; page-break-after: avoid"><font FACE="Albany, sans-serif"><font SIZE=4 STYLE="font-size: 16pt"><b>OpenOffice.org
		News Highlights (2004/2005)</b></font></font></p>
		<p ><strong><a href="ooo_news_2004_2005.odt">ODT</a> | <a href="ooo_news_2004_2005.pdf">PDF</a> </strong></p>
	</div>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.October 2005|outline">October
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Open Source Attracts Public Sector|outline">Open
	Source Attracts Public Sector</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Avanquest distributing StarOffice 8|outline">Avanquest
	distributing StarOffice 8</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Why multi-party stewardship of the OpenDocument Format matters so much|outline">Why
	multi-party stewardship of the OpenDocument Format matters so much</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.KOffice 1.4.2: Improved OpenDocument Support|outline">KOffice
	1.4.2: Improved OpenDocument Support</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.ISO to review OpenDocument as a standard|outline">ISO
	to review OpenDocument as a standard</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OASIS submits OpenDocument as standard|outline">OASIS
	submits OpenDocument as standard</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Microsoft 'must support OpenDocument'|outline">Microsoft
	'must support OpenDocument'</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.141,624 PCs with OpenOffice.org in China|outline">141,624
	PCs with OpenOffice.org in China</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.AbiWord gets OpenDocument support from Nokia|outline">AbiWord
	gets OpenDocument support from Nokia</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Microsoft denies PDF support is a reaction to Massachusetts decision|outline">Microsoft
	denies PDF support is a reaction to Massachusetts decision</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.RedMonk's Stephen O'Grady about Sun, Google and OpenOffice.org|outline">RedMonk's
	Stephen O'Grady about Sun, Google and OpenOffice.org</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Lenovo bundles StarOffice|outline">Lenovo
	bundles StarOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org &amp; Google's SOC|outline">OpenOffice.org
	&amp; Google's SOC</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.eWeek: 1xExcellent plus 3xGood for StarOffice 8|outline">eWeek:
	1xExcellent plus 3xGood for StarOffice 8</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.CRN: Five Stars for StarOffice 8|outline">CRN:
	Five Stars for StarOffice 8</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.September 2005|outline">September
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org 1.1.5 announced|outline">OpenOffice.org
	1.1.5 announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.SISSL retired|outline">SISSL
	retired</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Estonian Native-Lang project announced|outline">Estonian
	Native-Lang project announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.University of Toronto at Scarborough Standardizes on StarOffice for all Student Computing Resources|outline">University
	of Toronto at Scarborough Standardizes on StarOffice for all Student
	Computing Resources</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Commonwealth of Massachusetts moves to open document formats|outline">Commonwealth
	of Massachusetts moves to open document formats</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org distributed at state conference of lawyers|outline">OpenOffice.org
	distributed at state conference of lawyers</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.&quot;OpenOffice is great alternative to Microsoft&quot;|outline">&quot;OpenOffice
	is great alternative to Microsoft&quot;</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.&quot;Plan by 13 Nations Urges Open Technology Standards&quot;|outline">&quot;Plan
	by 13 Nations Urges Open Technology Standards&quot;</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Indonesia adopts the Java Desktop System (and StarOffice / OpenOffice.org) for its national open-source desktop|outline">Indonesia
	adopts the Java Desktop System (and StarOffice / OpenOffice.org) for
	its national open-source desktop</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org Conference 2005 in Koper / Capodistria, Slovenia|outline">OpenOffice.org
	Conference 2005 in Koper / Capodistria, Slovenia</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Raising the bar on patents and standards|outline">Raising
	the bar on patents and standards</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.August 2005|outline">August
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org announces version 2.0 public beta 2|outline">OpenOffice.org
	announces version 2.0 public beta 2</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.NeoOffice gets $25,000 donation|outline">NeoOffice
	gets $25,000 donation</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Linux pumps up fitness retailer's network, desktops|outline">Linux
	pumps up fitness retailer's network, desktops</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Kenosha Finds Big Savings in Linux|outline">Kenosha
	Finds Big Savings in Linux</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.CheckStatus.net Switches To Open Source|outline">CheckStatus.net
	Switches To Open Source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org distributed at state conference of lawyers|outline">OpenOffice.org
	distributed at state conference of lawyers</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Massive Linux handout set for French schools|outline">Massive
	Linux handout set for French schools</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.PC Magazine review OpenOffice.org 2.0 Beta|outline">PC
	Magazine review OpenOffice.org 2.0 Beta</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.&quot;OpenOffice.org 2.0 reviewed&quot;|outline">&quot;OpenOffice.org
	2.0 reviewed&quot;</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.FOSS word processors compared: OOo Writer, AbiWord, and KWord|outline">FOSS
	word processors compared: OOo Writer, AbiWord, and KWord</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Endorsement in the Chicago Tribune|outline">Endorsement
	in the Chicago Tribune</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Support for OASISOpenDocument format in eZ publish|outline">Support
	for OASISOpenDocument format in eZ publish</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Perl module for OASIS OpenDocument at CPAN|outline">Perl
	module for OASIS OpenDocument at CPAN</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.Juli 2005|outline">Juli
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org 1.1.5 Release Candidate Is Here|outline">OpenOffice.org
	1.1.5 Release Candidate Is Here</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.BharateeyaOO.o with Linux For You Magazine|outline">BharateeyaOO.o
	with Linux For You Magazine</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.New Community Contributor Representative|outline">New
	Community Contributor Representative</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org's third international conference announced|outline">OpenOffice.org's
	third international conference announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org at city of about 100,000|outline">OpenOffice.org
	at city of about 100,000</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org, FOSS, and the preservation of Gaelic|outline">OpenOffice.org,
	FOSS, and the preservation of Gaelic</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Vienna starts desktop Linux migration|outline">Vienna
	starts desktop Linux migration</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org at Australian community center|outline">OpenOffice.org
	at Australian community center</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Schools ink deal for open source|outline">Schools
	ink deal for open source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.New USB Flash Drive Sports Bootable OS, Office Apps|outline">New
	USB Flash Drive Sports Bootable OS, Office Apps</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Novell showcases OES|outline">Novell
	showcases OES</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org instead of Works|outline">OpenOffice.org
	instead of Works</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.[Beta Review] Openoffice.org 2|outline">[Beta
	Review] Openoffice.org 2</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice 2.0 Beta Review|outline">OpenOffice
	2.0 Beta Review</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.KDE Plugin in the Official OpenOffice.org Packages|outline">KDE
	Plugin in the Official OpenOffice.org Packages</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Xandros Business Desktop &amp; StarOffice|outline">Xandros
	Business Desktop &amp; StarOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Valuable Data Requires Open Formats|outline">Valuable
	Data Requires Open Formats</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.How Microsoft will try to get more money from Office users|outline">How
	Microsoft will try to get more money from Office users</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Taking the Lead in Security and Performance; New version of the TYPO3 Content Management System Released|outline">Taking
	the Lead in Security and Performance; New version of the TYPO3
	Content Management System Released</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Norway says yes to Open Source|outline">Norway
	says yes to Open Source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Microsoft looks to partners to force Office upgrades|outline">Microsoft
	looks to partners to force Office upgrades</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.June 2005|outline">June
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OOoCon 2005 Call For Papers|outline">OOoCon
	2005 Call For Papers</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.NeoOffice/J 1.1 Released!|outline">NeoOffice/J
	1.1 Released!</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Uno Runtime Environment (URE) released|outline">Uno
	Runtime Environment (URE) released</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Opening of an Eurasian Languages Native-Lang Group|outline">Opening
	of an Eurasian Languages Native-Lang Group</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Once more OpenOffice.org and Open Source Softwares on CDs in India|outline">Once
	more OpenOffice.org and Open Source Softwares on CDs in India</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Sun Microsystems' Donation of StarOffice(TM) Suite To Be Distributed Through Gifts In Kind International|outline">Sun
	Microsystems' Donation of StarOffice(TM) Suite To Be Distributed
	Through Gifts In Kind International</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Linux and other OSS helps connect rural African villages|outline">Linux
	and other OSS helps connect rural African villages</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Indian OpenOffice roll-out continues|outline">Indian
	OpenOffice roll-out continues</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Free Indian Language Software is Hot!|outline">Free
	Indian Language Software is Hot!</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.LT Scotland Introduces Gaelic Version of Office Applications Software|outline">LT
	Scotland Introduces Gaelic Version of Office Applications Software</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Trying OpenOffice|outline">Trying
	OpenOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Italian lawyers in love with open source|outline">Italian
	lawyers in love with open source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.RedMonk's Stephen O'Grady on the OASIS OpenDocument format|outline">RedMonk's
	Stephen O'Grady on the OASIS OpenDocument format</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.XML, one format to rule them all|outline">XML,
	one format to rule them all</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Sun Donates StarOffice to Non-Profits|outline">Sun
	Donates StarOffice to Non-Profits</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Coming Soon: MS Office Alternatives for Mac|outline">Coming
	Soon: MS Office Alternatives for Mac</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.May 2005|outline">May
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenDocument Format Formally Approved|outline">OpenDocument
	Format Formally Approved</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Members Approve OpenDocument as OASIS Standard|outline">Members
	Approve OpenDocument as OASIS Standard</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Azeri Native-Lang project announced|outline">Azeri
	Native-Lang project announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Polish Native-Lang Group announced|outline">Polish
	Native-Lang Group announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Detroit high school opens its desktops|outline">Detroit
	high school opens its desktops</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Sun signs StarOffice agreement for 4,000 Irish schools|outline">Sun
	signs StarOffice agreement for 4,000 Irish schools</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Open Source Software in Schools|outline">Open
	Source Software in Schools</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Open source makes school appointment|outline">Open
	source makes school appointment</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Local authorities keen on open source|outline">Local
	authorities keen on open source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Birmingham begins major open source pilot|outline">Birmingham
	begins major open source pilot</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Bristol ready to put open source on 3,500 desktops|outline">Bristol
	ready to put open source on 3,500 desktops</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Italian Automobile Club selects StarOffice (Italian articles only)|outline">Italian
	Automobile Club selects StarOffice (Italian articles only)</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Elite forces' health department trims operating costs|outline">Elite
	forces' health department trims operating costs</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Tamil Language Open Source Tools &amp; Apps Released in Chennai|outline">Tamil
	Language Open Source Tools &amp; Apps Released in Chennai</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Millions in India to get OpenOffice|outline">Millions
	in India to get OpenOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.StarOffice 8: Sun's Office Suite Takes on Microsoft|outline">StarOffice
	8: Sun's Office Suite Takes on Microsoft</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Product review, OpenOffice.org 2.0 beta|outline">Product
	review, OpenOffice.org 2.0 beta</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Review: OpenOffice a Strong Competitor|outline">Review:
	OpenOffice a Strong Competitor</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Lesson number one: get rid of Microsoft|outline">Lesson
	number one: get rid of Microsoft</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Ditching Microsoft can save millions|outline">Ditching
	Microsoft can save millions</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OO.o 2.0 pioneers new standard|outline">OO.o
	2.0 pioneers new standard</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.A Standard Set For The Office|outline">A
	Standard Set For The Office</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org File Viewer|outline">OpenOffice.org
	File Viewer</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.April 2005|outline">April
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org Conference 2005 - Please vote for the location!|outline">OpenOffice.org
	Conference 2005 - Please vote for the location!</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.NeoOffice/J Donates Code|outline">NeoOffice/J
	Donates Code</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Albanian Native-Lang project announced|outline">Albanian
	Native-Lang project announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Spreading OpenOffice Tamil|outline">Spreading
	OpenOffice Tamil</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.StarOffice at the Idaho National Laboratory (INL)|outline">StarOffice
	at the Idaho National Laboratory (INL)</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Small college saves big with OpenOffice.org and Linux|outline">Small
	college saves big with OpenOffice.org and Linux</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Why UK's Access Devices cooked up its own embedded open source OS|outline">Why
	UK's Access Devices cooked up its own embedded open source OS</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.StarOffice at the City of Marghera|outline">StarOffice
	at the City of Marghera</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.MIP Holdings moves most users to open source|outline">MIP
	Holdings moves most users to open source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.4,000 StarOffice licenses at SANG-HA|outline">4,000
	StarOffice licenses at SANG-HA</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.State govt logs on to cost-cutting drive|outline">State
	govt logs on to cost-cutting drive</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Thailand: The case for open source software|outline">Thailand:
	The case for open source software</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.DHBs to test open source alternative to Windows and Office|outline">DHBs
	to test open source alternative to Windows and Office</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.NZ open source trial attracts gov't attention|outline">NZ
	open source trial attracts gov't attention</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice 2.0 to break down walls to adoption|outline">OpenOffice
	2.0 to break down walls to adoption</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.First Look: OpenOffice.org 2.0 Looks Good|outline">First
	Look: OpenOffice.org 2.0 Looks Good</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Download some of the best software money can't buy|outline">Download
	some of the best software money can't buy</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice is a decent alternative|outline">OpenOffice
	is a decent alternative</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Ask Slashdot: OpenOffice vs. MS Office for Education_|outline">Ask
	Slashdot: OpenOffice vs. MS Office for Education?</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.IBM Certifies OpenDocument Successful Implementation|outline">IBM
	Certifies OpenDocument Successful Implementation</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OASIS Members to vote on OpenDocument XML Format|outline">OASIS
	Members to vote on OpenDocument XML Format</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Gentoo update for openoffice|outline">Gentoo
	update for openoffice</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.March 2005|outline">March
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org Announces Version 2.0 Public Beta|outline">OpenOffice.org
	Announces Version 2.0 Public Beta</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.First Native-Lang Group has been launched|outline">First
	Native-Lang Group has been launched</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Linux in Business and Governments: An Idea Whose Time Has Come|outline">Linux
	in Business and Governments: An Idea Whose Time Has Come</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.The case for open source software|outline">The
	case for open source software</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Availability of OpenOffice.org &amp; Staroffice Indexer for Google Dekstop Search|outline">Availability
	of OpenOffice.org &amp; Staroffice Indexer for Google Dekstop Search</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org Beta 2.0: Trouble for Microsoft|outline">OpenOffice.org
	Beta 2.0: Trouble for Microsoft</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.First look: OpenOffice.org version 2.0 beta|outline">First
	look: OpenOffice.org version 2.0 beta</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.A first look at OpenOffice.org 2.0|outline">A
	first look at OpenOffice.org 2.0</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Illuminata analyst on OpenOffice.org|outline">Illuminata
	analyst on OpenOffice.org</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.MS Office meets its match|outline">MS
	Office meets its match</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.February 2005|outline">February
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Winner, OpenOffice.org 2.0 Splashscreen competition|outline">Winner,
	OpenOffice.org 2.0 Splashscreen competition</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.L.A. mulls open source|outline">L.A.
	mulls open source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.LA Investigates Open Source To Cut Costs|outline">LA
	Investigates Open Source To Cut Costs</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.LinuxWorld preview: Open source rules, SCO fades and apps abound|outline">LinuxWorld
	preview: Open source rules, SCO fades and apps abound</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Sun Microsystems Hosts Annual Worldwide Education And Research Conference|outline">Sun
	Microsystems Hosts Annual Worldwide Education And Research
	Conference</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Vienna takes the boldest step of all - asking the users|outline">Vienna
	takes the boldest step of all - asking the users</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.7,000 OpenOffice.org users at Indian bank|outline">7,000
	OpenOffice.org users at Indian bank</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Banking on Indian ISVs|outline">Banking
	on Indian ISVs</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.2004 LinuxQuestions.org Members Choice Awards|outline">2004
	LinuxQuestions.org Members Choice Awards</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org database application: A first look review|outline">OpenOffice.org
	database application: A first look review</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Microsoft Office is too dangerous to leave with users|outline">Microsoft
	Office is too dangerous to leave with users</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.The Future Is Open: What OpenDocument Is And Why You Should Care|outline">The
	Future Is Open: What OpenDocument Is And Why You Should Care</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Analyst: MS Office Formats Not Open|outline">Analyst:
	MS Office Formats Not Open</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.StarOffice 8 goes beta|outline">StarOffice
	8 goes beta</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.New Sun StarOffice 8.0 Beta Looks a Lot Like Microsoft Office 2003|outline">New
	Sun StarOffice 8.0 Beta Looks a Lot Like Microsoft Office 2003</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.StarOffice 8 beta set to debut|outline">StarOffice
	8 beta set to debut</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.January 2005|outline">January
	2005</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OOoCon 2005 - Call for Location|outline">OOoCon
	2005 - Call for Location</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OOo version (1.9.71s1) on Mac OSX (X11/Mac OSX 10.3.4)|outline">OOo
	version (1.9.71s1) on Mac OSX (X11/Mac OSX 10.3.4)</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org 1.9m71 package for FreeBSD 5.3-RELEASE|outline">OpenOffice.org
	1.9m71 package for FreeBSD 5.3-RELEASE</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Venezuela opts for Linux|outline">Venezuela
	opts for Linux</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Enlaces To Install Linux in Chile Schools|outline">Enlaces
	To Install Linux in Chile Schools</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Linux gets warm reception in Chile|outline">Linux
	gets warm reception in Chile</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.EU's Open Source Observatory - Open Office in Naestved Municipality, Denmark|outline">EU's
	Open Source Observatory - Open Office in Naestved Municipality,
	Denmark</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Official Police migration|outline">Official
	Police migration</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.French police find open source arresting|outline">French
	police find open source arresting</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Vienna to softly embrace Linux|outline">Vienna
	to softly embrace Linux</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Viennese authority to push ahead with Linux plans|outline">Viennese
	authority to push ahead with Linux plans</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.StarOffice 7 Office Suite Momentum Scales New Heights|outline">StarOffice
	7 Office Suite Momentum Scales New Heights</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.UN project publishes free primer on open source software in education|outline">UN
	project publishes free primer on open source software in education</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice Prepares to Grow|outline">OpenOffice
	Prepares to Grow</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.December 2004|outline">December
	2004</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org Regional Conference North America|outline">OpenOffice.org
	Regional Conference North America</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.linux.conf.au OpenOffice.org Miniconf|outline">linux.conf.au
	OpenOffice.org Miniconf</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org goes Swahili|outline">OpenOffice.org
	goes Swahili</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org 1.1.4 Is Here|outline">OpenOffice.org
	1.1.4 Is Here</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Libertarian Linux goes mainstream|outline">Libertarian
	Linux goes mainstream</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Wal-Mart debuts $498 Linux laptop|outline">Wal-Mart
	debuts $498 Linux laptop</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.IT for free|outline">IT for free</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Dutch MPs fume over &pound;100m Microsoft contract|outline">Dutch
	MPs fume over &pound;100m Microsoft contract</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Dutch govt ends exclusive MS upgrade talks|outline">Dutch
	govt ends exclusive MS upgrade talks</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Africa Proving To Be Next Frontier for Free and Open Software|outline">Africa
	Proving To Be Next Frontier for Free and Open Software</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.DVA shops for open source Office|outline">DVA
	shops for open source Office</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.De Bortoli Wines gets a taste of Linux|outline">De
	Bortoli Wines gets a taste of Linux</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.NSW exam board tests Open Office|outline">NSW
	exam board tests Open Office</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Linux Makes Headway in Primary Education|outline">Linux
	Makes Headway in Primary Education</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Roundtable: City of Haarlem and OpenOffice.org|outline">Roundtable:
	City of Haarlem and OpenOffice.org</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice 2.0 preview released|outline">OpenOffice
	2.0 preview released</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice 2.0 Nears Beta Testing|outline">OpenOffice
	2.0 Nears Beta Testing</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.November 2004|outline">November
	2004</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org 1.1.3 with KDE integration|outline">OpenOffice.org
	1.1.3 with KDE integration</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Third-Annual Desktop Linux Summit Expands to Include Mozilla and OpenOffice.org Focus|outline">Third-Annual
	Desktop Linux Summit Expands to Include Mozilla and OpenOffice.org
	Focus</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.New web site for the Czech and Slovak OpenOffice.org users|outline">New
	web site for the Czech and Slovak OpenOffice.org users</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Basque localisation of OpenOffice.org 1.1.3|outline">Basque
	localisation of OpenOffice.org 1.1.3</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Announcing the OpenOffice.org Esperanto Native Language Project|outline">Announcing
	the OpenOffice.org Esperanto Native Language Project</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.New User Guide|outline">New User
	Guide</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Bristol City Council ditches MS for StarOffice|outline">Bristol
	City Council ditches MS for StarOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.UK tech specialist school pioneers open source switch|outline">UK
	tech specialist school pioneers open source switch</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Linux-based Scottish force continues its commitment to open-source|outline">Linux-based
	Scottish force continues its commitment to open-source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.100,000 desktops to OpenOffice|outline">100,000
	desktops to OpenOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OOo distributed by El Mundo|outline">OOo
	distributed by El Mundo</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Africa Becoming Vast Frontier for Free and Open Software|outline">Africa
	Becoming Vast Frontier for Free and Open Software</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Singapore Dumps Microsoft, Goes Open Source|outline">Singapore
	Dumps Microsoft, Goes Open Source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice is voted Best Value-for-Money Software by the most popular computer newspaper in Singapore|outline">OpenOffice
	is voted Best Value-for-Money Software by the most popular computer
	newspaper in Singapore</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Japan gives OK to Sun desktop suite|outline">Japan
	gives OK to Sun desktop suite</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.ITWeb : Microsoft price increase opens door for Open Office|outline">ITWeb
	: Microsoft price increase opens door for Open Office</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Sun Desktop goes back to school|outline">Sun
	Desktop goes back to school</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Munich's Linux plans attract international attention|outline">Munich's
	Linux plans attract international attention</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.CollabNet Helps OpenOffice.org Surpass 170,000 Registered Members|outline">CollabNet
	Helps OpenOffice.org Surpass 170,000 Registered Members</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.EC announces Open Standards Definition|outline">EC
	announces Open Standards Definition</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.PC Pro: Product Reviews: Labs: Office suites: OpenOffice 1.1.2|outline">PC
	Pro: Product Reviews: Labs: Office suites: OpenOffice 1.1.2</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.KDE and the Linux Journal 2004 Readers' Choice Awards|outline">KDE
	and the Linux Journal 2004 Readers' Choice Awards</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.European commission defines open standards|outline">European
	commission defines open standards</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.IBM, Microsoft, and Sun Respond to TAC Recommendation on Open Document Exchange Format|outline">IBM,
	Microsoft, and Sun Respond to TAC Recommendation on Open Document
	Exchange Format</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.European Union may soon endorse the Open Office file format|outline">European
	Union may soon endorse the Open Office file format</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.EU - Major software vendors ready to implement policy recommendations|outline">EU
	- Major software vendors ready to implement policy recommendations</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.MS Office 12's Competition: Its Older Versions and Linux Suites|outline">MS
	Office 12's Competition: Its Older Versions and Linux Suites</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Germans seek savings through Linux|outline">Germans
	seek savings through Linux</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Government starts to embrace open-source|outline">Government
	starts to embrace open-source</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.UK government report gives nod to open source|outline">UK
	government report gives nod to open source</a></font></p>
	<p STYLE="margin-top: 0.06in; margin-bottom: 0.06in"><font FACE="Albany"><font SIZE=4><b><a HREF="#0.October 2004|outline">October
	2004</a></b></font></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org 1.1.3 announced|outline">OpenOffice.org
	1.1.3 announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Bulgarian Native-Lang Project Announced|outline">Bulgarian
	Native-Lang Project Announced</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org development boosted by Arab and Israeli collaboration|outline">OpenOffice.org
	development boosted by Arab and Israeli collaboration</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org now available at CompUSA and TigerDirect.com|outline">OpenOffice.org
	now available at CompUSA and TigerDirect.com</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Bristol ponders switch to StarOffice|outline">Bristol
	ponders switch to StarOffice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Migration at Dover Grammar School for Boys|outline">Migration
	at Dover Grammar School for Boys</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Sun signs Interface for Opteron dealer push|outline">Sun
	signs Interface for Opteron dealer push</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.UK tech specialist school pioneers open source switch|outline">UK
	tech specialist school pioneers open source switch</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Germans claim Linux lowers costs|outline">Germans
	claim Linux lowers costs</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.OpenOffice.org at the City of Bergen, Norway|outline">OpenOffice.org
	at the City of Bergen, Norway</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Open approach offers Mindef more choice|outline">Open
	approach offers Mindef more choice</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Singapore government switches to OpenOffice.org |outline">Singapore
	government switches to OpenOffice.org </a></font>
	</p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.NSW opens door to Linux offers|outline">NSW
	opens door to Linux offers</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.An Open Road|outline">An Open Road</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Open for Business - The 2004 OfB Choice Awards|outline">Open
	for Business - The 2004 OfB Choice Awards</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Review: OpenOffice.org 1.9 m54|outline">Review:
	OpenOffice.org 1.9 m54</a></font></p>
	<p STYLE="margin-left: 0.2in; margin-top: 0.04in; margin-bottom: 0.04in">
	<font FACE="Albany"><a HREF="#0.0.Open Office XML May Satisfy ISO|outline">Open
	Office XML May Satisfy ISO</a></font></p>
</div>
<h1 CLASS="western"><a NAME="0.October 2005|outline"></a>October 2005</h1>
<h2 CLASS="western"><a NAME="0.0.Open Source Attracts Public Sector|outline"></a>
Open Source Attracts Public Sector</h2>
<p>“File format compatibility could prompt other public-sector CIOs
to consider similar moves, said Murugan Pal, founder and chief
technology officer of SpikeSource, which sells combinations of
open-source products and support licenses.</p>
<p>&quot;Two hundred years from now, organizations won't want to be
paying software royalties just so they can read documents that were
formatted in a variety of old formats,&quot; he said.</p>
<p>Even if OpenDocument isn't the prevailing format years from now,
developers will be able to easily create tools that understand it, he
said. &quot;The moment a format is not owned commercially, anybody
can create an interpreter to read that format,&quot; he added. ”</p>
<p><a HREF="http://www.toptechnews.com/story.xhtml?story_id=38621">http://www.toptechnews.com/story.xhtml?story_id=38621</a></p>
<h2 CLASS="western"><a NAME="0.0.Avanquest distributing StarOffice 8|outline"></a>
Avanquest distributing StarOffice 8</h2>
<p>“As part of the agreement, Avanquest will make StarOffice 8
software available to consumers throughout Europe, downloadable
versions of StarOffice 8 software will be available through Avanquest
Online stores in France, Belgium, Germany, Austria, Switzerland and
the UK. Online shoppers in Italy, Spain and Portugal will be able to
download the software from Avanquest Online by end-October, with the
retail boxed version of StarOffice 8 also available through more than
5,000 retail outlets Europe-wide by the end of the month.”</p>
<p><a HREF="http://sourcewire.com/releases/rel_display.php?relid=22927&amp;hilite">http://sourcewire.com/releases/rel_display.php?relid=22927&amp;hilite</a>=</p>
<h2 CLASS="western"><a NAME="0.0.Why multi-party stewardship of the OpenDocument Format matters so much|outline"></a>
Why multi-party stewardship of the OpenDocument Format matters so
much</h2>
<p>“Given ODF's multi-party stewardship, the ODF standard is far
more open to incorporating such changes than would be a single-party
controlled format since that single party may have other offerings
that are threatened by the enhancements.  Although such conflicts of
interest are not completely avoided by multi-party stewarded
standards, their likelihood is significantly reduced by the
transparency of the standards setting process.”</p>
<p><a HREF="http://blogs.zdnet.com/BTL/?p=2002">http://blogs.zdnet.com/BTL/?p=2002</a></p>
<h2 CLASS="western"><a NAME="0.0.KOffice 1.4.2: Improved OpenDocument Support|outline"></a>
KOffice 1.4.2: Improved OpenDocument Support</h2>
<p>&quot;Among various bugfixes and translation improvements, the
KOffice 1.4.2 release further improves support for the OASIS
OpenDocument file format and interoperability with OpenOffice.org.&quot;</p>
<p><a HREF="http://dot.kde.org/1129013255/">http://dot.kde.org/1129013255/</a></p>
<h2 CLASS="western"><a NAME="0.0.ISO to review OpenDocument as a standard|outline"></a>
ISO to review OpenDocument as a standard</h2>
<p>&quot;The committee will send the specification out to its members
probably at the end of this month, and they will have five months to
study and vote on it, according to ISO spokesman Roger Frost.&quot; 
</p>
<p><a HREF="http://www.computerworld.com/softwaretopics/software/story/0,10801,105314,00.html">http://www.computerworld.com/softwaretopics/software/story/0,10801,105314,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OASIS submits OpenDocument as standard|outline"></a>
OASIS submits OpenDocument as standard</h2>
<p>&quot;OpenDocument will continue to be developed and maintained
within OASIS, but the group is seeking the ISO standardization to
make the document formats more accessible, according to an OASIS
representative.</p>
<p>&quot;We believe OpenDocument's approval by ISO/IEC JTC1…will
serve as a gratifying endorsement, making OpenDocument even more
accessible to adopters--particularly those implementing business
solutions for governments--who look to ISO for assurance of long-term
viability,&quot; said OASIS representative Carol Geyer.&quot; 
</p>
<p><a HREF="http://news.zdnet.com/2100-3513_22-5892649.html">http://news.zdnet.com/2100-3513_22-5892649.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Microsoft 'must support OpenDocument'|outline"></a>
Microsoft 'must support OpenDocument'</h2>
<p>&quot;An OASIS spokeswoman said on Wednesday the public sector is
making &quot;great strides&quot; in terms of user demand for
OpenDocument.</p>
<p>Microsoft will be forced to offer support for OpenDocument if more
organisations decide to use the file format, according to James
Governor, an analyst at RedMonk.</p>
<p>&quot;ODF [OpenDocument] is quite new, and it will take a while
for demand to build. But I don't believe it will need 120,000
requests a month to change Microsoft's mind; just a few more high
profile departures like Massachusetts,&quot; said Governor. &quot;If
Microsoft starts to lose customers because of a lack of ODF support
they will offer a plug-in before you know it.&quot;&quot; 
</p>
<p><a HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39226547,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39226547,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.141,624 PCs with OpenOffice.org in China|outline"></a>
141,624 PCs with OpenOffice.org in China</h2>
<p>According to the following article OpenOffice.org will be on
141,624 PCs:</p>
<p>&quot;Six PC makers, including Haier and Founder, announced
yesterday that they have won contracts to provide a total of 141,624
PCs to the Jiangsu Provincial Department of Education for an
educational program called, &quot;School-to-School Project.&quot; At
the same time, Sun Wah Linux's Debian-based Chinese Operating System
RAYS LX was also chosen as the operating system used in all 141,624
PCs.&quot;</p>
<p>According to the product website, RAYS LX contains OpenOffice.org.</p>
<p><a HREF="http://www.linuxelectrons.com/article.php/20051005183120307">http://www.linuxelectrons.com/article.php/20051005183120307</a></p>
<h2 CLASS="western"><a NAME="0.0.AbiWord gets OpenDocument support from Nokia|outline"></a>
AbiWord gets OpenDocument support from Nokia</h2>
<p>&quot;Support for the OpenDocument file format has been donated by
INdT, Nokia's Technology Institute. Currently the OpenDocument import
filter is basically complete, with support for styles,
headers/footers, lists, image wrapping, text boxes, tables,
footnotes/endnotes and tables of contents. OpenDocument export is
planned as well and will be added during the 2.4.x series.&quot;</p>
<p><a HREF="http://www.abiword.com/release-notes/2.4.0.phtml">http://www.abiword.com/release-notes/2.4.0.phtml</a></p>
<h2 CLASS="western"><a NAME="0.0.Microsoft denies PDF support is a reaction to Massachusetts decision|outline"></a>
Microsoft denies PDF support is a reaction to Massachusetts decision</h2>
<p>&quot;Steven Sinofsky, senior vice president of the Microsoft
Office product development group, had earlier stated that the company
received 120,000 requests a month for the ability to produce PDFs
from within Office.</p>
<p>In any case it seems unlikely that the ability to save Word or
Excel documents as PDFs will sway the Massachusetts Information
Technology Division, especially since Sun Microsystems' StarOffice
and the open source OpenOffice.org project have supported the
creation of PDFs since 2003, and also support OpenDocument.&quot; 
</p>
<p><a HREF="http://www.cbronline.com/article_news.asp?guid=2ABE5E3C-3814-4A02-A259-B27E49EC20FA">http://www.cbronline.com/article_news.asp?guid=2ABE5E3C-3814-4A02-A259-B27E49EC20FA</a></p>
<h2 CLASS="western"><a NAME="0.0.RedMonk's Stephen O'Grady about Sun, Google and OpenOffice.org|outline"></a>
RedMonk's Stephen O'Grady about Sun, Google and OpenOffice.org</h2>
<p>&quot;And then there's OpenOffice.org. To me this is far and away
the most interesting of the potential collaboration areas (with the
possible exception of OpenSolaris, but that was not really discussed
a great deal on either call unlike OpenOffice.org). One of the
questions I was asked at least a dozen times between yesterday and
today was what Google might bring to the table with respect to the
Microsoft Office alternative so often in the news of late? Well,
resources for one. A web version? Possible, but I think it'd be very
different functionally than the current codebase - a lot simpler.
While I'll leave that speculation for another time - as we'd be here
a long time - I will say that even a tacit acknowledgement of
OpenOffice.org as a credible platform from Google would be a big win
for the project. If they can further it technically, all the better,
but Google's got sufficient clout at this point to have value just as
a marketing channel.&quot; 
</p>
<p><a HREF="http://www.redmonk.com/sogrady/archives/001015.html">http://www.redmonk.com/sogrady/archives/001015.html</a></p>
<p>Here are some ways Google and Sun could work together</p>
<p>&quot;Let's just say you are using StarOffice Impress, which is
Sun's counterpart to PowerPoint. How about a Picasa icon? Or maybe
even Google Earth, for import of geographical images of that empty
landscape you want to build your plant at for a presentation you are
showing to bankers and developers?</p>
<p>Or say you are writing a document in StarOffice Writer, Sun's
counterpart to (sorry, you get only one guess), Microsoft Word. You
want to know more about a given subject. You simply enter a search
term in the Google toolbar within Writer, click,and your browser
opens up in a new window with a list of search results.</p>
<p>Or, for that matter, you want to share that Impress spreadsheet
with your colleague. Why not IM him or her by means of GoogleTalk
button along the Impress toolbar?&quot; 
</p>
<p><a HREF="http://blogs.zdnet.com/ip-telephony/index.php?p=680">http://blogs.zdnet.com/ip-telephony/index.php?p=680</a></p>
<h2 CLASS="western"><a NAME="0.0.Lenovo bundles StarOffice|outline"></a>
Lenovo bundles StarOffice</h2>
<p>&quot;Sun Microsystems and Lenovo have announced an agreement to
bundle the StarOffice 8 desktop productivity suite in Lenovo’s
latest ThinkPad R51e notebook.&quot; 
</p>
<p><a HREF="http://computerworld.com.sg/ShowPage.aspx?pagetype=2&amp;articleid=2731&amp;pubid=3&amp;issueid=67">http://computerworld.com.sg/ShowPage.aspx?pagetype=2&amp;articleid=2731&amp;pubid=3&amp;issueid=67</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org &amp; Google's SOC|outline"></a>
OpenOffice.org &amp; Google's SOC</h2>
<p><a HREF="http://development.openoffice.org/summerprojects.html">http://development.openoffice.org/summerprojects.html</a></p>
<h2 CLASS="western"><a NAME="0.0.eWeek: 1xExcellent plus 3xGood for StarOffice 8|outline"></a>
eWeek: 1xExcellent plus 3xGood for StarOffice 8</h2>
<p>A good StarOffice 8 review from eWeek:</p>
<p>&quot;KEY PERFORMANCE INDICATORS</p>
<p>CAPABILITY - Excellent</p>
<p>INTEROPERABILITY - Good</p>
<p>SCALABILITY - Good</p>
<p>MANAGEMENT - Good&quot; 
</p>
<p><a HREF="http://www.eweek.com/article2/0,1895,1864224,00.asp">http://www.eweek.com/article2/0,1895,1864224,00.asp</a></p>
<h2 CLASS="western"><a NAME="0.0.CRN: Five Stars for StarOffice 8|outline"></a>
CRN: Five Stars for StarOffice 8</h2>
<p>StarOffice 8 gets four and five stars in this CRN review:</p>
<p>&quot;The verdict is in: StarOffice 8 is slowly, but surely,
gaining steam on Microsoft Office 2003 as it climbs toward an 80
percent functionality equivalent. StarOffice’s new macro converter
tool is finally solving the huge migration hurdle that customers need
to transition from Office.&quot;</p>
<p><a HREF="http://www.crn.com/sections/microsoft/microsoft.jhtml?articleId=171201631">http://www.crn.com/sections/microsoft/microsoft.jhtml?articleId=171201631</a></p>
<h1 CLASS="western"><a NAME="0.September 2005|outline"></a>September
2005</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org 1.1.5 announced|outline"></a>
OpenOffice.org 1.1.5 announced</h2>
<p>OpenOffice.org is proud to announce the immediate availability of
the new 1.1.5 version of the award-winning open source office suite.</p>
<p>This new version is initially available on the Windows
(98/ME/NT/2000/XP), GNU/Linux (X86 and PowerPC) and Solaris (SPARC
and X86) platforms.</p>
<p>In addition to English, builds for Czech, Danish, French, German,
Japanese, Russian, Simplified Chinese, Traditional Chinese and
Turkish are immediately available with other localisations following
shortly.</p>
<p>OpenOffice.org 1.1.5 introduces import support for documents,
spreadsheets and presentations in OpenDocument format. The
OpenDocument format is an XML based international office document
standard approved by OASIS, the Organisation for the Advancement of
Structured Information Standards. XML based, the OpenDocument format
enables the free exchange of data between compliant software
packages.</p>
<p>For full announcement please visit:</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=256">//servlets/ReadMsg?list=announce&amp;msgNo=256</a></p>
<h2 CLASS="western"><a NAME="0.0.SISSL retired|outline"></a>SISSL
retired</h2>
<p>On 2 September 2005 Sun Microsystems announced that it was
retiring the Sun Industry Standards Source License (SISSL), an Open
Source Initiative (OSI)-approved software license. In recent weeks,
the OSI, which authorises open-source licenses, has been discussing
limiting license proliferation, so as to make the process of choosing
a license easier for developers and companies. Sun's move is in
support of that objective.</p>
<p>How does this move affect OpenOffice.org? As most know,
OpenOffice.org code was launched under the dual banner of the SISSL
and LGPL; licensees could choose which one they wanted to use, and
nearly all have chosen the LGPL. Effective with the announcement that
Sun is retiring the SISSL, however, OpenOffice.org will in the future
only be licensed under the LGPL.</p>
<p>For users, the simplification means: no change. OpenOffice.org
remains free to use, distribute, even sell. One can freely use it in
commercial as well as government environments; nothing has changed.</p>
<p>For vendors, distributors, add-on and plug-in writers of
OpenOffice.org: The LGPL allows for commercial distribution without
affecting derived products in the same way as the GPL.</p>
<p>For developers and other contributors: As the code will be
licensed only under the LGPL, modifications to the source must be
published. (The SISSL did not require all changes to the source to be
published.) As most OpenOffice.org contributors are already openly
contributing to the community, we anticipate no problems. And for
those who have been using the SISSL exclusively, we invite you to
join us.</p>
<p>The OpenOffice.org Community Council</p>
<p STYLE="margin-bottom: 0in"><a HREF="http://council.openoffice.org/">http://council.openoffice.org</a></p>
<p STYLE="margin-bottom: 0in"><a HREF="//FAQs/license-change.html">//FAQs/license-change.html</a></p>
<p STYLE="margin-bottom: 0in"><br>
</p>
<p STYLE="margin-bottom: 0in">Original announcement:
<a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=255">//servlets/ReadMsg?list=announce&amp;msgNo=255</a></p>
<h2 CLASS="western"><a NAME="0.0.Estonian Native-Lang project announced|outline"></a>
Estonian Native-Lang project announced</h2>
<p>The Native-Language Confederation is pleased to welcome a new
member in its big family:</p>
<p>The Estonian Native-Language project, led by Ain Vagula and Peeter
Russak. The Estonian Native-Lang project has a fairly impressive
track record because it was active as a localization group long
before it went to existence as a member of the NLC. A team composed
currently of three main members, Ain Vagula, Peeter Russak and Marek
Laane, has been involved in the localization work of  Openoffice.org,
ever since the 1.0.2. This team also developped dictionaries and
distributes CD-Roms.</p>
<p>OpenOffice.org is making steady progress in the Baltic region, as
shown by the interest of the Estonian government in getting CD-Roms
including OOo in Estonian. Stay tuned, as the Estonian Native-Lang
project is a small community that can achieve much for
Openoffice.org!</p>
<p><a HREF="http://et.openoffice.org/">http://et.openoffice.org</a></p>
<h2 CLASS="western"><a NAME="0.0.University of Toronto at Scarborough Standardizes on StarOffice for all Student Computing Resources|outline"></a>
University of Toronto at Scarborough Standardizes on StarOffice for
all Student Computing Resources</h2>
<p>“Sun Microsystems of Canada Inc. today announced the University
of  Toronto at Scarborough (UTSC) has standardized on StarOffice(TM)
office productivity software for all student computing resources.
This ensures every student on campus has access to the leading office
productivity suite for Linux, UNIX(R) and the most popular
alternative for Windows-based computers. UTSC supports a mixed
computing environment, and required an office productivity
application that was available for all of its operating systems.
Delivery of a standard, easy-to-use, and cost-effective application
is central to UTSC's information technology mandate and was the key
to its decision to migrate to StarOffice.”</p>
<p><a HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=104&amp;STORY=/www/story/09-27-2005/0004132492&amp;EDATE">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=104&amp;STORY=/www/story/09-27-2005/0004132492&amp;EDATE</a>=</p>
<h2 CLASS="western"><a NAME="0.0.Commonwealth of Massachusetts moves to open document formats|outline"></a>
Commonwealth of Massachusetts moves to open document formats</h2>
<p>The big news for this month involves the decision of the
Commonwealth of  Massachusetts to move to open document formats,
including that of the upcoming OpenOffice.org 2.0's OpenDocument
format. This move has been given widespread acclaim with the move to
a format which is open, free and unencumbered. A lot has been written
about the move from praise, to rebuttals from Microsoft managers.</p>
<p>News of final decision:</p>
<p><a HREF="http://news.zdnet.com/2100-3513_22-5878869.html">http://news.zdnet.com/2100-3513_22-5878869.html</a></p>
<p>OpenDocument format:</p>
<p><a HREF="http://www.spreadopendocument.org/">http://www.spreadopendocument.org/</a></p>
<p><a HREF="http://www.groklaw.net/article.php?story=20050130002908154">http://www.groklaw.net/article.php?story=20050130002908154</a></p>
<p>MP3 and Ogg of meeting with Massachusetts CIO:</p>
<p><a HREF="http://www.softwaregarden.com/cgi-bin/oss-sig/wiki.pl?OpenFormatMeetingSept2005">http://www.softwaregarden.com/cgi-bin/oss-sig/wiki.pl?OpenFormatMeetingSept2005</a></p>
<p>Massachusetts Enterprise Technical Reference
Model:<a HREF="http://www.mass.gov/portal/index.jsp?pageID=itdsubtopic&amp;L=4&amp;L0=Home&amp;L1=Policies%2C+Standards+%26+Legal&amp;L2=Enterprise+Architecture&amp;L3=Enterprise+Technical+Reference+Model+-+Version+3.5&amp;sid=Aitd">http://www.mass.gov/portal/index.jsp?pageID=itdsubtopic&amp;L=4&amp;L0=Home&amp;L1=Policies%2c+Standards+%26+Legal&amp;L2=Enterprise+Architecture&amp;L3=Enterprise+Technical+Reference+Model+-+Version+3.5&amp;sid=Aitd</a></p>
<p>IBM response to decision:</p>
<p><a HREF="http://www-128.ibm.com/developerworks/blogs/dw_blog_comments.jspa?blog=384&amp;entry=94431">http://www-128.ibm.com/developerworks/blogs/dw_blog_comments.jspa?blog=384&amp;entry=94431</a></p>
<p>The story as it developed throughout the month:</p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/massachusetts-planning-move-to-open.html">http://ooonewsletter.blogspot.com/2005/09/massachusetts-planning-move-to-open.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/massachusetts-open-document-policy.html">http://ooonewsletter.blogspot.com/2005/09/massachusetts-open-document-policy.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/legal-worries-led-massachusetts-to.html">http://ooonewsletter.blogspot.com/2005/09/legal-worries-led-massachusetts-to.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/more-blog-commentary-on-massachusetts.html">http://ooonewsletter.blogspot.com/2005/09/more-blog-commentary-on-massachusetts.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/more-massachusetts-news.html">http://ooonewsletter.blogspot.com/2005/09/more-massachusetts-news.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/opinion-zdnet-blogs-on-opendocument.html">http://ooonewsletter.blogspot.com/2005/09/opinion-zdnet-blogs-on-opendocument.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/opinion-what-has-microsoft-done-for.html">http://ooonewsletter.blogspot.com/2005/09/opinion-what-has-microsoft-done-for.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/opinion-states-open-document-dispute.html">http://ooonewsletter.blogspot.com/2005/09/opinion-states-open-document-dispute.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/opinion-geriatric-microsoft-scuppered.html">http://ooonewsletter.blogspot.com/2005/09/opinion-geriatric-microsoft-scuppered.html</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/massachusetts-moves-ahead-sans.html">http://ooonewsletter.blogspot.com/2005/09/massachusetts-moves-ahead-sans.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org distributed at state conference of lawyers|outline"></a><a NAME="0.0.OpenOffice.org distributed at state conference of lawyers|outline"></a>
OpenOffice.org distributed at state conference of lawyers</h2>
<p>&quot;About 350 lawyers and Law students we expected, but, in
fact, over 750 came. It was a tremendous success. We distributed 750
CD&laquo;s with OpenOffice.org, and some other free softwares, and we
demonstrated it in a datashow (projector) along with some information
about its use. People got astonished and surprised.&quot;</p>
<p><a HREF="http://blogs.sun.com/roller/page/dancer?entry=openoffice_org_distributed_at_state">http://blogs.sun.com/roller/page/dancer?entry=openoffice_org_distributed_at_state</a></p>
<h2 CLASS="western"><a NAME="0.0.&quot;OpenOffice is great alternative to Microsoft&quot;|outline"></a>
&quot;OpenOffice is great alternative to Microsoft&quot;</h2>
<p>The Chicago Sun-Times has an article by Andy Ihnatko on the
upcoming OpenOffice.org 2.0, including favourable comparisons as an
office suite as well as an overview of the OpenDocument format.</p>
<p><a HREF="http://www.suntimes.com/output/worktech/cst-fin-andy22.html">http://www.suntimes.com/output/worktech/cst-fin-andy22.html</a></p>
<h2 CLASS="western"><a NAME="0.0.&quot;Plan by 13 Nations Urges Open Technology Standards&quot;|outline"></a>
&quot;Plan by 13 Nations Urges Open Technology Standards&quot;</h2>
<p>Following on from the Massachusetts policy, 13 nations have put
together a report to push for the adoption of open technology
standards.</p>
<p><a HREF="http://www.theinquirer.net/?article=26093">http://www.theinquirer.net/?article=26093</a></p>
<p><a HREF="http://ooonewsletter.blogspot.com/2005/09/plan-by-13-nations-urges-open.html">http://ooonewsletter.blogspot.com/2005/09/plan-by-13-nations-urges-open.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Indonesia adopts the Java Desktop System (and StarOffice / OpenOffice.org) for its national open-source desktop|outline"></a>
Indonesia adopts the Java Desktop System (and StarOffice /
OpenOffice.org) for its national open-source desktop</h2>
<p>&quot;Indonesia's Ministry of Research and Technology Thursday
said it will implement a Java Desktop System (JDS) on Linux as a
national-standard desktop, customed-designed for its own culture.
This desktop software will be a major component of the new Indonesia
Goes Open Source (IGOS) program that aims to help eliminate the
&quot;digital divide in the world's largest archipelago,&quot; the
ministry and Sun  Microsystems said in a joint announcement.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS3370503002.html">http://www.desktoplinux.com/news/NS3370503002.html</a></p>
<p><a HREF="http://www.igos.web.id/english/english.htm">http://www.igos.web.id/english/english.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org Conference 2005 in Koper / Capodistria, Slovenia|outline"></a>
OpenOffice.org Conference 2005 in Koper / Capodistria, Slovenia</h2>
<p STYLE="margin-bottom: 0in"><a HREF="http://ooocon-arnes.kiberpipa.org/media/">http://ooocon-arnes.kiberpipa.org/media/</a></p>
<h2 CLASS="western"><a NAME="0.0.Raising the bar on patents and standards|outline"></a>
Raising the bar on patents and standards</h2>
<p>&quot;Great news for OpenDocument fans. The guy from Microsoft
couldn't have known this, but we were already working on a move that
raises the bar on what it means to create a truly open standard.
Yesterday, Sun sent to OASIS a new statement concerning patents on
the OpenDocument standard. 
</p>
<p>To decode this statement for you, it says that Sun promises not to
enforce any patent in any country against any implementation of the
OpenDocument format (ODF). That means that, unless you're intending
to sue Sun in connection with ODF, you can use ODF with confidence
and ignore the FUD.&quot;</p>
<p STYLE="margin-bottom: 0in"><a HREF="http://blogs.sun.com/roller/page/webmink?entry=raising_the_bar_on_patents">http://blogs.sun.com/roller/page/webmink?entry=raising_the_bar_on_patents</a></p>
<h1 CLASS="western"><a NAME="0.August 2005|outline"></a>August 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org announces version 2.0 public beta 2|outline"></a>
OpenOffice.org announces version 2.0 public beta 2</h2>
<p>&quot;This beta release is made available in order to allow a
broad user base to test and evaluate the next major version of
OpenOffice.org, but is not recommended for production deployment at
this stage.&quot;</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=252">//servlets/ReadMsg?list=announce&amp;msgNo=252</a></p>
<h2 CLASS="western"><a NAME="0.0.NeoOffice gets $25,000 donation|outline"></a>
NeoOffice gets $25,000 donation</h2>
<p>&quot;A very generous individual has stepped forward and given a
US$25,000 donation to NeoOffice/J. This much needed donation plus the
many small donations received over the last few months provides
enough funds for me to work full time on upgrading NeoOffice/J to use
Java 1.4.</p>
<p>Upgrading NeoOffice/J to Java 1.4 is one of the critical tasks
that must be done in order for NeoOffice/J to run on Apple's upcoming
Intel-based machines. With this donation, one of the three critical
tasks for creating a Mac Intel verison of NeoOffice/J is now fully
funded.</p>
<p>Not only do I want to thank our generous donor, but I would also
like to thank the hundreds of people who have donated to NeoOffice/J.
The many small donations that NeoOffice/J has received are important
and, without them, working full time on NeoOffice/J would not be
possible.&quot;</p>
<p><a HREF="http://trinity.neooffice.org/modules.php?name=News&amp;file=article&amp;sid=97&amp;mode=&amp;order=0&amp;thold=0">http://trinity.neooffice.org/modules.php?name=News&amp;file=article&amp;sid=97&amp;mode=&amp;order=0&amp;thold=0</a></p>
<h2 CLASS="western"><a NAME="0.0.Linux pumps up fitness retailer's network, desktops|outline"></a>
Linux pumps up fitness retailer's network, desktops</h2>
<p>&quot;&quot;Twenty percent of our employees are already running
OpenOffice.org on Windows. Our first task was to train them on
OpenOffice.org; then we will switch to Linux.&quot; Converting
employees to OpenOffice.org brought formatting problems when
converting files from Word format. &quot;When people first used
OpenOffice.org, the formatting was somewhat distorted,&quot; Scott
says. &quot;We sat down and worked out the differences with them. Now
we have everyone first create their documents in OpenOffice.org.&quot;
Other than that, the migration hasn't caused any problems. Says
Scott, &quot;It's been pretty easy.&quot;&quot;</p>
<p><a HREF="http://business.newsforge.com/business/05/07/22/1418204.shtml?tid=37">http://business.newsforge.com/business/05/07/22/1418204.shtml?tid=37</a></p>
<h2 CLASS="western"><a NAME="0.0.Kenosha Finds Big Savings in Linux|outline"></a>
Kenosha Finds Big Savings in Linux</h2>
<p>&quot;&quot;For the most part, everybody is happy,&quot; says
Schall, who adds that OpenOffice integrates smoothly with Microsoft
Word and Excel documents.</p>
<p>A key benefit of using open source applications such as OpenOffice
and the Firefox Latest News about Firefox Web browser is that they
are platform independent, says Tig Kerkman, Kenosha's network
administrator.</p>
<p>&quot;So my users can download OpenOffice for free and use it at
home on whatever hardware they have,&quot; he says.&quot;</p>
<p><a HREF="http://www.toptechnews.com/story.xhtml?story_id=37526">http://www.toptechnews.com/story.xhtml?story_id=37526</a></p>
<h2 CLASS="western"><a NAME="0.0.CheckStatus.net Switches To Open Source|outline"></a>
CheckStatus.net Switches To Open Source</h2>
<p>&quot;&quot;Of course there is a learning curve. It is something
new and different, but after a few days most people feel like they've
used it all along. OpenOffice.org has made it much easier with their
OpenOffice suite. Last week we converted a law office over to
OpenOffice and will be migrating them to Linux shortly.&quot;&quot;</p>
<p><a HREF="http://i-newswire.com/pr40322.html">http://i-newswire.com/pr40322.html</a></p>
<p><a HREF="http://checkstatus.net/">http://checkstatus.net/</a></p>
<h2 CLASS="western">OpenOffice.org distributed at state conference of
lawyers</h2>
<p>&quot;About 350 lawyers and Law students we expected, but, in
fact, over 750 came. It was a tremendous success. We distributed 750
CD&acute;s with OpenOffice.org, and some other free softwares, and we
demonstrated it in a datashow (projector)along with some information
about its use. People got astonished and surprised.&quot;</p>
<p><a HREF="http://marketing.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=20943">http://marketing.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=20943</a></p>
<h2 CLASS="western"><a NAME="0.0.Massive Linux handout set for French schools|outline"></a>
Massive Linux handout set for French schools</h2>
<p>&quot;Every student between the ages of 15 and 19 attending a
school in Auvergne will be given a pack containing two CDs. The first
CD contains free software for Microsoft Windows and Apple Computer's
Mac OS X, including the OpenOffice.org office productivity
application, the Firefox browser and the GIMP image editing
application. The second CD is a Linux Live CD, allowing pupils to try
the open source operating system without installing it. The Linux
Live CD is based on Kaella, a French derivative of Knoppix.&quot;</p>
<p><a HREF="http://news.com.com/Massive+Linux+handout+set+for+French+schools/2100-7344_3-5828644.html?tag=nefd.top">http://news.com.com/Massive+Linux+handout+set+for+French+schools/2100-7344_3-5828644.html?tag=nefd.top</a></p>
<h2 CLASS="western"><a NAME="0.0.PC Magazine review OpenOffice.org 2.0 Beta|outline"></a>
PC Magazine review OpenOffice.org 2.0 Beta</h2>
<p>&quot;Unlike the slow, clunky original version, version 2.0 of
this free productivity suite is surprisingly slick and highly
compatible with Microsoft Office file formats. It even offers
features not found in its expensive Microsoft counterpart.&quot;</p>
<p><a HREF="http://www.pcmag.com/article2/0,1895,1851001,00.asp">http://www.pcmag.com/article2/0,1895,1851001,00.asp</a></p>
<h2 CLASS="western"><a NAME="0.0.&quot;OpenOffice.org 2.0 reviewed&quot;|outline"></a>
&quot;OpenOffice.org 2.0 reviewed&quot;</h2>
<p>SearchEnterpriseLinux has an article reviewing the OpenOffice.org
2.0 Beta,and gives it a good recommendation.</p>
<p><a HREF="http://searchenterpriselinux.techtarget.com/originalContent/0,289142,sid39_gci1116763,00.html">http://searchenterpriselinux.techtarget.com/originalContent/0,289142,sid39_gci1116763,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.FOSS word processors compared: OOo Writer, AbiWord, and KWord|outline"></a>
FOSS word processors compared: OOo Writer, AbiWord, and KWord</h2>
<p>OpenOffice.org receives most of the attention among free and open
source (FOSS) office suites, but users shouldn't forget that free
software includes at least two other word processors: AbiWord, part
of a projected GNOME Office, and KWord, part of the KOffice suite.
From their inception, both have been playing catch-up with
OpenOffice.org's Writer. But now, after several years of development,
 AbiWord and KWord are both reaching early maturity. How do Writer,
AbiWord,  and KWord compare?</p>
<p><a HREF="http://software.newsforge.com/software/05/08/16/2038242.shtml?tid=93&amp;tid=150">http://software.newsforge.com/software/05/08/16/2038242.shtml?tid=93&amp;tid=150</a></p>
<h2 CLASS="western"><a NAME="0.0.Endorsement in the Chicago Tribune|outline"></a>
Endorsement in the Chicago Tribune</h2>
<p>&quot;After all, www.OpenOffice.org alone gives us Writer, a
word-processing module with every feature from spell check to fancy
fonts, footnotes to frames that any ordinary family or student might
need or want.&quot;</p>
<p><a HREF="http://www.chicagotribune.com/technology/chi-0508150274aug16,1,6710884.column?coll=chi-technology-nav&amp;ctrack=1&amp;cset=true">http://www.chicagotribune.com/technology/chi-0508150274aug16,1,6710884.column?coll=chi-technology-nav&amp;ctrack=1&amp;cset=true</a></p>
<h2 CLASS="western"><a NAME="0.0.Support for OASISOpenDocument format in eZ publish|outline"></a>
Support for OASISOpenDocument format in eZ publish</h2>
<p>&quot;eZ publish, the CMS developed by eZ systems, a new extension
for to way communcation with the OASIS Open Document format is
released. This is the format used in OpenOffice.org version 2 and
KWord ammong other applications.&quot;</p>
<p><a HREF="http://newsvac.newsforge.com/article.pl?sid=05/08/02/1624208">http://newsvac.newsforge.com/article.pl?sid=05/08/02/1624208</a></p>
<h2 CLASS="western"><a NAME="0.0.Perl module for OASIS OpenDocument at CPAN|outline"></a>
Perl module for OASIS OpenDocument at CPAN</h2>
<p>&quot;The OpenDocument-compliant version of Perl OpenOffice::OODoc
(2.003) is now available at CPAN.</p>
<p>The same API supports both the OOo 1.0 and the ODF. With some
care, it's now possible to write programs that simultaneously deal
with several documents with different formats.&quot;</p>
<p><a HREF="http://search.cpan.org/dist/OpenOffice-OODoc">http://search.cpan.org/dist/OpenOffice-OODoc</a></p>
<h1 CLASS="western"><a NAME="0.Juli 2005|outline"></a>Juli 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org 1.1.5 Release Candidate Is Here|outline"></a>
OpenOffice.org 1.1.5 Release Candidate Is Here</h2>
<p>&quot;OpenOffice.org 1.1.5rc is ready for you to download now. 
It's a release candidate, meaning that it has bugs, and we would like
for you to work with us in finding them and reporting them.  It's
easy and even fun.  :-) 
</p>
<p>What's important about 1.1.5rc?  It includes numerous bug fixes
but just as important includes a filter for OpenDocument files, which
is the type that OpenOffice.org 2.0 and the 1.9.x releases create. 
To download and file bug reports, follow the links below:</p>
<ul>
	<li><p>OpenOffice.org 1.1.5rc:
	<br><a HREF="/download/1.1.5rc/index.html">/download/1.1.5rc/index.html</a></p>
	<li><p>QA Project: <br><a HREF="http://qa.openoffice.org/">http://qa.openoffice.org/</a></p>
</ul>
<p>This release candidate arrives simultaneously in 11 languages. 
More languages will be available as the community creates them. 
Check with your Native Language Project for more information. It is
also available for Linux, Solaris, and Windows.</p>
<ul>
	<li><p><a HREF="/projects/native-lang.html">/projects/native-lang.html</a></p>
</ul>
<p>The OpenOffice.org Team&quot;</p>
<p><br><br>
</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=250">//servlets/ReadMsg?list=announce&amp;msgNo=250</a></p>
<h2 CLASS="western"><a NAME="0.0.BharateeyaOO.o with Linux For You Magazine|outline"></a>
BharateeyaOO.o with Linux For You Magazine</h2>
<p>The July 2005 issue of Linux For You magazine (India) will be
distributed with the Hindi version of OpenOffice.org that was
recently released.</p>
<p><a HREF="http://www.linuxforu.com/">http://www.linuxforu.com/</a></p>
<h2 CLASS="western"><a NAME="0.0.New Community Contributor Representative|outline"></a>
New Community Contributor Representative</h2>
<p>Laurent Godard is the new Community Contributor Represenative
(CCR) winning  with 53% of the total votes. The CCR represents the
OpenOffice.org community of endusers, among others. To learn more of
the Community Council, visit the Council site.</p>
<p>Congratulations Laurent, and thanks again to all nominees and
participants!</p>
<p><a HREF="http://council.openoffice.org/">http://council.openoffice.org/</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org's third international conference announced|outline"></a>
OpenOffice.org's third international conference announced</h2>
<p>&quot;The conference is being organised by the Slovenian and
Italian OOo project teams. The first part of the program will cover
topics such as development and OpenOffice.org in education, for those
interested in the community and the project itself, whereas the last
part of the conference will be focused on the end-users and the use
of OpenOffice.org in public administration and enterprises.&quot;</p>
<p><a HREF="http://www.onlamp.com/pub/wlg/7321">http://www.onlamp.com/pub/wlg/7321</a></p>
<p>Conference page:</p>
<p><a HREF="http://marketing.openoffice.org/ooocon2005/index.html">http://marketing.openoffice.org/ooocon2005/index.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org at city of about 100,000|outline"></a>
OpenOffice.org at city of about 100,000</h2>
<p>&quot;Schall says there were no major issues with the migration to
Linux on either the server or the desktop. The city never used
Microsoft Latest News about Microsoft on the desktop and so is in the
process of transitioning from WordPerfect to OpenOffice.</p>
<p>&quot;For the most part, everybody is happy,&quot; says Schall,
who adds that OpenOffice integrates smoothly with Microsoft Word and
Excel documents.</p>
<p>A key benefit of using open source applications such as OpenOffice
and the Firefox Latest News about Firefox Web browser is that they
are platform independent, says Tig Kerkman, Kenosha's network
administrator.</p>
<p>&quot;So my users can download OpenOffice for free and use it at
home on whatever hardware they have,&quot; he says.&quot;</p>
<p><a HREF="http://www.newsfactor.com/story.xhtml?story_id=13000002WK6K">http://www.newsfactor.com/story.xhtml?story_id=13000002WK6K</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org, FOSS, and the preservation of Gaelic|outline"></a>
OpenOffice.org, FOSS, and the preservation of Gaelic</h2>
<p>&quot;By itself, the release of OpenOffice.org for Scots Gaelic is
a small event within the communities of free and open source software
(FOSS). It is only one of the more than 50 localizations available
for OpenOffice.org 1.x. However, the release shows a potential for
FOSS that is often overlooked, particularly by those for whom English
is their native language. Specifically, FOSS has the potential to
help resuscitate a declining language and thereby aid in revitalizing
a disintegrating culture.&quot;</p>
<p><a HREF="http://software.newsforge.com/software/05/06/28/2040202.shtml?tid=93&amp;tid=130&amp;tid=132">http://software.newsforge.com/software/05/06/28/2040202.shtml?tid=93&amp;tid=130&amp;tid=132</a></p>
<h2 CLASS="western"><a NAME="0.0.Vienna starts desktop Linux migration|outline"></a>
Vienna starts desktop Linux migration</h2>
<p>&quot;The city is currently running Microsoft Windows 2000 and
Office 2000 on its 16,000 desktop PCs, but has identified 7,500 that
could be migrated to the open source productivity application
OpenOffice.org. Of these, 4,800 could also be migrated to the open
source operating system Linux.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/0,39020330,39207461,00.htm">http://news.zdnet.co.uk/0,39020330,39207461,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org at Australian community center|outline"></a>
OpenOffice.org at Australian community center</h2>
<p>&quot;With 65 user accounts and counting, The Hut's network now
includes 10 Ubuntu workstations running GNOME, OpenOffice.org,
Evolution, and Firefox, an application server, a gateway box, and a
backup server. There is also a dual-boot workstation and two strictly
Windows boxes that sit on the network but don't rely on the file
server.&quot;</p>
<p><a HREF="http://business.newsforge.com/business/05/07/14/1942237.shtml?tid=37">http://business.newsforge.com/business/05/07/14/1942237.shtml?tid=37</a></p>
<h2 CLASS="western"><a NAME="0.0.Schools ink deal for open source|outline"></a>
Schools ink deal for open source</h2>
<p>&quot;The Education Ministry has signed an 18-month software
licensing deal with Novell New Zealand, the ministry's first deal to
provide open source software to schools.</p>
<p>It includes Novell's SUSE distribution of the Linux desktop
operating system.&quot;</p>
<p>...</p>
<p>&quot;The SUSE Linux operating system is packaged with open source
Internet browser Firefox and Microsoft Office rival OpenOffice.&quot;</p>
<p><a HREF="http://www.stuff.co.nz/stuff/0,2106,3348057a28,00.html">http://www.stuff.co.nz/stuff/0,2106,3348057a28,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.New USB Flash Drive Sports Bootable OS, Office Apps|outline"></a>
New USB Flash Drive Sports Bootable OS, Office Apps</h2>
<p>&quot;The $149 Computer-On-a-Stick is a USB flash drive with a
bootable onboard Linux operating system and open source office
suite.&quot;</p>
<p>...</p>
<p>&quot;The office suite, developed by OpenOffice.org, is compatible
with the most common Microsoft Office applications, including Word,
Excel, PowerPoint, and Outlook.&quot;</p>
<p><a HREF="http://informationweek.com/story/showArticle.jhtml?articleID=166401966">http://informationweek.com/story/showArticle.jhtml?articleID=166401966</a></p>
<p>Press Release:</p>
<p><a HREF="http://home.businesswire.com/portal/site/google/index.jsp?ndmViewId=news_view&amp;newsId=20050722005199&amp;newsLang=en">http://home.businesswire.com/portal/site/google/index.jsp?ndmViewId=news_view&amp;newsId=20050722005199&amp;newsLang=en</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.webpronews.com/news/ebusinessnews/wpn-45-20050723ComputerOnAStickWhatsNext.html">http://www.webpronews.com/news/ebusinessnews/wpn-45-20050723ComputerOnAStickWhatsNext.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Novell showcases OES|outline"></a>Novell
showcases OES</h2>
<p>&quot;The desktop OS includes a number of office productivity
tools and applications. The Novell edition of OpenOffice provides
tools like word processor, spreadsheet and presentation package that
handles native Microsoft Office file formats and can export files to
Adobe PDF.&quot;</p>
<p><a HREF="http://computerworld.com.sg/ShowPage.aspx?pagetype=2&amp;articleid=1902&amp;pubid=3&amp;issueid=56">http://computerworld.com.sg/ShowPage.aspx?pagetype=2&amp;articleid=1902&amp;pubid=3&amp;issueid=56</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org instead of Works|outline"></a>
OpenOffice.org instead of Works</h2>
<p>&quot;Corine has MS Works, but says it is not compatible with the
more widely used Microsoft Word. She wants to know if there is a
viable alternative that won't irritate her limited budget?</p>
<p>In the past I've suggested Open Office, at www.openoffice.org, as
a reasonably compatible suite of programs that in many cases works as
well as the hugely popular Microsoft product, though it is a little
lean on extras.</p>
<p>There are converters available for MS Works, but users of Open
Office do rave about its level of compatibility. Being free
open-source software, it is a continuing development project based
initially on the Sun Microsystems commercial product StarOffice.&quot;</p>
<p><a HREF="http://www.nzherald.co.nz/index.cfm?c_id=5&amp;ObjectID=10338051">http://www.nzherald.co.nz/index.cfm?c_id=5&amp;ObjectID=10338051</a></p>
<h2 CLASS="western"><a NAME="0.0.[Beta Review] Openoffice.org 2|outline"></a>
[Beta Review] Openoffice.org 2</h2>
<p>&quot;With that in mind, there's no doubt version 2 is more than
powerful enough for most home and business users and can certainly
give Microsoft a run for its money, especially since it's free.</p>
<p>And for corporate users who need proper technical support (which
isn't available with the free version), there's a retail version of
the suite called Star Office. This costs $50 (&pound;26.26 approx)
and is supplied and supported by Sun Microsystems.&quot;</p>
<p><a HREF="http://www.vnunet.com/personal-computer-world/software/2140229/openoffice-org">http://www.vnunet.com/personal-computer-world/software/2140229/openoffice-org</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice 2.0 Beta Review|outline"></a>
OpenOffice 2.0 Beta Review</h2>
<p>&quot;I have been exploring the use of free Open Source software
as an alternative to Microsoft Software for quite some time now. I
have been using Open Office for about 8 months now for my word
processing needs. In a nutshell I am satisfied. Last week a new beta
was released, I downloaded it as soon as it was made available, on
first view, even though the key functionality in version 2.0 Beta
remains largely intact, it promises dozens, possibly hundreds, of
changes.&quot;</p>
<p><a HREF="http://www.osjournal.com/content/119/Reviews/OpenOffice_2_0_Beta_Review/">http://www.osjournal.com/content/119/Reviews/OpenOffice_2_0_Beta_Review/</a></p>
<h2 CLASS="western"><a NAME="0.0.KDE Plugin in the Official OpenOffice.org Packages|outline"></a>
KDE Plugin in the Official OpenOffice.org Packages</h2>
<p>&quot;A year and a half after launching the KDE.OpenOffice.org
Integration Project, the KDE plugin with the Native Widget Framework
has become part of the official OpenOffice.org development packages.
Developer snapshot m118 is the first of the towards-2.0 milestones
that contains it.&quot;</p>
<p><br><br>
</p>
<p><a HREF="http://dot.kde.org/1122037183/">http://dot.kde.org/1122037183/</a></p>
<h2 CLASS="western"><a NAME="0.0.Xandros Business Desktop &amp; StarOffice|outline"></a>
Xandros Business Desktop &amp; StarOffice</h2>
<p>&quot;Over 1,000 businesses have taken up Xandros Inc's Enterprise
Linux Challenge to try out its Business Desktop Linux operating
system, according to the company, indicating strong potential demand
for the 
</p>
<p>new product. ... The product includes Sun Microsystems Inc's
StarOffice, Xandros Anti-Virus and Xandros Firewall security
features, and a bundle is available with the xDMS Xandros Desktop
Management Server for mass deployment.&quot;</p>
<p><a HREF="http://www.cbronline.com/article_news.asp?guid=64D13B18-A4ED-44C5-8CD4-EA126A9DA1F2">http://www.cbronline.com/article_news.asp?guid=64D13B18-A4ED-44C5-8CD4-EA126A9DA1F2</a></p>
<h2 CLASS="western"><a NAME="0.0.Valuable Data Requires Open Formats|outline"></a>
Valuable Data Requires Open Formats</h2>
<p>&quot;So I unzipped the OOo archive and checked the styles.xml
file using xmlwf (checking to see if the XML was 'well-formed', which
is step one of two on the road to correctness; the second hurdle is
validity according to the schema). Sure enough, there was a duplicate
element attribute at the line and column indicated in the cryptic OOo
error message.</p>
<p>Edit it out, zip it back up, try again, and ... same error,
different location. But after a couple of iterations the problem was
fixed.</p>
<p>Sure, it was a pain, and sure, it should never have happened. But
in an imperfect world, I'd much rather have my data in an accessible
format that can be manipulated by many different tools than locked up
in an undocumented, proprietary format.&quot;</p>
<p><a HREF="http://www.onlamp.com/pub/wlg/7432">http://www.onlamp.com/pub/wlg/7432</a></p>
<h2 CLASS="western"><a NAME="0.0.How Microsoft will try to get more money from Office users|outline"></a>
How Microsoft will try to get more money from Office users</h2>
<p>&quot;But likely to prove controversial is Microsoft intention to
charge users an additional &quot;premium&quot; client access licenses
(CAL) to use these higher-end versions of Office and Windows. Ballmer
and other executives were light on specifics today, although in the
Office market at least Microsoft seems to be going beyond its current
high-end edition of Office Professional Edition, which is priced at
$388.49 per copy.</p>
<p>...</p>
<p>&quot;We will... introduce higher-value versions of existing
products that really help us drive new growth and new value. We did
that with the Professional edition of our Windows product, and it
drove literally billions of dollars of revenue growth versus the home
version,&quot; Ballmer said.</p>
<p>...</p>
<p>Microsoft's decision to introduce more SKUs and charge higher
prices, though, will expose the company to more accusations from
competitors that is gouging customers while IT budgets are tight. Sun
Microsystems has been pushing StarOffice as a low-priced,
subscription-based alternative to Office to help customers overcome
the pricing issue.&quot;</p>
<p><a HREF="http://www.channelregister.co.uk/2005/07/28/microsoft_skus/">http://www.channelregister.co.uk/2005/07/28/microsoft_skus/</a></p>
<h2 CLASS="western"><a NAME="0.0.Taking the Lead in Security and Performance; New version of the TYPO3 Content Management System Released|outline"></a>
Taking the Lead in Security and Performance; New version of the TYPO3
Content Management System Released</h2>
<p>&quot;The powerful search engine now produces statistics about the
terms entered. Editors can use this information to tailor their site
to their visitors. The search engine also indexes new types of data,
such as Microsoft Excel tables, Microsoft PowerPoint presentations
and OpenOffice.org documents.&quot;</p>
<p><a HREF="http://www.emediawire.com/releases/2005/7/emw262183.htm">http://www.emediawire.com/releases/2005/7/emw262183.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Norway says yes to Open Source|outline"></a>
Norway says yes to Open Source</h2>
<p>&quot;The Norwegian minister for modernisation (nice job title)
says the government will no longer accept the use of proprietary
formats.</p>
<p>Without mentioning Microsoft, or anyone else, directly, Morten
Andreas Meyer said: &Ograve;Proprietary formats will no longer be
acceptable in communication between citizens and government.””</p>
<p><a HREF="http://www.theregister.co.uk/2005/06/28/norway_wants_os/">http://www.theregister.co.uk/2005/06/28/norway_wants_os/</a></p>
<h2 CLASS="western"><a NAME="0.0.Microsoft looks to partners to force Office upgrades|outline"></a>
Microsoft looks to partners to force Office upgrades</h2>
<p>Microsoft is investing $300m in Office marketing for fiscal 2006
and expanding the number of field sales people from 450 to more than
1,000 - Chris Capossela corporate vice president for the information
worker product management group.</p>
<p><a HREF="http://www.channelregister.co.uk/2005/07/08/_office_partners/">http://www.channelregister.co.uk/2005/07/08/_office_partners/</a></p>
<h1 CLASS="western"><a NAME="0.June 2005|outline"></a>June 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OOoCon 2005 Call For Papers|outline"></a>
OOoCon 2005 Call For Papers</h2>
<p>&quot;The third international OpenOffice.org Conference, OOoCon
2005, will be held in Koper-Capodistria, Slovenia, this year, from
28-30 September, and you are invited! Promoted this year as a joint
effort by the Slovenian and Italian OpenOffice.org language projects,
the conference provides the opportunity for the community to meet the
developers, contributors, marketers, and others who are making
OpenOffice.org one of the most important open-source projects and
products today.</p>
<p>If you have been thinking about coding for OpenOffice.org and want
tips, now is your chance; curious about OpenOffice.org's XML
potential? Want to write extensions? Plug ins? Then come to the
conference!</p>
<p>Indeed if you are not technically minded but want to join a great
community come along and find out why so many people are switching to
OpenOffice.org.</p>
<p>We have posted the call for papers (CFP) and are soliciting
presentations from the general OpenOffice.org community (and then
some) for papers concerning the development of OpenOffice.org to its
marketing; from the global politics of free software to the
technicalities of localizing OpenOffice.org.</p>
<p>To see all the tracks open and to obtain the template for
submissions, as well as to request travel assistance, visit:</p>
<ul>
	<li><p><a HREF="http://marketing.openoffice.org/ooocon2005/cfp.html">http://marketing.openoffice.org/ooocon2005/cfp.html</a></p>
</ul>
<p>250-word abstracts in English must be submitted to
callforpapers@openoffice.org by 10 July 2005. We ask that you use our
template for your abstract. It can be found on the CFP page.</p>
<p>For more information, visit the OOoCon 2005 pages:</p>
<ul>
	<li><p><a HREF="http://marketing.openoffice.org/ooocon2005/index.html">http://marketing.openoffice.org/ooocon2005/index.html</a></p>
</ul>
<p>And to learn more about the lovely seaside city of Koper –
Capodistria (a bilingual community), see:</p>
<ul>
	<li><p><a HREF="http://www.slo-istra.com/koper/eng.asp">http://www.slo-istra.com/koper/eng.asp</a></p>
</ul>
<p>Cheers,</p>
<p>The OpenOffice.org Team&quot;</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=246">//servlets/ReadMsg?list=announce&amp;msgNo=246</a></p>
<h2 CLASS="western"><a NAME="0.0.NeoOffice/J 1.1 Released!|outline"></a>
NeoOffice/J 1.1 Released!</h2>
<p>&quot;Planamesa Software and the NeoOffice.org community are proud
to introduce NeoOfficeš/J 1.1, a Mac OS X-native version of the
OpenOffice.org office suite that includes Microsoft Office-compatible
word processing, spreadsheet, presentation and drawing applications.</p>
<p>“This release is the culmination of many thousands of volunteer
hours,” said NeoOffice/J's creator and primary developer Patrick
Luby. &Ograve;As a result of this tremendous effort, we have a very
stable, full-featured office suite for Mac OS X that supports dozens
of languages.”</p>
<p>NeoOfficeš/J 1.1 is available today as a free download from the
Planamesa 
</p>
<p>Software website at http://www.planamesa.com/neojava/.&quot;</p>
<p><a HREF="http://www.planamesa.com/neojava/">http://www.planamesa.com/neojava/</a></p>
<h2 CLASS="western"><a NAME="0.0.Uno Runtime Environment (URE) released|outline"></a>
Uno Runtime Environment (URE) released</h2>
<p>&quot;Dear OpenOffice.org and UNO friends,</p>
<p>I am pleased to announce that a sponsor, who is preferring to stay
anonymous, is supporting us to do the next step in modulizing the
OpenOffice.org office suite and to make its component model available
independently. That means, that we are going to factor out the highly
requested 
</p>
<ul>
	<li><p>Universal Network Objects (UNO)</p>
</ul>
<p>into its own</p>
<ul>
	<li><p>Uno Runtime Environment  (URE)</p>
</ul>
<p>The URE allows the usage of UNO independently of the
OpenOffice.org productivity suite. UNO is OpenOffice.orgs underlying
component model, allowing language agnostic and remote transparent
development of add-ins, components and applications.</p>
<p>As UNO has already been designed with independence in mind, the
URE is mainly about bundling the appropriate libraries, executables
etc. into their own package. Please have a look at the URE proposal
at</p>
<ul>
	<li><p><a HREF="http://udk.openoffice.org/common/man/draft/standalone_uno_1_0.html">http://udk.openoffice.org/common/man/draft/standalone_uno_1_0.html</a></p>
</ul>
<p>respectively the UNO homepage at</p>
<ul>
	<li><p><a HREF="http://udk.openoffice.org/">http://udk.openoffice.org</a></p>
</ul>
<p>for details. The URE is planned to be released with OOo 2.0. As
OOo 2.0 is already advanced in its development, the plan is to adapt
OOo to the URE with its next major (see
<a HREF="//issues/show_bug.cgi?id=50467">//issues/show_bug.cgi?id=50467</a>)
release.</p>
<p>XPCom, Bonobo and Mono fans might want to give UNO a try and see
if we can/want to bridge from one component model to another, to
reach higher overall interoperability.</p>
<p>Distro packagers might want to provide the URE (and the OOo SDK)
with their distro, not only as a prerequisite for past OOo 2.0
releases but to enable people to develop UNO components.</p>
<p>Porters might want to port the URE, which is mainly a packaging
task, to their favorite platform.</p>
<p>Please send feedback to dev@udk.openoffice.org, respectively to
Stephan Bergmann (sb@openoffice.org, UDK co-lead) or Kay Ramme
(kr@openoffice.org, UDK lead).&quot;</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=245">//servlets/ReadMsg?list=announce&amp;msgNo=245</a></p>
<h2 CLASS="western"><a NAME="0.0.Opening of an Eurasian Languages Native-Lang Group|outline"></a>
Opening of an Eurasian Languages Native-Lang Group</h2>
<p>&quot;The Native-Lang Confederation announces the creation of the
Eurasian Languages Group. This group comes as an answer to the needs
of several projects to share their ressources, information, and ease
communication between them and the greater OpenOffice.org community.</p>
<p>As a result,</p>
<ul>
	<li><p>the Russian (http://ru.openoffice.org)</p>
	<li><p>the Turkish (http://tr.openoffice.org)</p>
	<li><p>the Georgian (http://ka.openoffice.org)</p>
	<li><p>the Azeri (http://az.openoffice.org)</p>
	<li><p>the Ukrainian (http://ua.openoffice.org)</p>
</ul>
<p>native-lang projects form this new group. Rail Aliev, co-lead of
the Russian and Turkish projects, will coordinate the technical &amp;
localization efforts. While there's no clear marketing coordinator,
the Eurasian Languages Group intends to increase its marketing
activities and its awareness inside the OpenOffice.org community.</p>
<p>More Eurasian projects can be added to this list in the future.
This is why the Group would like to invite the existing  Armenian and
Persian Native-Lang projects to join them. Later on, any native-lang
project representing Slavian, Turkic, Altaic and Mongolian languages
and cultures will be able to join this group.</p>
<p>As part of its mission, the Eurasian Native-Lang Group will have
to</p>
<ul>
	<li><p>coordinate  localization efforts and developments</p>
	<li><p>mutualize and help the projects with the localized builds'QA.</p>
	<li><p>speed up the adoption of OpenOffice.org on a local basis and
	help 
	</p>
	<li><p>coordinate its promotion</p>
	<li><p>coordinate documentation writing</p>
	<li><p>communicate with the other projects of OOo and the
	native-lang confederation</p>
	<li><p>ease the communication between the Eurasian native-lang
	projects</p>
</ul>
<p>Best Regards,</p>
<p>Charles-H. Schulz,</p>
<p>Lead of the Native-Lang Confederation,</p>
<p>OpenOffice.org&quot;</p>
<p><a HREF="http://native-lang.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=5263">http://native-lang.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=5263</a></p>
<h2 CLASS="western"><a NAME="0.0.Once more OpenOffice.org and Open Source Softwares on CDs in India|outline"></a>
Once more OpenOffice.org and Open Source Softwares on CDs in India</h2>
<p>&quot;At New Delhi on 20th June, Hindi Free Software CD will be
launched. And so will be OpenOffice.org in Hindi.</p>
<p>Venue: Vigyan Bhavan</p>
<p>Once again we are talking about 3 million CDs but this time in
Hindi. So what are the other OS softwares going in? This time we are
including FireFox, Gaim and Columba all localized to Hindi. Apart
from that we are also packaging Transliterator addon to
OpenOffice.org which supports transliteration from English to 5
Indian Languages.</p>
<p>I will be there at launch. Will come back and update you. 
</p>
<p>Please feel free to give this mail as much circulation as
possible.&quot;</p>
<p><a HREF="http://marketing.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=20519">http://marketing.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=20519</a></p>
<h2 CLASS="western"><a NAME="0.0.Sun Microsystems' Donation of StarOffice(TM) Suite To Be Distributed Through Gifts In Kind International|outline"></a>
Sun Microsystems' Donation of StarOffice(TM) Suite To Be Distributed
Through Gifts In Kind International</h2>
<p>&quot;Sun Microsystems and Gifts In Kind International, the
world's leading charity in the field of product philanthropy,
announced today a new global donation program, to provide
StarOffice(TM) suite to eligible nonprofit and Non-Governmental
Organizations (NGOs) in the US and countries around the world.
StarOffice is the world's leading office productivity software suite
on the Solaris(TM) Operating System (OS) and Linux, and the leading
alternative office suite on Windows.&quot;</p>
<p><a HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=109&amp;STORY=/www/story/06-06-2005/0003818288&amp;EDATE">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=109&amp;STORY=/www/story/06-06-2005/0003818288&amp;EDATE</a>=</p>
<h2 CLASS="western"><a NAME="0.0.Linux and other OSS helps connect rural African villages|outline"></a>
Linux and other OSS helps connect rural African villages</h2>
<p>&quot;Each Communications Station features an inexpensive and
durable PC with Linux and KDE, OpenOffice.org, and an unspecified
web-browser. Also, of course, each station has a telephone. In part
because of the open source Asterisk PBX system, villagers can now
make and receive calls for the first time --including free calls
between the connected villages.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS7710415162.html">http://www.desktoplinux.com/news/NS7710415162.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Indian OpenOffice roll-out continues|outline"></a>
Indian OpenOffice roll-out continues</h2>
<p>&quot;Last month, ZDNet UK reported that the Indian government
would distribute 3.5m free CDs containing Tamil Language versions of
open source applications, including the Firefox browser and the
OpenOffice.org productivity suite. Within a month the project had
received requests for 85,000 CDs, thousands of downloads from its Web
site, and had attracted the attention of the President of India, APJ
Abdul Kalam.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39205447,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39205447,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Free Indian Language Software is Hot!|outline"></a>
Free Indian Language Software is Hot!</h2>
<p>&quot;In a high profile ceremony, Smt. Sonia Gandhi, Chairman of
the National Advisory Council of India, and Thiru Dayanidhi Maran,
Union Minister for Communications and Information Technology released
a free CD of software containing Hindi language tools and fonts based
on open source software in New Delhi this week. To the rousing
applause of the audience, Thiru Maran asserted that this freely
available office suite is in every way the equal of Microsoft
Office.&quot;</p>
<p><a HREF="http://www.technetra.com/News/free_indian_language_software_is_hot_html">http://www.technetra.com/News/free_indian_language_software_is_hot_html</a></p>
<p>Additional reporting:</p>
<p>Linux For You magazine: <a HREF="http://www.linuxforu.com/">http://www.linuxforu.com/</a></p>
<h2 CLASS="western"><a NAME="0.0.LT Scotland Introduces Gaelic Version of Office Applications Software|outline"></a>
LT Scotland Introduces Gaelic Version of Office Applications Software</h2>
<p>&quot;Learning and Teaching Scotland (LT Scotland) launched a
groundbreaking Gaelic version of Open Office today (2 June 2005) at
the A' Chuisle conference in Aviemore. The software has user
interfaces and features similar to other office suites but for the
first time ever the language is entirely in Gaelic.&quot;</p>
<p><a HREF="http://www.ltscotland.org.uk/news/press.asp?newsid=396">http://www.ltscotland.org.uk/news/press.asp?newsid=396</a></p>
<p>OpenOffice.org Gaelic homepage:</p>
<p><a HREF="http://gd.openoffice.org/">http://gd.openoffice.org/</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.ngfl.gov.uk/news.jsp?sec=5&amp;cat=99&amp;res=86963">http://www.ngfl.gov.uk/news.jsp?sec=5&amp;cat=99&amp;res=86963</a></p>
<p><a HREF="http://www.publictechnology.net/modules.php?op=modload&amp;name=News&amp;file=article&amp;sid=3026">http://www.publictechnology.net/modules.php?op=modload&amp;name=News&amp;file=article&amp;sid=3026</a></p>
<h2 CLASS="western"><a NAME="0.0.Trying OpenOffice|outline"></a>Trying
OpenOffice</h2>
<p>&quot;I have a recommendation. A friend of mine who is majoring in
computer science recently turned me on to OpenOffice.org. It is a
free office suite by Sun Microsystems meant to compete with Microsoft
Office. It has a word processor and spreadsheet, presentation and
database software that effectively compete with their equivalents in
Office. It is Mac and PC compatible and will open most other types of
word processing software files. It will also work with any e-mail
program automatically attaching the file you are working on to the
message. It is also available in multiple languages, can be
downloaded for free at Openoffice.org or a cd ordered at the website
for a nominal cost.&quot;</p>
<p><a HREF="http://www.poynter.org/column.asp?id=32&amp;aid=83087">http://www.poynter.org/column.asp?id=32&amp;aid=83087</a></p>
<h2 CLASS="western"><a NAME="0.0.Italian lawyers in love with open source|outline"></a>
Italian lawyers in love with open source</h2>
<p>&quot;GL-OS is preparing to release Italian legal forms in
OpenDocument format, and plans to offer custom CD-ROMs. The group is
studying how to become official OOo Community Distributors. The to-do
list also includes training classes (especially for OpenOffice.org)
and conferences about FOSS and the forensic world. The longest-term
goal is the utilization of FOSS to access both legal databases and
the Processo Civile Telematico, the Italian project that is
attempting to reduce as much as possible the amount of paper
circulating in any given trial. Once it is implemented, all requests
to the court and other documents will be written and directly filed
in encrypted XML format, signed with smart cards.&quot;</p>
<p><a HREF="http://trends.newsforge.com/trends/05/06/15/1924206.shtml?tid=147&amp;tid=132">http://trends.newsforge.com/trends/05/06/15/1924206.shtml?tid=147&amp;tid=132</a></p>
<h2 CLASS="western"><a NAME="0.0.RedMonk's Stephen O'Grady on the OASIS OpenDocument format|outline"></a>
RedMonk's Stephen O'Grady on the OASIS OpenDocument format</h2>
<p>&quot;On some level these arguments fly in the face of the &quot;if
it ain't broke, don't fix it&quot; mindset that seems to be prevalent
within Microsoft divisions that have generated quarter after quarter
after quarter of sustained revenue growth, but I think that that
mindset is going to have to change in a world that's increasingly
driven by macro trends like open source and open standards. Are we at
the tipping point in the office format equation was a question I
debated with a vendor yesterday, and the answer, in my mind, is not
yet. But the Open Document Format is still young, and I do think it
ultimately has the power to fundamentally alter the context of
discussions around office productivity software. 
</p>
<p>Microsoft can be proactive and aggressively compete on that basis
now, or they can ignore the demands of governments and ISVs abroad. I
know what I'd choose.&quot; 
</p>
<p><a HREF="http://www.redmonk.com/sogrady/archives/000732.html">http://www.redmonk.com/sogrady/archives/000732.html</a></p>
<h2 CLASS="western"><a NAME="0.0.XML, one format to rule them all|outline"></a>
XML, one format to rule them all</h2>
<p>&quot;Interoperability will be greatly improved, since the new XML
format will be supported by three of the most important and utilized
applications from MS Office.</p>
<p>But the ones to benefit the most from this format will be Open
Office and StarOffice, which due to Microsoft's policy not to charge
any sum of money for Open XML Format will be able to offer much
easier support for the documents created with MS Office.&quot;</p>
<p><a HREF="http://news.softpedia.com/news/XML-one-format-to-rule-them-all-2570.shtml">http://news.softpedia.com/news/XML-one-format-to-rule-them-all-2570.shtml</a></p>
<h2 CLASS="western"><a NAME="0.0.Sun Donates StarOffice to Non-Profits|outline"></a>
Sun Donates StarOffice to Non-Profits</h2>
<p>&quot;Sun is giving the gift of StarOffice to nonprofit and
non-governmental organizations (NGOs) in the United States and
internationally. The software will be distributed through a
partnership with Gifts In Kind International.&quot;</p>
<p><a HREF="http://www.betanews.com/article/Sun_Donates_StarOffice_to_NonProfits/1118687222">http://www.betanews.com/article/Sun_Donates_StarOffice_to_NonProfits/1118687222</a></p>
<h2 CLASS="western"><a NAME="0.0.Coming Soon: MS Office Alternatives for Mac|outline"></a>
Coming Soon: MS Office Alternatives for Mac</h2>
<p>&quot;Major milestones were recently announced for two Mac OS
X-compatible software suites that could provide an alternative to the
near-ubiquitous Microsoft Office. The free NeoOffice/J, an
open-source software development project created by Patrick Luby and
Edward Peterlin, has reached its &quot;first stable release,&quot;
and South Korea-based Haansoft has announced that it will ship a Mac
OS X version of its ThinkFree Office 3.0 suite close on the heels of
the July release of the Windows version.&quot;</p>
<p><a HREF="http://www.eweek.com/article2/0,1759,1830588,00.asp">http://www.eweek.com/article2/0,1759,1830588,00.asp</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.techworld.com/applications/news/index.cfm?NewsID=3919&amp;Page=1&amp;pagePos=11">http://www.techworld.com/applications/news/index.cfm?NewsID=3919&amp;Page=1&amp;pagePos=11</a></p>
<h1 CLASS="western"><a NAME="0.May 2005|outline"></a>May 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OpenDocument Format Formally Approved|outline"></a>
OpenDocument Format Formally Approved</h2>
<p>&quot;On 1 May the OASIS OpenDocument Technical Committee approved
as a standard the OpenDocument file format, which OpenOffice.org 2.0
Beta uses. OASIS is the primary body for e-business standards. As an
OASIS open standard, any office application may use the format;
vendor lock in to a proprietary format is not possible.&quot;</p>
<p><a HREF="http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=office">http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=office</a></p>
<h2 CLASS="western"><a NAME="0.0.Members Approve OpenDocument as OASIS Standard|outline"></a>
Members Approve OpenDocument as OASIS Standard</h2>
<p>&quot;XML doesn't always mean open. You can hide a lot in a file
format. OpenDocument represents an opportunity to ensure truly open
file formats for productivity applications, which is why it will
receive the enthusiastic support of public sector steering
organizations on a global basis,&quot; commented James Governor,
principal analyst at RedMonk. &quot;The participation of enterprises
in vertical industries, such as aerospace, will also ensure adoption
in the private sector. One key to success will be the royalty free
status of the spec; there are no financial penalties associated with
developing to it.&quot; 
</p>
<p>[...] 
</p>
<p>&quot;IBM recognizes the importance of a standards-based document
format. Use of open, non-proprietary formats will facilitate seamless
collaboration between vendors, customers and partners and ensure the
maintenance of corporate and government knowledge,&quot; said Karla
Norsworthy, vice president, Software Standards, IBM. &quot;IBM
supports the OASIS OpenDocument formats, and we believe the
standardization is a major accomplishment in an important area.&quot;
</p>
<p>&quot;Sun believes in the power of open standards to enhance
business productivity and to stimulate innovation by preserving the
intellectual property rights of content creators,&quot; said Tim
Bray, Technology Director at Sun Microsystems. &quot;Sun is a
founding member of the OASIS OpenDocument Technical Committee, and
Sun's StarOffice 8 productivity suite, based on the OpenOffice.org
project, uses OpenDocument as its default file format.&quot; 
</p>
<p><a HREF="http://www.oasis-open.org/news/oasis_news_05_23_05.php">http://www.oasis-open.org/news/oasis_news_05_23_05.php</a></p>
<h2 CLASS="western"><a NAME="0.0.Azeri Native-Lang project announced|outline"></a>
Azeri Native-Lang project announced</h2>
<p>&quot;Azeri Native-Lang project opened:OpenOffice.org welcomes a
new member in its family, the Azeri</p>
<p>native-lang project. Led by Emin Huseynov, this project is very
active in Azerbaidjan, working with several organizations and NGOs
and spreading OpenOffice.org in several administrations.</p>
<p>We wish good luck to the Azeri Native-Lang project!</p>
<p>Charles Schulz,</p>
<p>Lead of the Native-Lang Confederation,</p>
<p>OpenOffice.org&quot;</p>
<h2 CLASS="western"><a NAME="0.0.Polish Native-Lang Group announced|outline"></a>
Polish Native-Lang Group announced</h2>
<p>&quot;The Native-Lang Confederation of OpenOffice.org greets today
a long-awaited member. The Polish Native-Lang project
(http://pl.openoffice.org), led by Adam Dereszkiewicz, gathers all
the local polish initiatives and communities in one single and
efficient project designed to spread OpenOffice.org in Polish
language.  OpenOffice.org in Polish will help accelerate the adoption
of Free/Open Source Software in Poland, a country standing as one of
the liveliest areas for the development of the Free and Open Source
Software.</p>
<p>We wish good luck to Adam and his team.</p>
<p>Charles-H. Schulz,</p>
<p>Lead of the Native-Lang Confederation,</p>
<p>OpenOffice.org&quot;</p>
<h2 CLASS="western"><a NAME="0.0.Detroit high school opens its desktops|outline"></a>
Detroit high school opens its desktops</h2>
<p>&quot;In 2003, John Hansknecht, the director of technology at the
University of Detroit Jesuit High School and Academy, had a tough
decision to make. The school had about a hundred older computers
running Microsoft Office 97 and Windows NT, and some kind of upgrade
was clearly required. It would have been an easy decision to simply
upgrade to Microsoft Office 2000, but that would have required
replacing all the computers with more powerful systems -- a large
expenditure which could be better spent on other technology needs.
Hansknecht had a better idea: OpenOffice.org.&quot;</p>
<p><a HREF="http://software.newsforge.com/software/05/05/18/1944227.shtml?tid=130&amp;tid=93">http://software.newsforge.com/software/05/05/18/1944227.shtml?tid=130&amp;tid=93</a></p>
<h2 CLASS="western"><a NAME="0.0.Sun signs StarOffice agreement for 4,000 Irish schools|outline"></a>
Sun signs StarOffice agreement for 4,000 Irish schools</h2>
<p>&quot;The NCTE, which is an agency of Ireland's Department of
Education and Science, has signed a master distribution agreement
with Santa Clara, California-based Sun through which it will provide
Sun's StarOffice 7 to 3,200 primary school and 720 secondary schools
across the country.&quot;</p>
<p><a HREF="http://www.cbronline.com/article_news.asp?guid=FFF7AC2B-4012-4C44-A78E-9E6CE7F6EBCD">http://www.cbronline.com/article_news.asp?guid=FFF7AC2B-4012-4C44-A78E-9E6CE7F6EBCD</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.siliconrepublic.com/news/news.nv?storyid=single4835">http://www.siliconrepublic.com/news/news.nv?storyid=single4835</a></p>
<h2 CLASS="western"><a NAME="0.0.Open Source Software in Schools|outline"></a>
Open Source Software in Schools</h2>
<p>&quot;A project report evaluating the use of open source software
(OSS) within a small number of schools will be published on Friday,
13 May 2005 by Becta (British Educational Communications and
Technology Agency).</p>
<p>The project report from the study &quot;Open Source Software in
Schools: A study of the spectrum of use and related ICT
infrastructure costs&quot; demonstrates that although the
implementation of OSS in schools needs careful planning and support,
the use of OSS can offer a cost-effective alternative to proprietary
software.&quot;</p>
<p><a HREF="http://www.becta.org.uk/corporate/press_out.cfm?id=4681">http://www.becta.org.uk/corporate/press_out.cfm?id=4681</a></p>
<p>Full report:</p>
<p><a HREF="http://www.becta.org.uk/corporate/publications/documents/BEC5606_Full_report18.pdf">http://www.becta.org.uk/corporate/publications/documents/BEC5606_Full_report18.pdf</a></p>
<h2 CLASS="western"><a NAME="0.0.Open source makes school appointment|outline"></a>
Open source makes school appointment</h2>
<p>&quot;Becta, the Government's lead agency for ICT in education, is
set to release a new report which will say that schools could save
significant sums by switching to open source software, eGov monitor
can report.</p>
<p>The landmark report will show that OSS can be implemented
successfully in schools and present documented examples of cost
savings from its use.&quot;</p>
<p><a HREF="http://www.channelregister.co.uk/2005/04/25/open_source_school/">http://www.channelregister.co.uk/2005/04/25/open_source_school/</a></p>
<h2 CLASS="western"><a NAME="0.0.Local authorities keen on open source|outline"></a>
Local authorities keen on open source</h2>
<p>&quot;Roughly half of the UK's local authorities are planning to
increase their use of open source software over the next three years,
according to a Socitm survey</p>
<p>Cost, security and dissatisfaction with Microsoft will drive
almost two-thirds of local authorities to increase their use of open
source software over the next three years, according to new
research.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/0,39020330,39197835,00.htm">http://news.zdnet.co.uk/0,39020330,39197835,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Birmingham begins major open source pilot|outline"></a>
Birmingham begins major open source pilot</h2>
<p>&quot;The council  the largest in Europe  will move 1,500 desktops
and all the associated back-end servers in its library service to
Linux and other open source software including OpenOffice and
Firefox. The year-long trial will be backed by government money, and
include a final, neutral assessment of the value of the move. Public
terminals in libraries will be shifted to Linux, as well as office
systems in the library service.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/0,39020330,39198699,00.htm">http://news.zdnet.co.uk/0,39020330,39198699,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Bristol ready to put open source on 3,500 desktops|outline"></a>
Bristol ready to put open source on 3,500 desktops</h2>
<p>&quot;The roll-out will take a year to complete. &quot;People have
been concerned  that we are getting rid of Windows, which is not
true. When we go into  offices and show them the product, we see them
relaxing,&quot; Beckett said.&quot;</p>
<p><a HREF="http://www.computerweekly.com/articles/article.asp?liArticleID=138630&amp;liArticleTypeID=1&amp;liCategoryID=6&amp;liChannelID=1&amp;liFlavourID=1&amp;sSearch=&amp;nPage=1">http://www.computerweekly.com/articles/article.asp?liArticleID=138630&amp;liArticleTypeID=1&amp;liCategoryID=6&amp;liChannelID=1&amp;liFlavourID=1&amp;sSearch=&amp;nPage=1</a></p>
<h2 CLASS="western"><a NAME="0.0.Italian Automobile Club selects StarOffice (Italian articles only)|outline"></a>
Italian Automobile Club selects StarOffice (Italian articles only)</h2>
<p>According to the following articles, the software will be
installed on more than 3,200 seats:</p>
<p><a HREF="http://it.sun.com/pressmedia/comunicati_stampa_05/sunflash050905b.html">http://it.sun.com/pressmedia/comunicati_stampa_05/sunflash050905b.html</a></p>
<p><a HREF="http://www.cwi.it/showPage.php?template=articoli&amp;id=13001">http://www.cwi.it/showPage.php?template=articoli&amp;id=13001</a></p>
<h2 CLASS="western"><a NAME="0.0.Elite forces' health department trims operating costs|outline"></a>
Elite forces' health department trims operating costs</h2>
<p>&quot;The Arabic-enabled nature of Sun's StarOffice productivity
suite, as well as the significantly more affordable investment level
for the Sun desktop solution, were cited as the major causes for the
switch. 'SANG-HA's hospitals and health utilities are among the best
in the region. We have adopted a strategic IT plan, which will
contribute to the development of health services provided to the
patients. Infrastructure development is a major focus area for us,
and the ability to use Sun's Arabic-enabled StarOffice suite and
lower operational costs and is making a major impact on SANG-HA's
bottom line,' says Dr Majid Al Tuwaijri, executive director for
information systems and informatics at SANG-HA&quot;</p>
<p><a HREF="http://www.itp.net/news/details.php?id=15060&amp;category">http://www.itp.net/news/details.php?id=15060&amp;category</a>=</p>
<h2 CLASS="western"><a NAME="0.0.Tamil Language Open Source Tools &amp; Apps Released in Chennai|outline"></a>
Tamil Language Open Source Tools &amp; Apps Released in Chennai</h2>
<p>&quot;In Chennai, on April 15th, marking the Tamil New Year,
India's Ministry of Communications and Information Technology (MCIT)
showed off its latest efforts to help close India's digital divide. A
complete bundle of open source computer software including the
localized Tamil version of OpenOffice.org was released. Hundreds of
computer fonts and tools in Tamil were given away amid great fanfare
and political and media excitement.&quot;</p>
<p><a HREF="http://www.technetra.com/News/tamil_openoffice_html">http://www.technetra.com/News/tamil_openoffice_html</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.hindu.com/2005/04/16/stories/2005041600292200.htm">http://www.hindu.com/2005/04/16/stories/2005041600292200.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Millions in India to get OpenOffice|outline"></a>
Millions in India to get OpenOffice</h2>
<p>&quot;The government has started distributing CDs containing
Tamil-language versions of various open source applications,
including the Firefox browser, the OpenOffice.org productivity suite
and the Columba email client. It plans to freely distribute 3.5
million copies of the CD to Tamil speakers worldwide, according to
R.K.V.S. Raman, a researcher at the Centre for Development of
Advanced Computing, an organisation involved in the production of the
CD.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39199972,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39199972,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.StarOffice 8: Sun's Office Suite Takes on Microsoft|outline"></a>
StarOffice 8: Sun's Office Suite Takes on Microsoft</h2>
<p>&quot;Sun's product, StarOffice, has not yet stolen significant
market share from Microsoft Office, but if its latest beta release
(which we look at here), is any indication, Sun's taking its push
into the market seriously.&quot;</p>
<p><a HREF="http://www.smallbusinesscomputing.com/news/article.php/3501431">http://www.smallbusinesscomputing.com/news/article.php/3501431</a></p>
<h2 CLASS="western"><a NAME="0.0.Product review, OpenOffice.org 2.0 beta|outline"></a>
Product review, OpenOffice.org 2.0 beta</h2>
<p>&quot;As a long time user of OpenOffice.org back to the days when
it was called StarOffice 5.2, I watched the development process with
great interest over the years. As soon as the beta for 2.0 became
available I grabbed it eagerly. Since then I've downloaded several
updates and kept more or less up to date with the latest releases.
Here are my findings.&quot;</p>
<p><a HREF="http://htmlfixit.com/?p=619">http://htmlfixit.com/?p=619</a></p>
<h2 CLASS="western"><a NAME="0.0.Review: OpenOffice a Strong Competitor|outline"></a>
Review: OpenOffice a Strong Competitor</h2>
<p>&quot;The latest version of the free OpenOffice suite promises to
be a strong competitor to Microsoft Office. It's still in the &quot;beta,&quot;
or unfinished, stage, but it's already a good alternative for people
who aren't heavy users. And you can't argue with the price.&quot;</p>
<p><a HREF="http://www.informationweek.com/story/showArticle.jhtml?articleID=163103695&amp;tid=5979">http://www.informationweek.com/story/showArticle.jhtml?articleID=163103695&amp;tid=5979</a></p>
<h2 CLASS="western"><a NAME="0.0.Lesson number one: get rid of Microsoft|outline"></a>
Lesson number one: get rid of Microsoft</h2>
<p>&quot;The report shows, for example, that these schools spend less
than half of what their Microsoft-enthralled contemporaries have to
fork out on IT support. Other benefits include lower expenditure on
software licensing, and computers that have to be upgraded less
frequently because they no longer dance to the beat of Microsoft's
drum. The headline in the Times Educational Supplement said it all:
'Ditching Microsoft could save millions.'&quot;</p>
<p><a HREF="http://observer.guardian.co.uk/business/story/0,6903,1483969,00.htm">http://observer.guardian.co.uk/business/story/0,6903,1483969,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Ditching Microsoft can save millions|outline"></a>
Ditching Microsoft can save millions</h2>
<p>&quot;In a report to be published next week, obtained by The TES,
Becta will highlight schools which have turned to free software
instead of the market leaders products. Becta does not name Microsoft
in its analysis. But almost all schools use some of the companys
products.&quot;</p>
<p><a HREF="http://www.tes.co.uk/2094985">http://www.tes.co.uk/2094985</a></p>
<h2 CLASS="western"><a NAME="0.0.OO.o 2.0 pioneers new standard|outline"></a>
OO.o 2.0 pioneers new standard</h2>
<p>&quot;The Organization for the Advancement of Structured
Information Standards (OASIS) announced its approval of
OpenOffice.org's XML-based file format, Open Document Format for
Office Applications, as a new standard. An article at eWEEK.com,
explains what this means for the world in general, and for OpenOffice
users in particular.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS5688133549.html">http://www.desktoplinux.com/news/NS5688133549.html</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.eweek.com/article2/0,1759,1819239,00.asp?kc=EWRSS03129TX1K0000616">http://www.eweek.com/article2/0,1759,1819239,00.asp?kc=EWRSS03129TX1K0000616</a></p>
<p><a HREF="http://www.cbronline.com/article_news.asp?guid=24314FB0-65A5-4D4D-B1A7-C45E5A03BBA3">http://www.cbronline.com/article_news.asp?guid=24314FB0-65A5-4D4D-B1A7-C45E5A03BBA3</a></p>
<h2 CLASS="western"><a NAME="0.0.A Standard Set For The Office|outline"></a>
A Standard Set For The Office</h2>
<p>&quot;Officials at the non-profit standards body OASIS
(Organization for the Advancement of Structured Information
Standards) announced Monday its approval of the OpenDocuments 1.0
specification as a standard.</p>
<p>The ratification puts OASIS' seal of approval on a single
XML-based file format for text, spreadsheets, charts and graphical
documents -- an area dominated by Microsoft and its popular Office
suite.&quot;</p>
<p><a HREF="http://www.internetnews.com/dev-news/article.php/3507111">http://www.internetnews.com/dev-news/article.php/3507111</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.linuxelectrons.com/article.php/2005052323053132">http://www.linuxelectrons.com/article.php/2005052323053132</a></p>
<p><a HREF="http://tech.monstersandcritics.com/news/article_1002046.php/OASIS_approves_OpenOffice_2.0_file_format">http://tech.monstersandcritics.com/news/article_1002046.php/OASIS_approves_OpenOffice_2.0_file_format</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org File Viewer|outline"></a>
OpenOffice.org File Viewer</h2>
<p>&quot;OpenOffice.org File Viewer or OOoView. A Java-based
OpenOffice.org file viewer, this was created by Ms. Christine
Bejerasco, Mr. Cipriano Consolacion Jr., and Ms. Raquel Tarroza
(supervised by yours truly) as a requirement in earning their degree
in Computer Science.</p>
<p>The first version only supported OpenOffice.org version 1.0 file
formats. It was recently upgraded to support version 1.1.x file
formats and the upcoming OpenOffice.org 2.0 file formats.</p>
<p>OOoView source is now available at http://oooview.dev.java.net.&quot;</p>
<p><a HREF="http://www.mb.com.ph/TECH2005051634852.html">http://www.mb.com.ph/TECH2005051634852.html</a></p>
<p><a HREF="http://oooview.dev.java.net/">http://oooview.dev.java.net</a></p>
<h1 CLASS="western"><a NAME="0.April 2005|outline"></a>April 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org Conference 2005 - Please vote for the location!|outline"></a>
OpenOffice.org Conference 2005 - Please vote for the location!</h2>
<p>&quot;Dear OpenOffice.org user,</p>
<p>Every year, members of the OpenOffice.org community gather at the
official international OpenOffice.org Conference, or OOoCon. The
purpose of this conference is to allow members of the community to
meet face-to-face in a convivial environment, in order to share
coding tips, plans, technology; information, strategies, methods, and
success stories, with the aim of building a more successful community
project and product.</p>
<p>Koper, Slovenia and Lyon, France have been proposed as locations
for the OpenOffice.org Conference 2005. Please go to the following
web page to submit a vote for your favorite location:</p>
<p><a HREF="http://marketing.openoffice.org/conference/ooocon2005/proposal.html">http://marketing.openoffice.org/conference/ooocon2005/proposal.html</a></p>
<p>The deadline is April 30, 2005. The chosen location will be
announced shortly after that date. In order to be able to participate
in the voting you must be a registered members of the OpenOffice.org
site.</p>
<p>Thank you very much and best regards,</p>
<p>The OpenOffice.org Conference Team&quot;</p>
<p><a HREF="http://marketing.openoffice.org/conference/ooocon2005/proposal.html">http://marketing.openoffice.org/conference/ooocon2005/proposal.html</a></p>
<p>Original posting:</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=241">//servlets/ReadMsg?list=announce&amp;msgNo=241</a></p>
<h2 CLASS="western"><a NAME="0.0.NeoOffice/J Donates Code|outline"></a>
NeoOffice/J Donates Code</h2>
<p>NeoOffice/J is an independent project building a Java-powered
Aqua-fied Mac OS X port of OpenOffice.org. Its donation resolves
numerous bugs. Thanks! We look forward to further collaboration.</p>
<p>Donation message:</p>
<p><a HREF="http://porting.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=15387">http://porting.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=15387</a></p>
<p>NeoOffice/J Project:</p>
<p><a HREF="http://trinity.neooffice.org/">http://trinity.neooffice.org/</a></p>
<h2 CLASS="western"><a NAME="0.0.Albanian Native-Lang project announced|outline"></a>
Albanian Native-Lang project announced</h2>
<p>I would like to announce the opening of the Albanian Native-Lang
project (sq) led by Mr. Shkumbin Saneja. OpenOffice.org is now
available in Albanian, an ancient culture and language of Southern
Europe.</p>
<p>This project have increased the interest about Open Source
applications,  in Albanian language speaking areas. As there is no
other office suite in Albanian, there are good chances that
OpenOffice.org will take the leading role.</p>
<p>Good luck for the Albanian native-lang project and hopefully we'll
be hearing from OpenOffice.org and other FOSS deployments in Albania
soon!</p>
<p>You can visit the Albanian project page here:
<a HREF="http://sq.openoffice.org/">http://sq.openoffice.org</a></p>
<p>Charles-H. Schulz,</p>
<p>Lead of the Native-Lang Confederation,</p>
<p>OpenOffice.org</p>
<h2 CLASS="western"><a NAME="0.0.Spreading OpenOffice Tamil|outline"></a>
Spreading OpenOffice Tamil</h2>
<p>I would like to tell you about a great and perhaps an
unprecendented thing that has happened to OpenOffice.org.</p>
<p>On April 15th 2005 the IT Minister of the country dedicated
OpenOffice.org 1.1.4 in Tamil to the Nation and brought it out as a
CD. This CD will be distributed free to those who request for it.</p>
<p>Apart from OpenOffice.org 1.1.4 in Tamil , the CD also contained
open type fonts, Firefox browser , email-client, OCR tools and speel
checkers all for Tamil Language.</p>
<p>In the coming months the ministry plans to distribute about 3
million copies of this CD to Tamilians all over the world.</p>
<p>Already about 50,000 copies of CD have been produced and are being
distributed. 
</p>
<p>So atleast among Tamil Speaking people, we would soon see
everybody using OpenOffice.org instead of proprietary softwares.</p>
<p>Apart from this I also had an opportunity to demo OpenOffice.org
in a TV interview for a Tamil News Channel called &quot;SUN NEWS&quot;</p>
<p>This interview will be telecasted on the &quot;SUN NEWS&quot;
Channel on Sunday 24/04/05 at 17:30pm (Indian Standard Time) .</p>
<p>So big time for OpenOffice.org among Tamilians.  Let us celebrate
the moment.&quot;</p>
<p>[Raman, Project co-ordinator for BharateeyaOO.o Project</p>
<p>(http://www.ncb.ernet.in/bharateeyaoo)]</p>
<p>Original posting:</p>
<p><a HREF="http://marketing.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=20240">http://marketing.openoffice.org/servlets/ReadMsg?list=dev&amp;msgNo=20240</a></p>
<h2 CLASS="western"><a NAME="0.0.StarOffice at the Idaho National Laboratory (INL)|outline"></a>
StarOffice at the Idaho National Laboratory (INL)</h2>
<p>&quot;Deployments of Sun's Grid technology announced in 2004
spanned industries ranging from government to financial services to
education. Notable wins included the Idaho National Laboratory (INL),
the Texas Advanced Computing Center, University of Leicester,
Stanford Linear Accelerator Center, University of Nottingham, and
several others.</p>
<p>Sun and INL teamed on a solution that includes more than 230 Sun
Fire V20z servers powered by AMD Opteron processors, and more than 12
Terabytes of Sun StorEdge(TM) 6320 storage, the Solaris 10 operating
system, Sun Java(TM) Enterprise System and Java development software,
Sun Grid Engine Enterprise Edition, Sun's StarOffice(TM) 7.0 office
productivity platform, as well as advanced on-site training and
support from Sun's Services division. The cluster's full-throttle
computing power ranks the INL datacenter as one of the world's top
supercomputing sites.&quot; 
</p>
<p><a HREF="http://biz.yahoo.com/prnews/050426/sftu070.html?.v=7">http://biz.yahoo.com/prnews/050426/sftu070.html?.v=7</a></p>
<h2 CLASS="western"><a NAME="0.0.Small college saves big with OpenOffice.org and Linux|outline"></a>
Small college saves big with OpenOffice.org and Linux</h2>
<p>Duncan remains pleased with the results of his creativity. &quot;This
puts us in control of our tech resources, instead of relying on some
third party. It's kind of a scary to say there's some company out
there telling me I'm going to buy a new computer every two years.
We've doubled the number of computers we have available to us with
the cost-savings of OpenOffice.org versus Microsoft Office. We've
made available open access to labs and cyber cafs using hardware that
others would have just thrown away.</p>
<p>&quot;OpenOffice.org made a lot of that possible.&quot;</p>
<p><a HREF="http://business.newsforge.com/business/05/03/30/2033252.shtml?tid=37&amp;tid=132&amp;tid=2">http://business.newsforge.com/business/05/03/30/2033252.shtml?tid=37&amp;tid=132&amp;tid=2</a></p>
<h2 CLASS="western"><a NAME="0.0.Why UK's Access Devices cooked up its own embedded open source OS|outline"></a>
Why UK's Access Devices cooked up its own embedded open source OS</h2>
<p>&quot;Access Devices, founded in 2001, is a digital video
equipment designer and manufacturer in the United Kingdom. With the
help of open source software consulting company Sirius, Access moved
entirely from Windows desktops to Linux and OpenOffice.org. Then,
after CEO Anthony Walton discovered how far Linux and other open
source software had come in terms of quality and viability, he
decided to commit to open source in a different way.&quot;</p>
<p><a HREF="http://business.newsforge.com/article.pl?sid=05/04/14/2123248">http://business.newsforge.com/article.pl?sid=05/04/14/2123248</a></p>
<h2 CLASS="western"><a NAME="0.0.StarOffice at the City of Marghera|outline"></a>
StarOffice at the City of Marghera</h2>
<p>&quot;The City of Marghera, Venice Municipality (Italy) -- The
City of Marghera (Venice municipality), in cooperation with Sun
Microsystems Italy, realized an IT laboratory for Marghera citizens,
the Internet Center &quot;Marghera digitale&quot;. The IT
infrastructure, designed and implemented by Sun Microsystems Italy,
includes more than 30 Sun Ray(TM) clients, three servers and a
software environment with StarOffice(TM) software &amp; the Sun Java
Desktop System.&quot;</p>
<p><a HREF="http://biz.yahoo.com/prnews/050426/sftu067.html?.v=7">http://biz.yahoo.com/prnews/050426/sftu067.html?.v=7</a></p>
<h2 CLASS="western"><a NAME="0.0.MIP Holdings moves most users to open source|outline"></a>
MIP Holdings moves most users to open source</h2>
<p>&quot;Fortunately, the open source alternatives proved to be fully
functional, stable and reliable solutions that were not difficult for
users to adapt to. In extreme situations, power users may need more
than these alternatives offer, but these users are rare. MIP
therefore embarked on an upgrade project installing OpenOffice on its
workstations.</p>
<p>The roll-out went smoothly, again, with no users finding they
could not complete their daily tasks on the new software. Firth says
some of the functions in OpenOffice are accessible via different
keystrokes or mouse clicks, but these changes are easily overcome
with a little coaching. &quot;The savings on licence fees is
enormous,&quot; he notes. &quot;But most importantly, we are saving
money without sacrificing productivity or limiting user
functionality.&quot;&quot;</p>
<p><a HREF="http://www.itweb.co.za/sections/enterprise/2005/0504080908.asp?A=ENA&amp;S=Enterprise%20Architecture&amp;O=FPIN">http://www.itweb.co.za/sections/enterprise/2005/0504080908.asp?A=ENA&amp;S=Enterprise%20Architecture&amp;O=FPIN</a></p>
<h2 CLASS="western"><a NAME="0.0.4,000 StarOffice licenses at SANG-HA|outline"></a>
4,000 StarOffice licenses at SANG-HA</h2>
<p>&quot;As a sign of its progressive approach to utilizing the
latest technology to provide first class medical services, SANG-HA
recently deployed 1,500 SunRay thin client desktop systems, in
addition to purchasing 4,000 StarOffice licenses, in order to refresh
its IT technology strategy. In addition to SANG-HA, Sun counts Saudi
Aramco, STC, and SAMBA as key customers in the Kingdom.&quot;</p>
<p><a HREF="http://www.ameinfo.com/58111.html">http://www.ameinfo.com/58111.html</a></p>
<h2 CLASS="western"><a NAME="0.0.State govt logs on to cost-cutting drive|outline"></a>
State govt logs on to cost-cutting drive</h2>
<p>&quot;In the past few months, OpenOffice, a free downloadable
package of commonly-used applications like spreadsheets, word
processing and email, has become the official choice for thousands of
desktops across the state, and is expected to save the exchequer
about Rs 90 crore in licence fees. Recently, the Maharashtra police
headquarters too plumped for free operating system GNU/Linux with
OpenOffice. That's not all. Already, the election office is using a
bi-lingual voter-list search system developed by free software
activists, while corporate open sourcers like Red Hat are providing
software for the government's treasury management, citizens' facility
centres and land record management.&quot;</p>
<p><a HREF="http://timesofindia.indiatimes.com/articleshow/1081589.cms">http://timesofindia.indiatimes.com/articleshow/1081589.cms</a></p>
<h2 CLASS="western"><a NAME="0.0.Thailand: The case for open source software|outline"></a>
Thailand: The case for open source software</h2>
<p>&quot;To counter the compatability issue, Sipa, Nectec and Sun
Microsystems Thailand are now working to make OpenOffice 2.0 _ an
open source office suite _ a standard program. In the past, there
have been various office software suites, including Pladao, OfficeTLE
and OpenOffice, which according to Mr Clark can create confusion.</p>
<p>Sipa, Nectec and Sun Microsystems are now merging some parts of
Pladao and OfficeTLE into OpenOffice 2.0.&quot;</p>
<p><a HREF="http://www.bangkokpost.com/300305_Database/30Mar2005_data51.php">http://www.bangkokpost.com/300305_Database/30Mar2005_data51.php</a></p>
<h2 CLASS="western"><a NAME="0.0.DHBs to test open source alternative to Windows and Office|outline"></a>
DHBs to test open source alternative to Windows and Office</h2>
<p>&quot;First, the DHBs will pilot an open source desktop
environment, being put together by Steve Rayner, CIO of Wanganui DHB,
to assess how many users it will serve adequately. Rayner plans to
support two categories of user: &quot;power users&quot; with
Microsoft desktop software, and &quot;regular clinical users&quot;
with Novell Enterprise Desktop, OpenOffice.org and GroupWise running
on Suse Linux.&quot;</p>
<p><a HREF="http://computerworld.co.nz/news.nsf/0/39A5FAC6A45E8FB2CC256FDA00319B5C?OpenDocument&amp;pub=Computerworld">http://computerworld.co.nz/news.nsf/0/39A5FAC6A45E8FB2CC256FDA00319B5C?OpenDocument&amp;pub=Computerworld</a></p>
<h2 CLASS="western"><a NAME="0.0.NZ open source trial attracts gov't attention|outline"></a>
NZ open source trial attracts gov't attention</h2>
<p>&quot;The Wanganui pilot will seek to establish how many users
there are with just basic computing needs and whether it is possible
to meet those with a non-Microsoft environment. It will be based on
Suse Linux and OpenOffice.org.&quot;</p>
<p><a HREF="http://www.computerworld.com.au/index.php/id;1561121703;fp;16;fpid;0">http://www.computerworld.com.au/index.php/id;1561121703;fp;16;fpid;0</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice 2.0 to break down walls to adoption|outline"></a>
OpenOffice 2.0 to break down walls to adoption</h2>
<p>&quot;Industry experts who have taken a look at the OpenOffice.org
2.0 said new database functionality included with the open source
personal productivity suite will go a long way toward making the
system a viable alternative to Microsoft Office -- especially in the
all important small and medium-sized business (SMB) market.&quot;</p>
<p><a HREF="http://searchenterpriselinux.techtarget.com/originalContent/0,289142,sid39_gci1073674,00.html">http://searchenterpriselinux.techtarget.com/originalContent/0,289142,sid39_gci1073674,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.First Look: OpenOffice.org 2.0 Looks Good|outline"></a>
First Look: OpenOffice.org 2.0 Looks Good</h2>
<p>&quot;In addition to Base, the database app, OpenOffice.org 2.0
includes a word processor, a spreadsheet application, a presentation
program, an app for creating mathematical formulas, and a nifty
drawing program much more powerful and fun than Microsoft's Paint.
The beta version is available for Windows, Linux, and Mac machines.&quot;</p>
<p><a HREF="http://www.pcworld.com/reviews/article/0,aid,120154,00.asp">http://www.pcworld.com/reviews/article/0,aid,120154,00.asp</a></p>
<h2 CLASS="western"><a NAME="0.0.Download some of the best software money can't buy|outline"></a>
Download some of the best software money can't buy</h2>
<p>&quot;Don't want to deal with the hassles of incompatible files?
No problem - OpenOffice.org can create, open, edit, and save Word,
Excel, and PowerPoint documents. Plus, it's available for multiple
platforms, including Windows, Macintosh, and Linux.</p>
<p>This is an outstanding solution for college students, home
offices, and pretty much anyone who wants Microsoft Office-caliber
functionality without the sticker shock.&quot;</p>
<p><a HREF="http://hometownlife.com/WestBloomfield/News.asp?pageType=StoryCurrent&amp;StoryArchiveID=94436&amp;StoryID=10661&amp;Section=At%20Home&amp;OnlineSection=At%20Home&amp;SectionPubDate=Thursday,%20March%2031,%202005&amp;RefDate=3/31/2005">http://hometownlife.com/WestBloomfield/News.asp?pageType=StoryCurrent&amp;StoryArchiveID=94436&amp;StoryID=10661&amp;Section=At%20Home&amp;OnlineSection=At%20Home&amp;SectionPubDate=Thursday,%20March%2031,%202005&amp;RefDate=3/31/2005</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice is a decent alternative|outline"></a>
OpenOffice is a decent alternative</h2>
<p>&quot;Don't take that to mean I've explored every nook and cranny
of the 2.0 beta. However, I've looked at enough to know that users
should consider using it over paying out cash for Microsoft Office, a
software that's gotten fatter and fatter.&quot;</p>
<p><a HREF="http://www.thestate.com/mld/thestate/business/11197462.htm">http://www.thestate.com/mld/thestate/business/11197462.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Ask Slashdot: OpenOffice vs. MS Office for Education_|outline"></a>
Ask Slashdot: OpenOffice vs. MS Office for Education?</h2>
<p>&quot;I work in a large high school district where there will be
some discussion on whether or not to purchase another term of
'Software Assurance' for MS Office licenses on thousands of
computers. This seems to be an ideal opportunity to promote an
alternative such as OpenOffice. It will not be an easy sell, even
though OpenOffice should more than satisfy all curricular needs and
save the district lots of money; like many other districts we have
political and cultural 'challenges'. So, I ask you, have you been
successful in moving your education or business organization from MS
Office to OpenOffice? What were the pros and cons from your
migration? What advice do you have in selling this to tech
coordinators and administrators who are not enlightened by Open
Source?&quot;</p>
<p><a HREF="http://ask.slashdot.org/article.pl?sid=05/04/20/1753225&amp;tid=146&amp;tid=102&amp;tid=201&amp;tid=4">http://ask.slashdot.org/article.pl?sid=05/04/20/1753225&amp;tid=146&amp;tid=102&amp;tid=201&amp;tid=4</a></p>
<h2 CLASS="western"><a NAME="0.0.IBM Certifies OpenDocument Successful Implementation|outline"></a>
IBM Certifies OpenDocument Successful Implementation</h2>
<p>&quot;Formal statement:  IBM Corporation certifies that it is
successfully using the Open Document Format for Office Applications
(OpenDocument) 1.0  specification consistently with the OASIS IPR
Policy.  -- Nathaniel Borenstein, Distinguished Engineer and Open
Standards Strategist, IBM Corporation&quot;</p>
<p><a HREF="http://lists.oasis-open.org/archives/office/200503/msg00020.html">http://lists.oasis-open.org/archives/office/200503/msg00020.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OASIS Members to vote on OpenDocument XML Format|outline"></a>
OASIS Members to vote on OpenDocument XML Format</h2>
<p>&quot;OASIS organizational members are asked to vote on four
specifications that have been submitted for consideration as OASIS
Standards. The ebXML Registry Information Model (RIM) v3.0 and ebXML
Registry Services and Protocols (RS) v3.0 offer a method for defining
and managing interoperable registries and repositories. OpenDocument
provides an XML-based file format specification for office
applications.&quot; 
</p>
<p><a HREF="http://xml.sys-con.com/read/77288.htm">http://xml.sys-con.com/read/77288.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Gentoo update for openoffice|outline"></a>
Gentoo update for openoffice</h2>
<p>&quot;Gentoo has issued updates for openoffice. These fix a
vulnerability,which can be exploited by malicious people to
compromise a user's system.&quot;</p>
<p><a HREF="http://secunia.com/advisories/14983/">http://secunia.com/advisories/14983/</a></p>
<h1 CLASS="western"><a NAME="0.March 2005|outline"></a>March 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org Announces Version 2.0 Public Beta|outline"></a>
OpenOffice.org Announces Version 2.0 Public Beta</h2>
<p>4 MARCH, 2005 - 08H00 UTC</p>
<p>The OpenOffice.org project is pleased to announce that the first
public beta release of OpenOffice.org 2.0 is now available for
download.</p>
<p>OpenOffice.org 2.0 Beta is immediately available in English for
Windows, GNU/Linux and Solaris. Additional platforms and
localisations for Brazilian Portuguese, German, Italian, Japanese,
Korean, Russian, Spanish, Swedish, Simplified Chinese, Traditional
Chinese and Turkish, amongst others, will follow shortly.</p>
<p>The release of OpenOffice.org 2.0 Beta coincides with the Danish
LinuxForum 2005 and with the Open Source Days in Turkey.  Both events
demonstrate the gaining power of open source and especially the force
for change OpenOffice.org 2.0 represents.  We are honoured to be
included in these important events.</p>
<p>This beta release is the result of many months work in expanding
the functionality, performance and compatibility of the office suite.
This intense effort has yielded impressive results including the
addition of a new database module, implementation of the OASIS
OpenDocument XML file format and a host of other new features and
capabilities.</p>
<p>The public beta release is made available in order to allow a
broad user base to test and evaluate this new major version of
OpenOffice.org, but is not recommended for production deployment at
this stage.</p>
<p>Beta Availability</p>
<p>The beta version and it's source code can be downloaded from</p>
<p><a HREF="/download/2.0beta/index.html">/download/2.0beta/index.html</a></p>
<p>Feature Guide</p>
<p>A more detailed guide to the features can be found at</p>
<p><a HREF="//dev_docs/features/2.0/index.html">//dev_docs/features/2.0/index.html</a>.</p>
<p>Error and Bug Reporting</p>
<p>Users of the OpenOffice.org 2.0 Beta release are encouraged to
join the</p>
<p>OpenOffice.org project and report any bugs, issues or errors at</p>
<p><a HREF="http://qa.openoffice.org/issue_handling/project_issues.html">http://qa.openoffice.org/issue_handling/project_issues.html</a>.</p>
<p>For ongoing updates regarding beta releases of OpenOffice.org 2.0,</p>
<p>please subscribe to the OpenOffice.org Announce mailing list at</p>
<p><a HREF="//mail_list.html#general">//mail_list.html#general</a>.</p>
<h2 CLASS="western"><a NAME="0.0.First Native-Lang Group has been launched|outline"></a>
First Native-Lang Group has been launched</h2>
<p>&quot;I would like to announce that the first Native-Language
Group has been launched. To those who are wondering &quot;what is a
native-language group?&quot;, it can be summed up as a group of
several native-lang 
</p>
<p>projects (see: <a HREF="http://native-lang.openoffice.org/">http://native-lang.openoffice.org</a>)
willing to help each others and coordinate their actions.</p>
<p>The first native-language group is the Indic Native-Language
Group, composed of the following communities:</p>
<ul>
	<li><p>the Hindi native-lang project (http://hi.openoffice.org)</p>
	<li><p>the Tamil native-lang project (http://ta.openoffice.org)</p>
	<li><p>the Bengali native-lang project (http://bn.openoffice.org)</p>
	<li><p>the Malayalam native-lang project (http://ml.openoffice.org)</p>
	<li><p>the Telugu native-lang project (http://te.openoffice.org)</p>
	<li><p>the Gujarati native-lang project  (http://gu.openoffice.org)</p>
</ul>
<p>More Indic projects can be added to this list in the future. As
part of its mission, the Indic native-lang group will have to</p>
<ul>
	<li><p>coordinate  localization efforts and developments</p>
	<li><p>mutualize and help the projects with the localized builds'QA.</p>
	<li><p>speed up the adoption of OpenOffice.org on a local basis and
	help coordinate its promotion</p>
	<li><p>coordinate documentation writing</p>
	<li><p>communicate with the other projects of OOo and the
	native-lang confederation</p>
	<li><p>ease the communication between the Indic native-lang projects</p>
</ul>
<p>This group comes as an answer for the native-lang projects to
avoid the &quot;walled garden&quot; effect that some projects have to
face, while at the mean time help these projects who lack ressources
and time to develop and build themselves. Expect more groups to come
in a near future.</p>
<p>I would also like to congratulate Vijay Kumar and Rajesh Rajan for
their newly appointed positions as the Group coordinators. Meanwhile,
the rights and deeds of the native-lang projects' leads remain
unchanged.</p>
<p>Regards,</p>
<p>Charles-H. Schulz,</p>
<p>Lead of the Native-Lang Confederation,</p>
<p>OpenOffice.org&quot;</p>
<h2 CLASS="western"><a NAME="0.0.Linux in Business and Governments: An Idea Whose Time Has Come|outline"></a>
Linux in Business and Governments: An Idea Whose Time Has Come</h2>
<p>&quot;At least 80,000 PCs will be concerned by the migration
before the end of the year. In a first step, 35,000 PCs will be
equipped by OpenOffice.org before the summer. OpenOffice will be
used, as Microsoft Office, for the rapports and statements, but will
offer more services than Word and Excel.</p>
<p>The National Gendarmerie has announced that the migration, the
technical support and the personnel training will be managed without
any external help.</p>
<p>It is expected to save 2 million euro by year through this
migration.&quot;</p>
<p><a HREF="http://www.cooltechzone.com/index.php?option=content&amp;task=view&amp;id=1121&amp;Itemid=0&amp;limit=1&amp;limitstart=0">http://www.cooltechzone.com/index.php?option=content&amp;task=view&amp;id=1121&amp;Itemid=0&amp;limit=1&amp;limitstart=0</a></p>
<h2 CLASS="western"><a NAME="0.0.The case for open source software|outline"></a>
The case for open source software</h2>
<p>&quot;To counter the compatability issue, Sipa, Nectec and Sun
Microsystems Thailand are now working to make OpenOffice 2.0 _ an
open source office suite _ a standard program. In the past, there
have been various office software suites, including Pladao, OfficeTLE
and OpenOffice, which according to Mr Clark can create confusion.</p>
<p>Sipa, Nectec and Sun Microsystems are now merging some parts of
Pladao and OfficeTLE into OpenOffice 2.0. &quot;</p>
<p><a HREF="http://www.bangkokpost.com/Database/30Mar2005_data51.php">http://www.bangkokpost.com/Database/30Mar2005_data51.php</a></p>
<h2 CLASS="western"><a NAME="0.0.Availability of OpenOffice.org &amp; Staroffice Indexer for Google Dekstop Search|outline"></a>
Availability of OpenOffice.org &amp; Staroffice Indexer for Google
Dekstop Search</h2>
<p>&quot;Allow Google Desktop Search to index all OpenOffice.org and
StarOffice 6 or later files, including text documents, spreadsheets,
presentations and templates. Supported file types are SXC, STC, SXD,
STD, SXI, STI, SXW, SXG, and STW.&quot;</p>
<p><a HREF="http://desktop.google.com/plugins/indextheopenoffice.html">http://desktop.google.com/plugins/indextheopenoffice.html</a></p>
<p><a HREF="http://www.trivex.net/">http://www.trivex.net/</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org Beta 2.0: Trouble for Microsoft|outline"></a>
OpenOffice.org Beta 2.0: Trouble for Microsoft</h2>
<p>&quot;OpenOffice has many features, but one of the most
significant features for first time users has to be the crossover
between the various modules. The knowledge gained in Writers easily
transferred to Calc and vice-versa. This makes working with
OpenOffice.org very comfortable, even more so than Microsoft Office.</p>
<p>OpenOffice has reached the stage of being able to competently and
comfortably replace Microsoft Office as your main office suite.
Consider the fact that it is free, and yet manages to beat Microsoft
Office at it's own game; it's a compliment in itself. The only thing
that you have to do now is wait for the final version of OpenOffice
2.0 to begin your journey to the world of Open Source. If you are
impatient to begin, grab the beta and dive right in. The water's
fine.&quot;</p>
<p><a HREF="http://www.cooltechzone.com/index.php?option=content&amp;task=view&amp;id=1073">http://www.cooltechzone.com/index.php?option=content&amp;task=view&amp;id=1073</a></p>
<h2 CLASS="western"><a NAME="0.0.First look: OpenOffice.org version 2.0 beta|outline"></a>
First look: OpenOffice.org version 2.0 beta</h2>
<p>&quot;OpenOffice.org has always been conservative with version
numbers. Enough minor releases have boasted enough new features that
the current release could easily be 3.0 or 4.0 instead of 1.1.4.
Given this record, it's hardly surprising that version 2.0, for which
beta code is set to be unveiled very shortly, amounts to a major
rewrite of the software. Although key functionality remains largely
intact, version 2.0 promises dozens, possibly hundreds, of changes.
Many times during our testing of the pre-beta release, we felt we
could almost have been looking at an entirely new piece of software.&quot;</p>
<p><a HREF="http://www.newsforge.com/article.pl?sid=05/02/25/209222">http://www.newsforge.com/article.pl?sid=05/02/25/209222</a></p>
<h2 CLASS="western"><a NAME="0.0.A first look at OpenOffice.org 2.0|outline"></a>
A first look at OpenOffice.org 2.0</h2>
<p>&quot;It is not too bold to say that OpenOffice.org 2.0 will usher
in a new era of functionality, reliability, compatibility and ease of
use. The extensive changes and enhancements which are to be included
in the upcoming release are all the evidence needed to justify this
assertion.</p>
<p>For those who are impatient and unwilling to wait for the final
release, today sees the public availability of the first beta version
of OpenOffice.org 2.0. This beta is not for the faint of heart, and
should not be considered as reliable or be used in a production
environment.&quot;</p>
<p><a HREF="http://www.tectonic.co.za/view.php?id=420">http://www.tectonic.co.za/view.php?id=420</a></p>
<h2 CLASS="western"><a NAME="0.0.Illuminata analyst on OpenOffice.org|outline"></a>
Illuminata analyst on OpenOffice.org</h2>
<p>&quot;Illuminata analyst Gordon Hoff said that Microsoft must
convince customers that Longhorn will offer more than incremental
improvements. &quot;We're reaching the point where, without more
substantive changes -- more frankly disruptive changes --
improvements are more and more incremental. So something like
OpenOffice can increasingly be the functional equivalent of what
Microsoft does.&quot;&quot;</p>
<p><a HREF="http://www.internetnews.com/ent-news/article.php/3493416">http://www.internetnews.com/ent-news/article.php/3493416</a></p>
<h2 CLASS="western"><a NAME="0.0.MS Office meets its match|outline"></a>
MS Office meets its match</h2>
<p>&quot;However, I'm not here to tell you how easy the install
process is or how well OpenOffice performs in terms of speed compared
with Microsoft Office.  
</p>
<p>Instead, I'm here to tell you that it has just about all the same
main features Microsoft Office has and comes at absolutely no cost.&quot;</p>
<p><a HREF="http://star-techcentral.com/tech/story.asp?file=/2005/2/22/prodit/10176856&amp;sec=prodit">http://star-techcentral.com/tech/story.asp?file=/2005/2/22/prodit/10176856&amp;sec=prodit</a></p>
<h1 CLASS="western"><a NAME="0.February 2005|outline"></a>February
2005</h1>
<h2 CLASS="western"><a NAME="0.0.Winner, OpenOffice.org 2.0 Splashscreen competition|outline"></a>
Winner, OpenOffice.org 2.0 Splashscreen competition</h2>
<p>&quot;All,</p>
<p>Thousands of OpenOffice.org community members participated in the
voting for the OpenOffice.org 2.0 splashscreen. People could vote for
their favourite three choices from the eleven splashscreens
shortlisted form over 340 submissions from 103 artists and designers.</p>
<p>We are pleased to announce that Brendan Wheelan was the outright
winner with his splashscreen design:</p>
<p><a HREF="//editorial/bwhelan.html">//editorial/bwhelan.html</a></p>
<p>Brendan, a professional programmer, has since worked with the
development team to finalise the artwork to be included in
OpenOffice.org 2.0 Beta, including the splashscreen, about box and
installer graphics.</p>
<p>The splashscreen competition not only provided a successful
splashscreen, but created awareness of the OpenOffice.org Art Project
(http://marketing.openoffice.org/art/) that is responsible for the
creation and maintenance of graphics and art pieces for the
OpenOffice.org community.</p>
<p>Thank you to all the artists who participated in the splashscreen
competition. We look forward to any other ways you may wish to
contribute to the OpenOffice.org Art Project.</p>
<p>Congratulations Brendan, and a big thank you also to all the
community members who participated in voting for the splashscreen.</p>
<p>Regards</p>
<p>Jacqueline McNally</p>
<p>Lead, OpenOffice.org Marketing Project&quot;</p>
<h2 CLASS="western"><a NAME="0.0.L.A. mulls open source|outline"></a>L.A.
mulls open source</h2>
<p>&quot;Three Los Angeles council members want the city to switch to
an open-source platform to save millions of dollars in software
costs.</p>
<p>Council members Eric Garcetti, Wendy Greul and Jack Weiss
introduced a motion yesterday asking the city's Information
Technology Agency about a transition from proprietary software
licenses to open-source platforms and programs. The money saved could
be used to hire more police personnel, the council members said.&quot;</p>
<p><a HREF="http://www.fcw.com/geb/articles/2005/0131/web-lalinux-02-03-05.asp">http://www.fcw.com/geb/articles/2005/0131/web-lalinux-02-03-05.asp</a></p>
<h2 CLASS="western"><a NAME="0.0.LA Investigates Open Source To Cut Costs|outline"></a>
LA Investigates Open Source To Cut Costs</h2>
<p>&quot;For example, Kamensky said city officials could save US$5.2
million by switching to OpenOffice, an open-source desktop Trade in
your old desktops, laptops and servers and get great deals on HP
technology. computer suite that includes word processor and
spreadsheet programs, rather than purchasing a Microsoft (Nasdaq:
MSFT) Latest News about Microsoft Office product at $200 per license
for 26,000 desktops. The savings would go to a special fund to hire
more employees for the police department, a major focus for city
officials right now, he added.&quot;</p>
<p><a HREF="http://www.linuxinsider.com/story/LA-Investigates-Open-Source-To-Cut-Costs-40828.html">http://www.linuxinsider.com/story/LA-Investigates-Open-Source-To-Cut-Costs-40828.html</a></p>
<h2 CLASS="western"><a NAME="0.0.LinuxWorld preview: Open source rules, SCO fades and apps abound|outline"></a>
LinuxWorld preview: Open source rules, SCO fades and apps abound</h2>
<p>&quot;Steven Thompson, CTO of building products corporation Omega
Products International, is implementing SuSE Linux, in a
departmentally-phased approach and only buying new software that is
Web-based and certified with a Mozilla/Firefox client. &quot;We are
switching the entire company over to OpenOffice this year, [and] 45%
of desktops have been switched to date,&quot; he said.&quot;</p>
<p><a HREF="http://searchenterpriselinux.techtarget.com/originalContent/0,289142,sid39_gci1052513,00.html">http://searchenterpriselinux.techtarget.com/originalContent/0,289142,sid39_gci1052513,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Sun Microsystems Hosts Annual Worldwide Education And Research Conference|outline"></a>
Sun Microsystems Hosts Annual Worldwide Education And Research
Conference</h2>
<p>&quot;During the event, Mayor Newsom will announce an alliance
between the city of San Francisco and Sun that will offer free access
to Sun's StarOffice(TM) productivity suite software to all students
and teachers throughout the city. More than 200,000 students in all
public and private K-12, community colleges and universities, and
more than 5,000 teachers in these same institutions, will be able to
benefit from the word processing, spreadsheet, presentation, drawing
and database capabilities of StarOffice. The value of this alliance
is estimated to be more than $5,000,000. For a limited time, students
and teachers in the city of San Francisco can download the free
software by registering at http://www.sun.com/edu/edusoft.&quot;</p>
<h2 CLASS="western"><a NAME="0.0.Vienna takes the boldest step of all - asking the users|outline"></a>
Vienna takes the boldest step of all - asking the users</h2>
<p>&quot;Some of that revolutionary yet pragmatic spirit can still be
found in the city's IT department. Rather than mandate a switch to
Linux and OpenOffice.org (OOo), the department is letting the people
decide. They have a choice between Microsoft Office or OOo on
Windows, or they can move to Linux and OOo. IT will support any
choice but will charge more for the Microsoft alternatives -- and
will train those who want to make the switch.&quot;</p>
<p><a HREF="http://comment.zdnet.co.uk/other/0,39020682,39185491,00.htm">http://comment.zdnet.co.uk/other/0,39020682,39185491,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.7,000 OpenOffice.org users at Indian bank|outline"></a>
7,000 OpenOffice.org users at Indian bank</h2>
<p>&quot;One of Indias most savvy IT users, HDFC Bank, has deployed
Linux as the platform for two applicationsa proxy server and PKI
(Public Key Infrastructure). The bank has been using OpenOffice on
more than 7,000 desktops for about two years. It has also deployed
Linux-based desktops for the use of its outbound telemarketing team.&quot;</p>
<p><a HREF="http://www.expresscomputeronline.com/20050228/opensource01.shtml">http://www.expresscomputeronline.com/20050228/opensource01.shtml</a></p>
<h2 CLASS="western"><a NAME="0.0.Banking on Indian ISVs|outline"></a>Banking
on Indian ISVs</h2>
<p>&quot;Microsofts intention to create Office for Banks is part of
the companys efforts to thwart the success of alternative office
suites available from vendors such as Sun Microsystems (StarOffice)
and C K Technologies (Shakti Office) in the banking space. HDFC Bank
uses StarOffice while Bank of Baroda uses Shakti Office.&quot;</p>
<p><a HREF="http://www.expresscomputeronline.com/20050228/market01.shtml">http://www.expresscomputeronline.com/20050228/market01.shtml</a></p>
<h2 CLASS="western"><a NAME="0.0.2004 LinuxQuestions.org Members Choice Awards|outline"></a>
2004 LinuxQuestions.org Members Choice Awards</h2>
<p>The polls are closed and the results are in for the 2004
LinuxQuestions.org Members Choice Awards. I'd like to congratulate
each and every nominee. Winners will be receiving an email in the
next 48 hours or so and will be able to pick their award up at
LinuxWorld. We'll also be sending out small logo's that can be put
up.</p>
<p>Browser of the Year - Firefox (77.12%)</p>
<p>Distribution of the Year - Slackware (19.36%)</p>
<p>LiveCD Distribution of the Year - Knoppix (57.69%)</p>
<p>Database of the Year - MySQL (53.51%)</p>
<p>Desktop Environment of the Year - KDE (58.25%)</p>
<p>Window Manager of the Year - Fluxbox (31.14%)</p>
<p>&gt;&gt; Office Suite of the Year - OpenOffice.org (84.85%)</p>
<p>&gt;&gt; Word Processor of the Year - oowriter (63.75%)</p>
<p>&gt;&gt; Spreadsheet of the Year - oocalc (57.57%)</p>
<p>Audio Multimedia Application of the Year - XMMS (45.83%)</p>
<p>Video Multimedia Application of the Year - mplayer (49.85%)</p>
<p>Security App of the Year - nmap (37.14%)</p>
<p>Hardening App of the Year - SELinux (68.65%)</p>
<p>Editor of the Year - vi/vim (36.37%)</p>
<p>Web Development Editor of the Year - Quanta (50.88%)</p>
<p>IDE of the Year - Kdevelop (37.77%)</p>
<p>Mail Client of the Year - Thunderbird (47.60%)</p>
<p>Open Source Game of the Year - Frozen Bubble (25.52%)</p>
<p>Commercial Game of the Year - UT2004 (38.86%)</p>
<p>Windows on Linux App of the Year - Wine (42.59%)</p>
<p>File Manager of the Year - Konqueror (30.59%)</p>
<p>Messaging App of the Year - Gaim (56.00%)</p>
<p>Graphics App of the Year - GIMP (72.82%)</p>
<p>MTA of the Year - PostFix (45.57%)</p>
<p><a HREF="http://www.linuxquestions.org/questions/t286716.html">http://www.linuxquestions.org/questions/t286716.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org database application: A first look review|outline"></a>
OpenOffice.org database application: A first look review</h2>
<p>&quot;This story will discuss the OpenOffice.org Base and how it
can be used in your business. I'll touch on the similarities (plus
differences) with the OpenOffice.org database program and Access.
I'll continue with a little commentary on migration issues. We'll
finish up by building a basic contact database, a form, a query, and
a report using the wizards. If you are already an OpenOffice.org
believer, you can just skip down to the &quot;build a quick database
application&quot; section to see how it works.&quot;</p>
<p><a HREF="http://www.newsforge.com/article.pl?sid=05/01/25/1758245">http://www.newsforge.com/article.pl?sid=05/01/25/1758245</a></p>
<h2 CLASS="western"><a NAME="0.0.Microsoft Office is too dangerous to leave with users|outline"></a>
Microsoft Office is too dangerous to leave with users</h2>
<p>&quot;Just as eliminating MSN Messenger and replacing MS-Outlook
with Thunderbird (or presently Evolution) improves your corporate
security, so does replacing MS-Office with OpenOffice.org or another
office suite.</p>
<p>Careful planning will avoid rubbing your users up the wrong way.
Any change produces resistance, and by minimising the changes
(converting beloved templates, making conditions under the new suite
better, sending copies home especially with people who only have
MS-Works or MS-Word there etc) you can maximise acceptance.</p>
<p>Make OpenOffice the default or only office suite on new installs.
Use it yourself, for everything; train your technical people up on it
so they become used to using and installing it by default and your
other users will see the &quot;elites&quot; using it.</p>
<p>Since OpenOffice is now available to more than 10% of all desktops
and the file format is about to become a European standard, it is now
more socially reasonable to send office documents in the OASIS format
adopted by OpenOffice.&quot;</p>
<p><a HREF="http://lxer.com/module/newswire/view/31395/">http://lxer.com/module/newswire/view/31395/</a></p>
<h2 CLASS="western"><a NAME="0.0.The Future Is Open: What OpenDocument Is And Why You Should Care|outline"></a>
The Future Is Open: What OpenDocument Is And Why You Should Care</h2>
<p>&quot;Quiz: Complete the sentence,&quot;OpenDocument is ...&quot;</p>
<p>(a) An open, XML-based file format.</p>
<p>(b) An open standard, supported by the OASIS and ISO standards
groups.</p>
<p>(c) The default file format for the upcoming OpenOffice.org 2.0
and KOffice 1.4.</p>
<p>(d) A top prospect for an official format for the European
Commission.</p>
<p>(e) Our best chance to fight vendor lock-in associated with
proprietary formats.</p>
<p>(f) All of the above.</p>
<p>The correct answer is (f) All of the above.&quot;</p>
<p><a HREF="http://www.groklaw.net/article.php?story=20050130002908154">http://www.groklaw.net/article.php?story=20050130002908154</a></p>
<h2 CLASS="western"><a NAME="0.0.Analyst: MS Office Formats Not Open|outline"></a>
Analyst: MS Office Formats Not Open</h2>
<p>&quot;Jupiter Research senior analyst Joe Wilcox has blasted
recent media reports that claim Microsoft has opened up its Office
file formats.&quot;</p>
<p>&quot;Wilcox explained that Eric Kriss, Massachusetts Secretary of
Administration and Finance, simply announced that the Commonwealth
had modified its position on open formats. &quot;Under the change,
Microsoft Office file formats could be considered open by the
Commonwealth, depending on the terms of usage.&quot;&quot;</p>
<p><a HREF="http://www.betanews.com/article/Analyst_MS_Office_Formats_Not_Open/1107211516">http://www.betanews.com/article/Analyst_MS_Office_Formats_Not_Open/1107211516</a></p>
<h2 CLASS="western"><a NAME="0.0.StarOffice 8 goes beta|outline"></a>StarOffice
8 goes beta</h2>
<p>&quot;Sun released a beta version of office productivity
application StarOffice 8 on Thursday, which it says provides improved
compatibility with Microsoft Office files and a new database
front-end tool.</p>
<p>StarOffice already allows users to open and save Microsoft Office
files, but a lack of full interoperability has caused problems for
users migrating from MS Office. Sun claims that StarOffice 8&quot;
significantly improves&quot; the compatability between StarOffice and
MS Office files, according to a PDF available on Sun's Web site.</p>
<p>...</p>
<p>The database front-end tool in StarOffice, StarOffice Base, has
been &quot;totally re-designed&quot; to make it easier for users to
create forms, queries and reports, according to Sun. Stephen O'Grady,
senior analyst at RedMonk, said the database is a useful feature in
StarOffice and is likely to compete with Microsoft Access.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39188480,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39188480,00.htm</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.heise.de/english/newsticker/news/56577">http://www.heise.de/english/newsticker/news/56577</a></p>
<h2 CLASS="western"><a NAME="0.0.New Sun StarOffice 8.0 Beta Looks a Lot Like Microsoft Office 2003|outline"></a>
New Sun StarOffice 8.0 Beta Looks a Lot Like Microsoft Office 2003</h2>
<p>&quot;Chief among these improvements, in my opinion, is its new
look and feel, which is modeled after Office 2003. That's right;
despite some rough edges (the StarOffice 8.0 beta still has the
insane and control-heavy configuration dialog boxes that earlier
releases used), the product does a credible job of emulating the
latest version of  Microsoft's product. And those rough edges are all
that separates this otherwise impressive product from its much more
expensive competition. If Sun can fix the dialog boxes, the product
will be a winner. For the free beta download, visit Sun's Web site.&quot;</p>
<p><a HREF="http://www.windowsitpro.com/windowspaulthurrott/Article/ArticleID/45460/windowspaulthurrott_45460.html">http://www.windowsitpro.com/windowspaulthurrott/Article/ArticleID/45460/windowspaulthurrott_45460.html</a></p>
<h2 CLASS="western"><a NAME="0.0.StarOffice 8 beta set to debut|outline"></a>
StarOffice 8 beta set to debut</h2>
<p>&quot;StarOffice, which shares a code base with the open-source
OpenOffice application suite, will feature enhanced compatibility
with Microsoft Office, including importation of password-protected
documents and a database module much more like Microsoft's own
Access.&quot;</p>
<p><a HREF="http://www.pcauthority.com.au/news.aspx?CIaNID=17846">http://www.pcauthority.com.au/news.aspx?CIaNID=17846</a></p>
<h1 CLASS="western"><a NAME="0.January 2005|outline"></a>January 2005</h1>
<h2 CLASS="western"><a NAME="0.0.OOoCon 2005 - Call for Location|outline"></a>
OOoCon 2005 - Call for Location</h2>
<p>&quot;Dear OpenOffice.org community members,</p>
<p>After Hamburg in 2003 and Berlin in 2004, we are searching for the
perfect location for the OpenOffice.org Conference in 2005.</p>
<p>We are collecting applications from teams who are willing to
organize OOoCon 2005 in locations outside Germany.</p>
<p>Interested teams should send their applications to the mailing
list conference@marketing.openoffice.org in the following format:</p>
<p>Key Question</p>
<ul>
	<li><p>In 200 words or less, answer this question:<br>Why is your
	location and the date you propose the best for the OOoCon 2005?</p>
</ul>
<p>Your application MUST INCLUDE:</p>
<ul>
	<li><p>Location (country, city, conference center/university)</p>
	<li><p>Proposed Date(s)</p>
	<li><p>Team Lead (main contact person)</p>
	<li><p>Team Members (all members should be willing and able to
	commit at least 3 hours per day to planning the conference during
	the last two weeks before OOoCon 2005)</p>
	<li><p>Local events that are taking place in parallel (or right
	before/after)</p>
	<li><p>Special visa or entry requirements, e.g. vaccinations</p>
</ul>
<p>Your application COULD INCLUDE:</p>
<ul>
	<li><p>Large local OpenOffice.org deployments (for user keynotes and
	success stories)</p>
	<li><p>Names of local OpenOffice.org developers (for developer
	sessions)</p>
	<li><p>Names of local OpenOffice.org vendors/partners (potential
	sponsors)</p>
	<li><p>Travel costs (e.g. flight costs from the following cities:
	London, Paris, Rome, Beijing, Sydney, New York, Hamburg, Dublin, San
	Francisco, South Africa, Tokyo)</p>
	<li><p>Accomodation costs (youth hostel, hotel)</p>
</ul>
<p>According to the OOoCon 2004 attendee survey, proposed locations
should meet the following requirements as much as possible (order by
priority):</p>
<ul>
	<li><p>attract the largest number of community contributers</p>
	<li><p>be near enough to allow a large number of Sun's
	OpenOffice.org developers, who are in Hamburg, to attend</p>
	<li><p>low accomodation costs</p>
	<li><p>cheap flight and train tickets</p>
	<li><p>the conference venue is for free</p>
	<li><p>alignment with large IT event (e.g. CeBIT, Systems, Comdex)</p>
	<li><p>strong local OpenOffice.org community</p>
	<li><p>strong sponsor support</p>
</ul>
<p>The deadline for submissions is January 23, 2005. Shortly after
that date we will publish the applications at
<a HREF="http://marketing.openoffice.org/conference/">http://marketing.openoffice.org/conference/</a>
and call for votes.</p>
<p>Information about the last two OpenOffice.org Conferences can be
found at:</p>
<ul>
	<li><p><a HREF="http://marketing.openoffice.org/conference/">http://marketing.openoffice.org/conference/</a></p>
	<li><p><a HREF="http://marketing.openoffice.org/conference/OOoCon2003.html">http://marketing.openoffice.org/conference/OOoCon2003.html</a></p>
</ul>
<p>Thank you and best regards,</p>
<p>The OpenOffice.org Conference Team&quot;</p>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=230">//servlets/ReadMsg?list=announce&amp;msgNo=230</a></p>
<h2 CLASS="western"><a NAME="0.0.OOo version (1.9.71s1) on Mac OSX (X11/Mac OSX 10.3.4)|outline"></a>
OOo version (1.9.71s1) on Mac OSX (X11/Mac OSX 10.3.4)</h2>
<p>After some progress, I'm very pleased to announce I have for the
first time started an OOo version (1.9.71s1 here)  on Mac OSX
(X11/Mac OSX 10.3.4)!</p>
<p>The first try wasn't very beautyfull, because I've made the first
start with only openoffice-core....I have put some snapshots here: 
</p>
<ul>
	<li><p><a HREF="http://eric.bachard.free.fr/mac/MacOSX_m71s1/">http://eric.bachard.free.fr/mac/MacOSX_m71s1/</a></p>
</ul>
<p>But with Florian Heckl tip about the packaging , I finally
obtained a full 1.9.71-1 version on Mac OSX, as .pkg packages!</p>
<p>About the build, the process is complete, excepted for
binfilter***</p>
<p>So, I couldn't resist to put some other screenshots here : 
</p>
<ul>
	<li><p><a HREF="http://eric.bachard.free.fr/mac/MacOSX_m71s1/png/">http://eric.bachard.free.fr/mac/MacOSX_m71s1/png/</a></p>
</ul>
<p>in.png format (following Kazunari Hirano's advice ) more easy to
use for everyone.</p>
<p>Sure, a lot of work is to do before a completely functional
(stable over all) version of OpenOffice.org2.0 can be used on Mac
OSX, but whith this, an enormous progress is done!</p>
<p>This work is not only my work, but the result of help and sharing
of knowledge by/with a lot of people like Kevin Hendricks, Pavel
Janik, Rene Engelhard, Eric Hoch (of course), Torsten (b_osi), Maho
Nakata, Jim Watson, Florian Heckl and all the others. 
</p>
<p>Sorry for the one I forgot the names. And many thank's to Sun for
all.</p>
<p>I sincerily hope this &quot;proof of concept&quot; will concince
that 
</p>
<p>*it is possible !*</p>
<p>So, what about the Next Step  ? (not a play on words :-) ) ...
change the look and feel of OOo, transforming this great software in
a &quot;real&quot; Mac OSX application ? 
</p>
<p>With best regards,</p>
<p>Eric Bachard, for the French OpenOffice.org project 
</p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org 1.9m71 package for FreeBSD 5.3-RELEASE|outline"></a>
OpenOffice.org 1.9m71 package for FreeBSD 5.3-RELEASE</h2>
<p>&quot;Dear all,</p>
<p>OOo 1.9m71 has been ported to FreeBSD 5.3-RELEASE.</p>
<p>English version of binary package is available at:</p>
<p><a HREF="http://osdn.dl.sourceforge.jp/waooo/12904/OOo_1.9m71_FreeBSD53Intel_install_en-US.tbz">http://osdn.dl.sourceforge.jp/waooo/12904/OOo_1.9m71_FreeBSD53Intel_install_en-US.tbz</a></p>
<p>---</p>
<ul>
	<li><p>Our efforts has also been committed to FreeBSD's
	ports.<br>http://www.freebsd.org/cgi/cvsweb.cgi/ports/editors/openoffice-2.0-devel/</p>
	<li><p>Now almost all of the patches has
	#iz.<br>(//issues/show_bug.cgi?id=40187)</p>
	<li><p>Language packs are in preparation and testing.</p>
</ul>
<p>---</p>
<p>Please refer this page for details:</p>
<p><a HREF="http://porting.openoffice.org/freebsd/">http://porting.openoffice.org/freebsd/</a></p>
<p>---</p>
<p>Huge thanks to: Pavel Janik, and Kris Kennaway</p>
<p>Additional contributors. thank you very much for all:</p>
<p>daichi, Eric Bachard, kan, lofi, Martin Hollmichel,</p>
<p>nork, obrien, Sander Vesik, sem, and Stefan Taxhet</p>
<p>All the best,</p>
<p>-- NAKATA, Maho&quot;</p>
<p><a HREF="//servlets/ReadMsg?list=releases&amp;msgNo=8249">//servlets/ReadMsg?list=releases&amp;msgNo=8249</a></p>
<h2 CLASS="western"><a NAME="0.0.Venezuela opts for Linux|outline"></a>
Venezuela opts for Linux</h2>
<p>&quot;The Venezuelan president has decreed that the public
administration will switch over to use open source software over the
next two years</p>
<p>Venezuelan president Hugo Chavez said this week that the country's
public administration will switch to open source software over the
next two years, according to reports.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/business/0,39020645,39182957,00.htm">http://news.zdnet.co.uk/business/0,39020645,39182957,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Enlaces To Install Linux in Chile Schools|outline"></a>
Enlaces To Install Linux in Chile Schools</h2>
<p>&quot;The Edulinux system works on a client-server model, where
PCs in the network work just as terminals and all applications run
from a central server. PCs in the network can operate productivity
tools such as OpenOffice and Internet browser Mozilla, all compatible
with Microsoft Office.&quot;</p>
<p><a HREF="http://www.linuxinsider.com/story/40330001422084057.html">http://www.linuxinsider.com/story/40330001422084057.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Linux gets warm reception in Chile|outline"></a>
Linux gets warm reception in Chile</h2>
<p>&quot;Nearly 10,000 computers in Chilean schools will be turned
into thin clients running Linux and applications such as
OpenOffice.org and Mozilla.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/0,39020330,39183940,00.htm">http://news.zdnet.co.uk/0,39020330,39183940,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.EU's Open Source Observatory - Open Office in Naestved Municipality, Denmark|outline"></a>
EU's Open Source Observatory - Open Office in Naestved Municipality,
Denmark</h2>
<p>&quot;The migration to an open source solution, in a Citrix
environment, didnt encounter any problem. A growing number of pilot
users are already using Open Office and the deadline for migrating
the entire organisation is set to 1 February 2005. Mr Anders Krabbe
Moeller, the IT Coordinator of the city, is confident we will meet
the deadline as the Citrix environment makes technical roll out
relatively easy.&quot;</p>
<p><a HREF="http://europa.eu.int/ida/en/document/3658">http://europa.eu.int/ida/en/document/3658</a></p>
<h2 CLASS="western"><a NAME="0.0.Official Police migration|outline"></a>
Official Police migration</h2>
<p>&quot;French Police (Gendarmerie) has officially announced this
morning on our  list the migration of all the department to OOo (it
was signed yesterday).</p>
<p>That mean, that today they are migrating 35 OOO users (beginning
on March on the 2.0 or the available release of it), 80 000 at the
beginning of the summer and the last part at the end of year. At the
beginning of 2006, the entire police will use OOo  :) 
</p>
<p>There will be 2 communications about this migration : one during
Solutions Linux :</p>
<p><a HREF="http://www.solutionslinux.fr/fr/conferences_detail.php?id_conference=17">http://www.solutionslinux.fr/fr/conferences_detail.php?id_conference=17</a></p>
<p>the second during OOoDay :</p>
<p><a HREF="http://fr.sun.com/societe/agenda/oooday/">http://fr.sun.com/societe/agenda/oooday/</a>&quot;</p>
<p><a HREF="http://native-lang.openoffice.org/servlets/ReadMsg?list=com&amp;msgNo=816">http://native-lang.openoffice.org/servlets/ReadMsg?list=com&amp;msgNo=816</a></p>
<h2 CLASS="western"><a NAME="0.0.French police find open source arresting|outline"></a>
French police find open source arresting</h2>
<p>&quot;Up to 80,000 PCs from the Gendarmerie Nationale could be
involved in one of the largest migrations to OpenOffice.org to date
French police are planning to switch from Microsoft Office to open
source productivity suite OpenOffice.org, a spokesman confirmed on
Wednesday.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39184699,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39184699,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Vienna to softly embrace Linux|outline"></a>
Vienna to softly embrace Linux</h2>
<p>&quot;Of its 16,000 desktop PCs, Vienna has identified 7,500 that
could be migrated to OpenOffice.org, of which 4,800 could migrate to
Linux, according to Gillich. The IT department is offering to install
OpenOffice.org or Linux free of charge on PCs and will charge
departments less money if they run these open source applications
rather than running Microsoft Office or Windows. Users that make the
change will be offered support, but not full training, said Gillich.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39185440,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39185440,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Viennese authority to push ahead with Linux plans|outline"></a>
Viennese authority to push ahead with Linux plans</h2>
<p>&quot;Vienna's Municipal Authority is pushing ahead with plans to
provide Linux as a desktop alternative to Windows for thousands of
employees this year, according to an official.&quot;</p>
<p>&quot;Wienux, as the Vienna Linux system has now been named, is
based on Debian using the Linux operating system kernel version
2.6.9-1, the Firefox Web browser and KDE 3.3 as the graphical user
interface, Lutz said at the Open Source Business Conference 2005 in
Vienna. The system includes OpenOffice version 1.1.3, the open-source
version of Sun's commercial StarOffice suite, originally developed in
Germany.&quot;</p>
<p><a HREF="http://www.techworld.com/opsys/news/index.cfm?NewsID=3013">http://www.techworld.com/opsys/news/index.cfm?NewsID=3013</a></p>
<h2 CLASS="western"><a NAME="0.0.StarOffice 7 Office Suite Momentum Scales New Heights|outline"></a>
StarOffice 7 Office Suite Momentum Scales New Heights</h2>
<p>&quot; Singapore  18 January 2005 - Sun Microsystems, Inc.s
StarOffice 7 Office Suite saw an increase in take up rates between
November and December of 2004 in Singapore. Local sales of StarOffice
7 office suite retail packs and corporate licenses increased by 45%
and 75% respectively. 
</p>
<p>With recent changes to local legislation, software non-compliance
can result in criminal penalties. Infringement of this act happens
through under-licensing or with the use of unauthorised or pirated
software in a business environment. This shift has been a catalyst
for various organizations to rethink their choice of office
productivity software to ensure that they do not contravene the new
rulings. Many have stated that they are looking for more cost
effective alternatives. According to a survey conducted by the
Intellectual Property Office of Singapore, it revealed that 64.8% of
115 respondents suggested the need to lower the financial costs of
software acquisition and ownership in response to adhering to this
law.&quot;</p>
<p><a HREF="http://www.hardwarezone.com/news/view.php?id=484&amp;cid=4">http://www.hardwarezone.com/news/view.php?id=484&amp;cid=4</a></p>
<h2 CLASS="western"><a NAME="0.0.UN project publishes free primer on open source software in education|outline"></a>
UN project publishes free primer on open source software in education</h2>
<p>&quot;Last August, the United Nations-funded UNDP-APDIP
International Open Source Network (IOSN) published the &quot;User
Guide to Using the Linux Desktop&quot;, a guide that introduces
computer neophytes to Internet access and applications such as email
and browsers, managing files and folders, and how to use the
OpenOffice.org suite.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS2077548596.html">http://www.desktoplinux.com/news/NS2077548596.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice Prepares to Grow|outline"></a>
OpenOffice Prepares to Grow</h2>
<p>&quot;One of the most remarkable novelties of version 2.0 will be
the integration of the open source database engine HSQL. This
addition fills a gap that OpenOffice had in comparison to its
commercial competitors, StarOffice and MS Office: the former, based
on the same code as OpenOffice, includes Software AG's database
Adabas; the latter comes with Access.&quot;</p>
<p><a HREF="http://www.tandemnews.com/viewstory.php?storyid=4801">http://www.tandemnews.com/viewstory.php?storyid=4801</a></p>
<h1 CLASS="western"><a NAME="0.December 2004|outline"></a>December
2004</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org Regional Conference North America|outline"></a>
OpenOffice.org Regional Conference North America</h2>
<p>&quot;The inaugural OpenOffice.org Regional Conference North
America (OOo RegiCon North America) will be held 9 February 2005, Del
Mar Fairgrounds in San Diego, CA.</p>
<p>OOo RegiCon is hosted by the Desktop Linux Summit (DLS) and gets
the DLS underway on 9 February at 1200 midday.</p>
<p>Registration for OOo RegiCon is included in the ticket for DLS and
early bird registration closes 7 January 2005.&quot;</p>
<p><a HREF="http://marketing.openoffice.org/conference/regicon/">http://marketing.openoffice.org/conference/regicon/</a></p>
<h2 CLASS="western"><a NAME="0.0.linux.conf.au OpenOffice.org Miniconf|outline"></a>
linux.conf.au OpenOffice.org Miniconf</h2>
<p>The inaugural linux.conf.au OpenOffice.org Mini-conference will be
held on Monday 18th and Tuesday 19th April 2005, two days prior to
the official LCA 2005 conference at the Australian National
University in Canberra, Australia.</p>
<p>LCA 2005 runs from Wednesday 20th to Saturday 23rd April 2005, and
covers all things Linux presented by Linux and open-source software
developers and users. The OpenOffice.org Miniconf is for
presentations more specific to the OpenOffice.org office productivity
suite.</p>
<p>The call for participation is now open. Seminar presentations,
case studies and tutorials ranging from 10 minutes to three hours
(including questions) will be accepted by Friday 4th Feb 2005.</p>
<p><a HREF="/.nz/miniconf/cfp.php">/.nz/miniconf/cfp.php</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org goes Swahili|outline"></a>
OpenOffice.org goes Swahili</h2>
<p>&quot;Developers have released the first version of OpenOffice.org
in the East African language of Swahili, having overcome translation
and infrastructure difficulties.&quot;</p>
<p>...</p>
<p>&quot;The initial release of Jambo OpenOffice, which follows four
months work, is a test version. This initial version will only work
on the Linux operating system, but the final release, which is due in
February 2005, will also work on Windows.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/0,39020330,39179058,00.htm">http://news.zdnet.co.uk/0,39020330,39179058,00.htm</a></p>
<p>Download here:</p>
<p><a HREF="http://www.kilinux.org/">http://www.kilinux.org/</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://news.bbc.co.uk/1/hi/world/africa/4078753.stm">http://news.bbc.co.uk/1/hi/world/africa/4078753.stm</a></p>
<p><a HREF="http://www.theregister.co.uk/2004/12/07/jambo_openoffice_swahili/">http://www.theregister.co.uk/2004/12/07/jambo_openoffice_swahili/</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org 1.1.4 Is Here|outline"></a>
OpenOffice.org 1.1.4 Is Here</h2>
<p>OpenOffice.org 1.1.4 is ready for download.  It is our new stable
release and replaces OpenOffice.org 1.1.3.  OpenOffice.org 1.1.4 is
free for all to use and distribute.  For versions in your language,
check with your native-language project.</p>
<ul>
	<li><p>OpenOffice.org
	1.1.4<br><a HREF="/download/1.1.4/index.html">/download/1.1.4/index.html</a></p>
	<li><p>Native-Language
	Confederation<br><a HREF="/projects/native-lang.html">/projects/native-lang.html</a>
		</p>
</ul>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=227">//servlets/ReadMsg?list=announce&amp;msgNo=227</a></p>
<h2 CLASS="western"><a NAME="0.0.Libertarian Linux goes mainstream|outline"></a>
Libertarian Linux goes mainstream</h2>
<p>&quot;The open-source software used by the city of Northglenn
includes Samba, a file-sharing and printing software; the Firefox and
Mozilla Web browsers; OpenOffice, which matches Microsoft Office; and
Gimp, which is similar to Adobe Photoshop.</p>
<p>These open-source programs can run on top of Windows, which many
Northglenn workers are still reluctant to replace with Linux. &quot;They
tend to be comfortable with what they know,&quot; said Northglenn
information technology manager Jim Reiss. &quot;You can only handle
so much change at one time.&quot;&quot;</p>
<p><a HREF="http://www.denverpost.com/Stories/0,1413,36~33~2577377,00.html">http://www.denverpost.com/Stories/0,1413,36~33~2577377,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Wal-Mart debuts $498 Linux laptop|outline"></a>
Wal-Mart debuts $498 Linux laptop</h2>
<p>&quot;Walmart.com and Linspire on Monday unveiled a Linux-based
laptop priced at $498.</p>
<p>The computer, dubbed Balance, comes loaded with the Linspire
operating system and the OpenOffice.org office suite, the companies
said.&quot;</p>
<p><a HREF="http://news.com.com/Wal-Mart+debuts+498+Linux+laptop/2100-1044_3-5498006.html">http://news.com.com/Wal-Mart+debuts+498+Linux+laptop/2100-1044_3-5498006.html</a></p>
<h2 CLASS="western"><a NAME="0.0.IT for free|outline"></a>IT for free</h2>
<p>&quot;Beaumont Hospital in Dublin already had a mix of 22 Linux
servers and 14 Windows servers when it began deploying StarOffice
desktop applications software and SuSE Mail to its 1,000 desktops in
2002. Although the presentation module lacked some of PowerPoint's
finer features, it found functionality was &quot;fully adequate for
most users&quot;. Interoperability was &quot;not seen as a major
issue for most business purposes&quot;.&quot;</p>
<p><a HREF="http://www.infoconomy.com/pages/strategy-column/group100524.adp">http://www.infoconomy.com/pages/strategy-column/group100524.adp</a></p>
<h2 CLASS="western"><a NAME="0.0.Dutch MPs fume over &pound;100m Microsoft contract|outline"></a>
Dutch MPs fume over &pound;100m Microsoft contract</h2>
<p>&quot;However, this is thought to be a move to open-source
software, encouraged by Vendrik's motion. A survey undertaken last
year by the Maastricht Economic Research Institute on Innovation and
Technology (MERIT) suggested that open source is making gains in the
Dutch public sector, and awareness of it was increasing. The survey
was however commissioned by the OSOSS (Open Standards and Open Source
Software).</p>
<p>And the town of Haarlem has reportedly already moved over 2,000
desktops over to OpenOffice in order to save on its 500,000 euro
software licence costs. Reports suggest that training and migration
cost Haarlem burghers 50,000 euros (about &pound;35,000),
representing a saving of about 90 per cent over an upgrade to
Microsoft Office 2000.&quot;</p>
<p><a HREF="http://www.techworld.com/opsys/news/index.cfm?NewsID=2801">http://www.techworld.com/opsys/news/index.cfm?NewsID=2801</a></p>
<h2 CLASS="western"><a NAME="0.0.Dutch govt ends exclusive MS upgrade talks|outline"></a>
Dutch govt ends exclusive MS upgrade talks</h2>
<p>&quot;The Dutch government has abandoned its negotiations with
Microsoft over an ambitious plan to upgrade more than 260,000
workstations and servers.&quot;</p>
<p><a HREF="http://www.theregister.co.uk/2004/12/23/ms_holland_talks_off/">http://www.theregister.co.uk/2004/12/23/ms_holland_talks_off/</a></p>
<h2 CLASS="western"><a NAME="0.0.Africa Proving To Be Next Frontier for Free and Open Software|outline"></a>
Africa Proving To Be Next Frontier for Free and Open Software</h2>
<p>&quot;Thiessen said that each school in the Shuttleworth program
arranges a monthly open day where educators explain open-source
software to the community, showcase certain packages such as
openoffice.org, and provide copies of software for their use and
distribution.&quot;</p>
<p><a HREF="http://www.technewsworld.com/story/Africa-Proving-To-Be-Next-Frontier-for-Free-and-Open-Software-38727.html">http://www.technewsworld.com/story/Africa-Proving-To-Be-Next-Frontier-for-Free-and-Open-Software-38727.html</a></p>
<p><br><br>
</p>
<h2 CLASS="western"><a NAME="0.0.DVA shops for open source Office|outline"></a>
DVA shops for open source Office</h2>
<p>&quot;CONTINUING its recent tradition of being a pioneer of new
technology within the Federal Government, the Department of Veterans'
Affairs is to investigate open source alternatives to the Microsoft
Office productivity suite used within the department.&quot;</p>
<p>...</p>
<p>&quot;Potential suppliers would need to indicate how they would
supply such complex functionality where it was specifically required,
such as in spreadsheet, the Department says. Other issues to be
addressed would include document compatibility, archival and
management, changeover and integration options and compatibility with
existing anti-virus and security tools. Potential suppliers would
also need to detail the system resource requirements of any package
being offered, using either Office 97 or Office 2003 as benchmarks.&quot;</p>
<p><a HREF="http://www.computerworld.com/developmenttopics/development/webservices/story/0,10801,97898,00.html">http://www.computerworld.com/developmenttopics/development/webservices/story/0,10801,97898,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.De Bortoli Wines gets a taste of Linux|outline"></a>
De Bortoli Wines gets a taste of Linux</h2>
<p>&quot;&quot;You have to invest in people,&quot; he said. &quot;For
example, our IT staff have undertaken the Red Hat Linux essentials
training, and we are in the process of ongoing OpenOffice.org
training for the organisation.&quot;</p>
<p>[...]</p>
<p>De Bortoli has 350 staff overall, which expands to about 450
during grape harvesting. Its IT department is based in Bilbul and has
five full-time staff and several key external consultants.&quot;</p>
<p><a HREF="http://www.linuxworld.com.au/index.php/id;1058410056;fp;4;fpid;2">http://www.linuxworld.com.au/index.php/id;1058410056;fp;4;fpid;2</a></p>
<h2 CLASS="western"><a NAME="0.0.NSW exam board tests Open Office|outline"></a>
NSW exam board tests Open Office</h2>
<p>&quot;NSW school curriculum administrator the Office of the Board
of Studies has started trialling the OpenOffice.org office suite amid
its strategy to move more applications - including examinations - to
a Web-based architecture.&quot;</p>
<p><a HREF="http://www.computerworld.com.au/index.php/id;907826517;fp;16;fpid;0">http://www.computerworld.com.au/index.php/id;907826517;fp;16;fpid;0</a></p>
<h2 CLASS="western"><a NAME="0.0.Linux Makes Headway in Primary Education|outline"></a>
Linux Makes Headway in Primary Education</h2>
<p>&quot;&quot;Linux is only now beginning to be ready for use in a
general purpose  lab. At the rate things like OpenOffice and Gnome
and KDE are progressing, it will be fully ready for the general
purpose lab within a year,&quot; teacher and project coordinator Jeff
Elkner wrote in an assessment of his school's experience.&quot;</p>
<p><a HREF="http://www.technewsworld.com/story/Linux-Makes-Headway-in-Primary-Education-38733.html">http://www.technewsworld.com/story/Linux-Makes-Headway-in-Primary-Education-38733.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Roundtable: City of Haarlem and OpenOffice.org|outline"></a>
Roundtable: City of Haarlem and OpenOffice.org</h2>
<p>&quot;Early in November it was announced that the municipal
offices of the Dutch city of Haarlem, the capital of North Holland,
had migrated to OpenOffice.org. Nederlands Language Project Lead
Simon Brouwer and Co-Lead Arthur Buijs met with the persons
responsible on 24 November 2004 and discussed the move, motives for
it, and effects. The following article is extracted from notes taken
at that meeting. Questions were agreed upon by Louis Suarez-Potts,
Simon Brouwer, and Arthur Buijs.&quot;</p>
<p><br><br>
</p>
<p><a HREF="//editorial/roundtable_haarlem.html">//editorial/roundtable_haarlem.html</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice 2.0 preview released|outline"></a>
OpenOffice 2.0 preview released</h2>
<p>&quot;THE SUN-SPONSORED OpenOffice.org project based on open
sourced StarOffice code has released a preview of the upcoming
OpenOffice 2.0 product. This version touts better MS-Office loading
and parsing, strict XML compliant output, a new database program that
mimics Microsoft's Access, and much more. It's available for 32-bit
Windows, Linux (x86), Sun Solaris x86, and the traditional Solaris
for Sparc. We used this opportunity to take this pre-release &quot;version
1.9.65&quot;, which will end up being 2.0, for a quick spin.&quot;</p>
<p><a HREF="http://www.theinquirer.net/?article=20293">http://www.theinquirer.net/?article=20293</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice 2.0 Nears Beta Testing|outline"></a>
OpenOffice 2.0 Nears Beta Testing</h2>
<p>&quot;OpenOffice.org 2.0, the open-source office suite sponsored
by Sun Microsystems Inc., is getting closer to reality.</p>
<p>The latest prebeta edition, OpenOffice.org Snapshot Build 1.9.m65
(680_m65), is feature-complete and reveals an office suite that
includes a personal DBMS (database management system) and improved
Microsoft Office file compatibility.&quot;</p>
<p><a HREF="http://www.eweek.com/article2/0,1759,1744354,00.asp">http://www.eweek.com/article2/0,1759,1744354,00.asp</a></p>
<h1 CLASS="western"><a NAME="0.November 2004|outline"></a>November
2004</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org 1.1.3 with KDE integration|outline"></a>
OpenOffice.org 1.1.3 with KDE integration</h2>
<p>&quot;OpenOffice.org 1.1.3 with KDE integration is now available
for download. It also features a lot of other improvements over the
stock OOo (including the GNOME integration bits; but do not be
afraid, it does not link against Gtk+ in KDE, and vice versa),
because it is built from the ooo-build codebase.&quot;</p>
<p><a HREF="http://dot.kde.org/1101482981/">http://dot.kde.org/1101482981/</a></p>
<h2 CLASS="western"><a NAME="0.0.Third-Annual Desktop Linux Summit Expands to Include Mozilla and OpenOffice.org Focus|outline"></a>
Third-Annual Desktop Linux Summit Expands to Include Mozilla and
OpenOffice.org Focus</h2>
<p>&quot;SAN DIEGO, Nov. 4 /PRNewswire/ -- Now in its third year, the
annual Desktop Linux Summit has added an extra day, expanding its
focus to include discussions of open source leaders Mozilla and
OpenOffice.org. A two-day event in prior years, the Summit is now
three days and will be held February 9-11, 2005 at the Del Mar
Fairgrounds in San Diego.&quot;</p>
<p><a HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=109&amp;STORY=/www/story/11-04-2004/0002355559&amp;EDATE">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=109&amp;STORY=/www/story/11-04-2004/0002355559&amp;EDATE</a>=</p>
<p>For more information see</p>
<p><a HREF="http://www.desktoplinuxsummit.org/">http://www.desktoplinuxsummit.org</a></p>
<h2 CLASS="western"><a NAME="0.0.New web site for the Czech and Slovak OpenOffice.org users|outline"></a>
New web site for the Czech and Slovak OpenOffice.org users</h2>
<p>&quot;Since yesterday we just have started the new OpenOffice.cz
web site for the Czech and Slovak OpenOffice.org users. Our goal is
to spread OpenOffice.org in our country and help users with their
problems. We are going to support SME sector as well.</p>
<p>Robert Vojta - OpenOffice.cz manager&quot;</p>
<p><a HREF="http://www.OpenOffice.cz/">http://www.OpenOffice.cz/</a></p>
<h2 CLASS="western"><a NAME="0.0.Basque localisation of OpenOffice.org 1.1.3|outline"></a>
Basque localisation of OpenOffice.org 1.1.3</h2>
<p>&quot;Finally OOo 1.1.3 Basque builds are in the net, as you can
see in those</p>
<p>links:</p>
<p>(en) http://eu.openoffice.org/softwarea/about_downloads.html</p>
<p>(eu) http://eu.openoffice.org/softwarea/jeitsi_buruz.html</p>
<p>and of course in 
</p>
<p>http://ooo.euskalgnu.org&quot;</p>
<p>[on behalf of the Basque Native-Lang Project and the Basque
Localization team]</p>
<h2 CLASS="western"><a NAME="0.0.Announcing the OpenOffice.org Esperanto Native Language Project|outline"></a>
Announcing the OpenOffice.org Esperanto Native Language Project</h2>
<p>&quot;We are proud to announce the launch of the Esperanto Native
Language Project of OpenOffice.org. The project's website is
http://eo.openoffice.org/index.html and contains information in
Esperanto about the project and about OpenOffice.org in general.
Additionally we have forums and email lists available for users and
interested parties.</p>
<p>We are targeting a complete Esperanto build a few months following
the expected arrival of OpenOffice.org 2.0 in the Spring of 2005.</p>
<p>Esperanto speakers and organizations are encouraged to visit the
website and help us grow the Esperanto OpenOffice.org Community!</p>
<p>Respectfully,</p>
<p>Joey STANFORD, Tim MORLEY, and rest of the Esperanto Translation
Team.&quot;</p>
<p><a HREF="http://eo.openoffice.org/index.html">http://eo.openoffice.org/index.html</a></p>
<h2 CLASS="western"><a NAME="0.0.New User Guide|outline"></a>New User
Guide</h2>
<p>A new User Guide, written in plain language, is available from the
Documentation Project, with a troubleshooting section for common
problems.</p>
<p><a HREF="http://documentation.openoffice.org/manuals/">http://documentation.openoffice.org/manuals/</a></p>
<h2 CLASS="western"><a NAME="0.0.Bristol City Council ditches MS for StarOffice|outline"></a>
Bristol City Council ditches MS for StarOffice</h2>
<p>&quot;Bristol City Council expects to save &pound;1.4m over the
next five years by switching to StarOffice desktop applications.</p>
<p>The council sees the move as part of an ongoing drive to meet the
government's requirements for improved efficiency in the public
sector as set out in the Gershon Review.</p>
<p>The council plans over 5,000 users from the authority's existing
mixture of Corel Word Perfect, Lotus 1-2-3 and Microsoft Office
software to Sun Microsystems' integrated StarOffice 7 suite.&quot;</p>
<p><a HREF="http://www.computerweekly.com/articles/article.asp?liArticleID=135099&amp;liArticleTypeID=1&amp;liCategoryID=1&amp;liChannelID=1&amp;liFlavourID=1&amp;sSearch=&amp;nPage=1">http://www.computerweekly.com/articles/article.asp?liArticleID=135099&amp;liArticleTypeID=1&amp;liCategoryID=1&amp;liChannelID=1&amp;liFlavourID=1&amp;sSearch=&amp;nPage=1</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39171155,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39171155,00.htm</a></p>
<p><a HREF="http://www.theinquirer.net/?article=19285">http://www.theinquirer.net/?article=19285</a></p>
<p><a HREF="http://www.cbronline.com/article_news.asp?guid=5AD88DF3-B288-431F-98C5-B4DC34B48990">http://www.cbronline.com/article_news.asp?guid=5AD88DF3-B288-431F-98C5-B4DC34B48990</a></p>
<h2 CLASS="western"><a NAME="0.0.UK tech specialist school pioneers open source switch|outline"></a><a NAME="0.0.UK tech specialist school pioneers open source switch|outline"></a>
UK tech specialist school pioneers open source switch</h2>
<p>&quot;Using OSS packages such as OpenOffice, MySQL and The Gimp
had advantages over using proprietary software because the school
didn't need to worry about licensing issues connected with pupils
running the software at home. Support for Windows-based legacy
software that had no direct OSS equivalent was also needed.&quot;</p>
<p><a HREF="http://www.theregister.co.uk/2004/10/19/oss_school_switch/">http://www.theregister.co.uk/2004/10/19/oss_school_switch/</a></p>
<p>Case study:</p>
<p><a HREF="http://www.theregister.co.uk/Design/page/linux_case_study_orwell_high_school.html">http://www.theregister.co.uk/Design/page/linux_case_study_orwell_high_school.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Linux-based Scottish force continues its commitment to open-source|outline"></a>
Linux-based Scottish force continues its commitment to open-source</h2>
<p>&quot;Central Scotland police is already a big open-source user
with Linux servers, Linux-based email clients and Sun's StarOffice
software. Dick said desktop Linux is currently also being evaluated
but is still at an &quot;early stage&quot;.&quot;</p>
<p><a HREF="http://software.silicon.com/os/0,39024651,39125661,00.htm">http://software.silicon.com/os/0,39024651,39125661,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.100,000 desktops to OpenOffice|outline"></a>
100,000 desktops to OpenOffice</h2>
<p>&quot;Among other speakers, Christian Hardy from the French
ministry of  finance presented the large migration of over 100,000
desktops to OpenOffice, the free software alternative to Microsoft
Office, across the national French Administration.&quot;</p>
<p><a HREF="http://trends.newsforge.com/trends/04/11/19/148236.shtml?tid=138">http://trends.newsforge.com/trends/04/11/19/148236.shtml?tid=138</a></p>
<h2 CLASS="western"><a NAME="0.0.OOo distributed by El Mundo|outline"></a>
OOo distributed by El Mundo</h2>
<p>&quot;The Spanish magazine, El Mundo, will be distributing 11 CDs
with a mixture of open/closed, free/non-free software.  CD2 and CD9
include OOo, the former as part of Guadalinux, the latter standalone
but with a tutorial. The set is being marketed as the definitive
collection of the best programs in the world 2005.&quot;</p>
<p><a HREF="http://www.elmundo.es/promociones/mpm/">http://www.elmundo.es/promociones/mpm/</a></p>
<h2 CLASS="western"><a NAME="0.0.Africa Becoming Vast Frontier for Free and Open Software|outline"></a>
Africa Becoming Vast Frontier for Free and Open Software</h2>
<p>&quot;Thiessen said that each school in the Shuttleworth program
arranges a monthly open day where educators explain open-source
software to the community, showcase certain packages such as
openoffice.org, and provide copies of software for their use and
distribution.&quot;</p>
<p><a HREF="http://www.linuxinsider.com/story/Africa-Becoming-Vast-Frontier-for-Free-and-Open-Software-38025.html">http://www.linuxinsider.com/story/Africa-Becoming-Vast-Frontier-for-Free-and-Open-Software-38025.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Singapore Dumps Microsoft, Goes Open Source|outline"></a>
Singapore Dumps Microsoft, Goes Open Source</h2>
<p>&quot;The Defense Ministry of Singapore, the latest government
agency to spurn Microsoft for open source, said this week that it's
turning to the OpenOffice application suite rather than updating
Microsoft Office.&quot;</p>
<p><a HREF="http://www.techweb.com/wire/ebiz/50900190">http://www.techweb.com/wire/ebiz/50900190</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://news.zdnet.co.uk/software/windows/0,39020396,39171012,00.htm">http://news.zdnet.co.uk/software/windows/0,39020396,39171012,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice is voted Best Value-for-Money Software by the most popular computer newspaper in Singapore|outline"></a>
OpenOffice is voted Best Value-for-Money Software by the most popular
computer newspaper in Singapore</h2>
<p>&quot;Why it's hot: It's free but it lets you work as if you are
using Microsoft Office, which costs hundreds of dollars.</p>
<p>Downloadable from www.openoffice.org, the software lets you type
your reports, create presentation slides and chart out your accounts.</p>
<p>Though the formatting in some files may look out of sorts when
opened in Microsoft Office, most of the time, simply-laid-out
documents work fine.</p>
<p>Open Office gets our vote for being the best value-for-money
product - actually best value for no money.&quot;</p>
<p>(Online registration required)</p>
<p><a HREF="http://straitstimes.asia1.com.sg/sub/digital_life/story/0,5597,284079,00.html">http://straitstimes.asia1.com.sg/sub/digital_life/story/0,5597,284079,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Japan gives OK to Sun desktop suite|outline"></a>
Japan gives OK to Sun desktop suite</h2>
<p>&quot;Japan's Ministry of Economy, Trade and Industry has endorsed
Sun's Java Desktop System as an approved product for future bids, a
Sun representative said Wednesday. The ministry is undergoing an
evaluation of its current desktop software but has not yet committed
to deploying JDS, the representative said.</p>
<p>JDS is a suite of open-source office desktop programs that
includes the Linux operating system and the company's open-source
StarOffice suite. Sun also sells versions of JDS for its Solaris
operating system, and individual components, such as the browser and
StarOffice, also run on Windows.&quot;</p>
<p><a HREF="http://news.com.com/Japan+gives+OK+to+Sun+desktop+suite/2100-7344_3-5446812.html">http://news.com.com/Japan+gives+OK+to+Sun+desktop+suite/2100-7344_3-5446812.html</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://biz.yahoo.com/prnews/041110/sfw092_1.html">http://biz.yahoo.com/prnews/041110/sfw092_1.html</a></p>
<p><a HREF="http://software.silicon.com/applications/0,39024653,39125837,00.htm">http://software.silicon.com/applications/0,39024653,39125837,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.ITWeb : Microsoft price increase opens door for Open Office|outline"></a>
ITWeb : Microsoft price increase opens door for Open Office</h2>
<p>&quot;The price hike in Microsoft Office Suite may push small and
medium enterprises (SMEs) into the open source camp as the business
software equivalent, Open Office, becomes more cost-effective, say
market pundits.</p>
<p>SMEs will shoulder the burden of Microsoft's price hike for its
Office Suite software that came into effect from 1 November.&quot;</p>
<p><a HREF="http://www.itweb.co.za/sections/software/2004/0411031145.asp?S=Business%20Applications&amp;A=BAP&amp;O=FRGN">http://www.itweb.co.za/sections/software/2004/0411031145.asp?S=Business%20Applications&amp;A=BAP&amp;O=FRGN</a></p>
<h2 CLASS="western"><a NAME="0.0.Sun Desktop goes back to school|outline"></a>
Sun Desktop goes back to school</h2>
<p>&quot;JDS, which features the open source StarOffice desktop
productivity suite, will be tested for issues including security,
integration, printer compatibility and accessibility of the interface
by five institutions serving 2,000 students. JDS made it onto open
source verification program after beating 10 rival desktop packages.&quot;</p>
<p><a HREF="http://www.cbronline.com/article_news.asp?guid=47CB1AFF-A63C-431E-BFE1-0A33158AE577">http://www.cbronline.com/article_news.asp?guid=47CB1AFF-A63C-431E-BFE1-0A33158AE577</a></p>
<h2 CLASS="western"><a NAME="0.0.Munich's Linux plans attract international attention|outline"></a>
Munich's Linux plans attract international attention</h2>
<p>&quot;The planned migration of 14,000 desktops in the City of
Munich to Linux has attracted attention from as far away as Japan and
Australia - and so far all they've switched over is the browser&quot;</p>
<p>...</p>
<p>&quot;The next step for LiMux is the migration from Microsoft
Office 97 and 2000 to OpenOffice, and from Windows NT 4.0 to Linux,
which is due to start in the New Year. Hofmann hopes that by the
middle of 2005 the first department will be running OpenOffice, in
parallel with Microsoft Office. The first departments to be migrated
will be those whose users are willing and which have less issues with
bespoke applications and macros, according to Hoffman.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39171380,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39171380,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.CollabNet Helps OpenOffice.org Surpass 170,000 Registered Members|outline"></a>
CollabNet Helps OpenOffice.org Surpass 170,000 Registered Members</h2>
<p>&quot;BRISBANE, CA -- (MARKET WIRE) -- 10/27/2004 -- CollabNet,
the leading provider of on demand distributed software development
solutions and host to the OpenOffice.org community, today announced
it has helped OpenOffice.org surpass its 170,000 registered member
mark, further solidifying its place as the world's most successful
corporate-initiated and sponsored open-source project.&quot;</p>
<p><a HREF="http://www.marketwire.com/mw/release_html_b1?release_id=75016">http://www.marketwire.com/mw/release_html_b1?release_id=75016</a></p>
<h2 CLASS="western"><a NAME="0.0.EC announces Open Standards Definition|outline"></a>
EC announces Open Standards Definition</h2>
<p>&quot;Among other speakers, Christian Hardy from the French
ministry of finance presented the large migration of over 100,000
desktops to OpenOffice, the free software alternative to Microsoft
Office, across the national French Administration.&quot;</p>
<p><a HREF="http://trends.newsforge.com/trends/04/11/19/148236.shtml?tid=138">http://trends.newsforge.com/trends/04/11/19/148236.shtml?tid=138</a></p>
<h2 CLASS="western"><a NAME="0.0.PC Pro: Product Reviews: Labs: Office suites: OpenOffice 1.1.2|outline"></a>
PC Pro: Product Reviews: Labs: Office suites: OpenOffice 1.1.2</h2>
<p>&quot;RATING: ******</p>
<p>[...]</p>
<p>As we've pointed out, there are a few shortcomings, but with a
dedicated following in the development community it won't be long
before they're ironed out. In the meantime, the fact it's a free
download is enough for us to brush them to one side and fully endorse
OpenOffice over and above Microsoft Office 2003 for both home and
corporate use (see Sun StarOffice 7).&quot;</p>
<p><a HREF="http://www.pcpro.co.uk/labs/64884/openoffice-112.html">http://www.pcpro.co.uk/labs/64884/openoffice-112.html</a></p>
<h2 CLASS="western"><a NAME="0.0.KDE and the Linux Journal 2004 Readers' Choice Awards|outline"></a>
KDE and the Linux Journal 2004 Readers' Choice Awards</h2>
<p>&quot;There was also some bad news for the KOffice team which
didn't make the top three in &quot;Favorite Office Program&quot; or a
mention in the editorial on the category. As you might guess,
OpenOffice.org came in a clear first and miles ahead of the
competition. AbiWord took second place followed by StarOffice.&quot;</p>
<p><a HREF="http://dot.kde.org/1099004959/">http://dot.kde.org/1099004959/</a></p>
<h2 CLASS="western"><a NAME="0.0.European commission defines open standards|outline"></a>
European commission defines open standards</h2>
<p>&quot;At the Open Standards and Libre Software in Government
conference, several EU governments announced national open source and
free software efforts, urging governments to adopt open source
strategies for increased efficiency, interoperability and reduced
costs. During the Dutch sponsored conference, the European Commission
formally announced its definition of Open Standards.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS3877409046.html">http://www.desktoplinux.com/news/NS3877409046.html</a></p>
<p><a HREF="http://www.linuxinsider.com/story/EU-Governments-Gather-To-Promote-Open-Source-38324.html">http://www.linuxinsider.com/story/EU-Governments-Gather-To-Promote-Open-Source-38324.html</a></p>
<h2 CLASS="western"><a NAME="0.0.IBM, Microsoft, and Sun Respond to TAC Recommendation on Open Document Exchange Format|outline"></a>
IBM, Microsoft, and Sun Respond to TAC Recommendation on Open
Document Exchange Format</h2>
<p>&quot;According to IDA's summary, Sun Microsystems, &quot;the
provider of  Open Office who has been instrumental in the process of
standardising the Open Office XML document format in OASIS
(Organization for the Advancement of Structured Information
Standards), welcomed the recommendations and said it would encourage
the adoption of the OASIS format as an ISO standard. It also
announced that it would shortly release filters providing import and
export capabilities to other formats, making them also available for
other software vendors.&quot;&quot;</p>
<p><a HREF="http://www.xmlmania.com/news_article_1696-IBM-Microsoft-and-Sun-Respond-to-TAC-Recommendation-on-Open-Document-Exchange-Format.php">http://www.xmlmania.com/news_article_1696-IBM-Microsoft-and-Sun-Respond-to-TAC-Recommendation-on-Open-Document-Exchange-Format.php</a></p>
<h2 CLASS="western"><a NAME="0.0.European Union may soon endorse the Open Office file format|outline"></a>
European Union may soon endorse the Open Office file format</h2>
<p>&quot;Bottomline: Sun scored a nice one today, thanks to some very
talented and discrete people inside it, and thanks to the Valoris
consulting group. IBM joins the ball. Heh, it's never too late... And
what about MS? well, after they've acknowledged that their file
formats were &quot;a bit proprietary&quot;, they're now left alone in
the morning sun.&quot;</p>
<p><a HREF="http://lxer.com/module/newswire/view/26419/">http://lxer.com/module/newswire/view/26419/</a></p>
<h2 CLASS="western"><a NAME="0.0.EU - Major software vendors ready to implement policy recommendations|outline"></a>
EU - Major software vendors ready to implement policy recommendations</h2>
<p>&quot;SUN, the provider of Open Office who has been instrumental
in the process of standardising the Open Office XML document format
in OASIS (Organization for the Advancement of Structured Information
Standards), welcomed the recommendations and said it would encourage
the adoption of the OASIS format as an ISO standard. It also
announced that it would shortly release filters providing import and
export capabilities to other formats, making them also available for
other software vendors.</p>
<p>IBM responded to the recommendation stating that they have
informed OASIS of their intention to join the relevant technical
committee and that they already have products which comply with the
existing OASIS draft specification on Open Office XML format.&quot;</p>
<p><a HREF="http://europa.eu.int/ida/en/document/3463">http://europa.eu.int/ida/en/document/3463</a></p>
<p>Additional commentary:</p>
<p><a HREF="http://blogs.sun.com/roller/page/webmink/20041115#ignoring_the_elephant">http://blogs.sun.com/roller/page/webmink/20041115#ignoring_the_elephant</a></p>
<p><a HREF="http://blogs.sun.com/roller/page/dancer/20041115#what_has_ibm_to_do">http://blogs.sun.com/roller/page/dancer/20041115#what_has_ibm_to_do</a></p>
<p><a HREF="http://www.desktoplinux.com/news/NS7246039020.html">http://www.desktoplinux.com/news/NS7246039020.html</a></p>
<h2 CLASS="western"><a NAME="0.0.MS Office 12's Competition: Its Older Versions and Linux Suites|outline"></a>
MS Office 12's Competition: Its Older Versions and Linux Suites</h2>
<p>&quot;For example, he pointed to an ad hoc survey taken at a
recent Gartner conference, where about 15 percent of enterprise
customers reported using Office 97, even though the software has been
orphaned by Microsoft and suffers from a growing list of security
issues.</p>
<p>&quot;To Microsoft's dismay, Office 97 didn't stop working when
they stopped supporting it,&quot; Silver said. &quot;Since Office
2000, companies have moved very slowly to upgrade, although Office
2003 has an appeal for mobile workers.&quot;</p>
<p>According to Silver, about 45 percent of larger enterprises are
still using Office 2000, with less than 10 percent using the current
Office 2003. He expects a greater shift to Office 2003 in 2005.</p>
<p>Silver said more interest in StarOffice and OpenOffice could be
sparked when customers now running Office 2000 decide to upgrade. He
also suggested that enterprises will be more interested when their
existing Software Assurance contracts expire.</p>
<p>&quot;In the Longhorn time frame, when older versions look really
old, that will be an opportunity for Sun or OpenOffice.org to pick up
some market share,&quot; he said. &quot;</p>
<p><a HREF="http://www.eweek.com/article2/0,1759,1711271,00.asp">http://www.eweek.com/article2/0,1759,1711271,00.asp</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.microsoft-watch.com/article2/0,1995,1711072,00.asp">http://www.microsoft-watch.com/article2/0,1995,1711072,00.asp</a></p>
<h2 CLASS="western"><a NAME="0.0.Germans seek savings through Linux|outline"></a>
Germans seek savings through Linux</h2>
<p>&quot;By comparison, Heinz Huber Internationale Spedition GmbH &amp;
Co. is pursuing a less pervasive open source approach, although the
company says that it, too, is saving plenty of money. The 38-person
logistics company has deployed Linux in its servers and installed
open source applications, including StarOffice, on Windows-based
clients.&quot;</p>
<p><a HREF="http://www.nwfusion.com/news/2004/1027linux-ger.html">http://www.nwfusion.com/news/2004/1027linux-ger.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Government starts to embrace open-source|outline"></a>
Government starts to embrace open-source</h2>
<p>&quot;One long-standing critic of Microsoft, Eddie Bleasdale, of
consultancy Netproject, welcomed the announcement. &quot;I am glad
that government is jumping on the bandwagon.&quot; But he said making
decisions on the total cost of onwership is &quot;fraught with
difficulty&quot;. &quot;Coming up with a generic cost model is not
meaningful.&quot; Decisions, he said, should be made on &quot;what is
best for your long-term future and this usually means you have
control of your IT infrastructure and are no longer dependent on your
supplier.&quot; &quot;</p>
<p><a HREF="http://politics.guardian.co.uk/egovernment/story/0,12767,1337817,00.html">http://politics.guardian.co.uk/egovernment/story/0,12767,1337817,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.UK government report gives nod to open source|outline"></a>
UK government report gives nod to open source</h2>
<p>&quot;Following a year-long pilot program to study the viability
of using Open Source Software across central government departments
and the public sector, the Office of Government Commerce (OGC) today
published its report. The group's findings urged governments to
consider open source when implementing new systems or refreshing
hardware.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS5013620917.html">http://www.desktoplinux.com/news/NS5013620917.html</a></p>
<p>Additional reporting:</p>
<p><a HREF="http://www.theregister.co.uk/2004/10/28/ogc_oss_pilot_report/">http://www.theregister.co.uk/2004/10/28/ogc_oss_pilot_report/</a></p>
<h1 CLASS="western"><a NAME="0.October 2004|outline"></a>October 2004</h1>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org 1.1.3 announced|outline"></a>
OpenOffice.org 1.1.3 announced</h2>
<p>&quot;OpenOffice.org 1.1.3 is ready for immediate download.  It is
our new stable release and replaces OpenOffice.org 1.1.2. 
OpenOffice.org 1.1.3 is free to use and distribute by all.  At the
moment, some languages, including English, are ready. As the month
progresses, more languages will be available.  Check with your
Native-Language project for updates.</p>
<ul>
	<li><p>OpenOffice.org
	1.1.3<br>/download/1.1.3/index.html</p>
	<li><p>Native-Language
	Confederation<br>/projects/native-lang.html</p>
</ul>
<p>The build includes many bug fixes but no new features.   Please
read our release notes to learn more. 
</p>
<ul>
	<li><p>Release Notes to OpenOffice.org
	1.1.3<br>/download/1.1.3/release_notes_1.1.3.html</p>
</ul>
<p>OpenOffice.org 1.1.3 is ready for use by businesses, enterprises,
governments and individuals, and offers near-perfect compatibility
with legacy proprietary office suites such as Microsoft Office. 
</p>
<p>It represents one of the last stages before our next major
evolution, to OpenOffice.org 2.0.  
</p>
<p>OpenOffice.org 2.0 will be ready for general use in March 2005. 
Early versions--pre-Alpha versions--are ready for download now.  They
are not meant for daily use but are meant to give a taste of things
to come.</p>
<p>To download the early developer version of OpenOffice.org 2.0,
visit our 680 page.</p>
<ul>
	<li><p>680<br>/download/680/”</p>
</ul>
<p><a HREF="//servlets/ReadMsg?list=announce&amp;msgNo=219">//servlets/ReadMsg?list=announce&amp;msgNo=219</a></p>
<h2 CLASS="western"><a NAME="0.0.Bulgarian Native-Lang Project Announced|outline"></a>
Bulgarian Native-Lang Project Announced</h2>
<p>&quot;OpenOffice.org is proud to announce the opening of the
Bulgarian Native-Lang project, led by Mr Hristo Hristov. The Bugarian
project will address the growing needs of the Bulgarian users of
OpenOffice.org and grow its community, after having completed the
localization in Bulgarian.</p>
<p>The Bulgarian Native-Lang Project (http://bg.openoffice.org) is
also the project that has been the fastest to be set up (no more than
two days), up and running.</p>
<p>Building the Bulgarian community also marks an important milestone
for OpenOffice.org in the Balkanese area. 
</p>
<p>We wish the greatest success to Mr Hristov and his team.</p>
<p>Charles-H. Schulz,                                            
</p>
<p>Lead of the Native-Lang 
</p>
<p>Confederation,</p>
<p>OpenOffice.org&quot;</p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org development boosted by Arab and Israeli collaboration|outline"></a>
OpenOffice.org development boosted by Arab and Israeli collaboration</h2>
<p>&quot;The Hebrew and Arabic OpenOffice.org teams have cooperated
on local versions of the open-source productivity application, which
celebrated its fourth birthday on Wednesday 
</p>
<p>Similarities between the Arabic and Hebrew languages have enabled
groups of Israeli and Arab developers to assist each other in solving
common problems developing local versions of OpenOffice.org
software.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/applications/0,39020384,39170349,00.htm">http://news.zdnet.co.uk/software/applications/0,39020384,39170349,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org now available at CompUSA and TigerDirect.com|outline"></a>
OpenOffice.org now available at CompUSA and TigerDirect.com</h2>
<p>&quot;Flexiety Software Company is now selling OpenOffice.org for
Windows with support at 25 CompUSA stores in Silicon Valley, Seattle,
and Texas. The company expects to have OpenOffice.org available in
all CompUSA stores by 2006.&quot;</p>
<p><a HREF="http://www.desktoplinux.com/news/NS6869512239.html">http://www.desktoplinux.com/news/NS6869512239.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Bristol ponders switch to StarOffice|outline"></a>
Bristol ponders switch to StarOffice</h2>
<p>&quot;Bristol City Council may move up to 5,000 of its desktop
computers to StarOffice next year. The move could save an estimated
&pound;1.4m over five years, a council spokeswoman said on Friday.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/linuxunix/0,39020390,39171155,00.htm">http://news.zdnet.co.uk/software/linuxunix/0,39020390,39171155,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.Migration at Dover Grammar School for Boys|outline"></a>
Migration at Dover Grammar School for Boys</h2>
<p>'Case study here with practical information about how to move to
OOo on Linux thin clients.'</p>
<p><a HREF="http://www.schoolforge.org.uk/index.php/Dover_Grammar_School_for_Boys">http://www.schoolforge.org.uk/index.php/Dover_Grammar_School_for_Boys</a></p>
<h2 CLASS="western"><a NAME="0.0.Sun signs Interface for Opteron dealer push|outline"></a>
Sun signs Interface for Opteron dealer push</h2>
<p>&quot;Sun Microsystems UK has signed up Birmingham-based distie
Interface Solutions to wholesale Sun servers, desktops and
workstations.&quot;</p>
<p>...</p>
<p>&quot;Gary Nugent, iForce partner and mid-market director at Sun,
said the deal gave the company, access to &quot;new markets in
regions across the UK, bringing a great opportunity for growth and
the chance to expand the Sun offering of Linux and StarOffice into
previously untouched markets.&quot;</p>
<p><a HREF="http://www.theregister.co.uk/2004/10/04/sun_signs_interface/">http://www.theregister.co.uk/2004/10/04/sun_signs_interface/</a></p>
<h2 CLASS="western">UK tech specialist school pioneers open source
switch</h2>
<p>&quot;Using OSS packages such as OpenOffice, MySQL and The Gimp
had advantages over using proprietary software because the school
didn't need to worry about licensing issues connected with pupils
running the software at home. Support for Windows-based legacy
software that had no direct OSS equivalent was also needed.&quot;</p>
<p><a HREF="http://www.theregister.co.uk/2004/10/19/oss_school_switch/">http://www.theregister.co.uk/2004/10/19/oss_school_switch/</a></p>
<p>Case study:</p>
<p><a HREF="http://www.theregister.co.uk/Design/page/linux_case_study_orwell_high_school.html">http://www.theregister.co.uk/Design/page/linux_case_study_orwell_high_school.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Germans claim Linux lowers costs|outline"></a>
Germans claim Linux lowers costs</h2>
<p>&quot;The greatest cost saving opportunities that Soreon Research
found were in the adoption of a variety of office applications on
work-stations. Over three-years, a 2000-seat organisation would save
around 525,000 with office applications, 57,000 with servers, 32,000
with content management systems and 21,000 with databases. For a
1,000,000 budget, the use of OpenOffice.org instead of Microsoft
Office would provide a 20 per cent cost advantage.&quot;</p>
<p><a HREF="http://www.theinquirer.net/?article=19006">http://www.theinquirer.net/?article=19006</a></p>
<h2 CLASS="western"><a NAME="0.0.OpenOffice.org at the City of Bergen, Norway|outline"></a>
OpenOffice.org at the City of Bergen, Norway</h2>
<p>&quot;The City of Bergen, in Norway, is also due to migrate
desktops in its 100 schools, which have 32,000 students and pupils.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/windows/0,39020396,39171012,00.htm">http://news.zdnet.co.uk/software/windows/0,39020396,39171012,00.htm</a></p>
<p>Sun Microsystems Launches Sun Technology and Academic Resources
Initiative (STAR) to Reduce Cost and Complexity for Education IT
Community</p>
<p>&quot;Continuing its mission to provide access to technology and
technical resources for higher education and K-12 schools and
research institutions, Sun Microsystems, Inc. (Nasdaq: SUNW)
announced the Sun(SM) Technology and Academic Resources (STAR)
initiative. STAR brings together several strategic programs that can
reduce the cost and complexity of managing network systems for the
education IT community.&quot;</p>
<p><a HREF="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=109&amp;STORY=/www/story/09-27-2004/0002259028&amp;EDATE">http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=109&amp;STORY=/www/story/09-27-2004/0002259028&amp;EDATE</a>=</p>
<h2 CLASS="western"><a NAME="0.0.Open approach offers Mindef more choice|outline"></a>
Open approach offers Mindef more choice</h2>
<p>&quot;The Ministry of Defence (Mindef) has installed the
OpenOffice productivity suite on 5,000 new desktop computers. This
move is aimed at giving employees in the ministry an additional
choice in productivity software. It will also help Mindef make
'significant' savings in terms of capital costs (see box story on
page 6).&quot;</p>
<p><a HREF="http://computertimes.asiaone.com.sg/news/story/0,5104,2868,00.html">http://computertimes.asiaone.com.sg/news/story/0,5104,2868,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Singapore government switches to OpenOffice.org |outline"></a>
Singapore government switches to OpenOffice.org 
</h2>
<p>&quot;With the ministry operating around 20,000 PCs, the decision
to move to open-source software on the desktop is among the biggest
by any government agency, according to Bloomberg News.</p>
<p>[...]</p>
<p>OpenOffice.org is available all four of Singapore's official
languages: English, Chinese, Malay and Tamil, according to the native
language section of the OpenOffice.org site. Office 2003 is only
available in English and Chinese, according to the Microsoft Web
site.&quot;</p>
<p><a HREF="http://news.zdnet.co.uk/software/windows/0,39020396,39171012,00.htm">http://news.zdnet.co.uk/software/windows/0,39020396,39171012,00.htm</a></p>
<h2 CLASS="western"><a NAME="0.0.NSW opens door to Linux offers|outline"></a>
NSW opens door to Linux offers</h2>
<p>&quot;THE NSW Department of Commerce has released its eagerly
anticipated Linux tender, calling for a panel of suppliers to provide
enterprise-level software and services for government agencies.</p>
<p>The contract, reportedly worth $40 million, is seen as a major
step forward for open source lobbyists, as it requests suppliers to
provide Linux software for both desktop and server environments.&quot;</p>
<p>&quot;n keeping with the NSW governments push for openness within
its IT environment, the tender document states submissions can be
lodged in file formats that can be read by OpenOffice.org/StarOffice
Write and Microsoft Word.&quot;</p>
<p><a HREF="http://australianit.news.com.au/articles/0,7204,10916500%5E15344%5E%5Enbv%5E15306-15321,00.html">http://australianit.news.com.au/articles/0,7204,10916500%5E15344%5E%5Enbv%5E15306-15321,00.html</a></p>
<h2 CLASS="western"><a NAME="0.0.An Open Road|outline"></a>An Open
Road</h2>
<p>&quot;Years later, the RTA explored use of alternative desktops
with the rollout of Sun Microsystems Java Terminals for staff at the
organization's 140 registries. It recently installed Sun StarOffice
on more than 300 desktops to assess its suitability as a replacement
for Microsoft Office. All projects were conceived and executed
in-house by an IT organization whose more than 200 IT staff service
some 6600 employees and maintain more than 800 applications.&quot;</p>
<p><a HREF="http://www.cio.com.au/index.php/id;439031820;fp;4;fpid;21">http://www.cio.com.au/index.php/id;439031820;fp;4;fpid;21</a></p>
<h2 CLASS="western"><a NAME="0.0.Open for Business - The 2004 OfB Choice Awards|outline"></a>
Open for Business - The 2004 OfB Choice Awards</h2>
<p>&quot;Best Office Suite: OpenOffice.org 1.1.1 OpenOffice.org
remains the only serious contender to replace Microsoft Office on
Windows or GNU/Linux desktops. There are some competitors, such as
Abiword on Windows and GNU/Linux as well as Corel WordPerfect Office
on Windows; OpenOffice.org seems to have a unique hold on progress
toward offering comprehensive compatibility with Microsoft Office in
an interface that should minimize adjustment time for users migrating
to it.&quot;</p>
<p><a HREF="http://www.ofb.biz/modules.php?name=News&amp;file=article&amp;sid=330">http://www.ofb.biz/modules.php?name=News&amp;file=article&amp;sid=330</a></p>
<h2 CLASS="western"><a NAME="0.0.Review: OpenOffice.org 1.9 m54|outline"></a>
Review: OpenOffice.org 1.9 m54</h2>
<p>&quot;The latest snapshot at the moment of writing is 1.9m54, and
while there is still a long way to go till the final release of
OpenOffice.org 2.0, it gives a fairly good idea of what users can
expect to see in the next major release of OOo.&quot;</p>
<p><a HREF="http://www.pcstuff.dk/articles/ooo19m54/index.html">http://www.pcstuff.dk/articles/ooo19m54/index.html</a></p>
<h2 CLASS="western"><a NAME="0.0.Open Office XML May Satisfy ISO|outline"></a>
Open Office XML May Satisfy ISO</h2>
<p>&quot;A letter to Sun Microsystems' COO Jonathan Schwartz by the
European Commission (EC) this week may set the stage for the
International Organization for Standardization (ISO) to adopt the
Open Office XML format (also known as OO.o XML) as an ISO standard.
If it does, the stamp of approval would mark the largest ever
validation of Sun's work on the desktop.&quot;</p>
<p><a HREF="http://www.internetnews.com/dev-news/article.php/3414101">http://www.internetnews.com/dev-news/article.php/3414101</a></p>
<p>Weblog:</p>
<p><a HREF="http://www.tbray.org/ongoing/When/200x/2004/09/24/SmartEC">http://www.tbray.org/ongoing/When/200x/2004/09/24/SmartEC</a></p>
<p>Slashdot story:</p>
<p><a HREF="http://it.slashdot.org/it/04/09/27/1111202.shtml?tid=117&amp;tid=102&amp;tid=1&amp;tid=218">http://it.slashdot.org/it/04/09/27/1111202.shtml?tid=117&amp;tid=102&amp;tid=1&amp;tid=218</a></p>
<p><br><br>
</p>
</body>
</html>
