<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <title>Review Produk</title>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <link type="text/css" rel="stylesheet" href="produk.css" />
</head>
<body><div id="midtabs">
<ul> 
  <li><a href="index.html">Product</a></li>
  <li><a href="writer.html">Writer</a></li>
  <li><a href="calc.html">Calc</a></li>
  <li><a href="impress.html">Impress</a></li>
  <li><a href="draw.html">Draw</a></li>
  <li><a href="base.html">Base</a></li>
  <li><a href="math.html">Math</a></li>
  <li><a href="paket.html">Paket</a></li>
  <li class="th"><a href="review.html">Review</a></li>
  <li><a href="kasus.html">Kasus</a></li>
  <li><a href="informasi.html">Lebih Lanjut</a></li>
</ul>
</div>
<br />
<br/>
<hr />
<h2>Review Produk</h2>
<p>Harap dicatat bahwa OpenOffice.org tidak membeli cetakan dari majalah yang mencetak review ini. Kami tidak membeli iklan pada majalah tentang review atau yang telah me-review OpenOffice.org. Jika reviewer mengatakan OpenOffice.org adalah produk yang bagus, maka itu adalah opini mereka yang tidak bias.</p>

  <h3>Review Pra-Rilis OOo 3.0</h3>

  <ul>
    <li><a href=
    "http://www.eweek.com/c/a/Linux-and-Open-Source/OpenOfficeorg-Grows-Up/">OpenOffice.org
    Grows Up</a> oleh Jason Brooks, 2008-10-02 <span style=
    "font-weight: bold;">eWeek.com</span> <cite>Nine years after Sun
    Microsystems bought StarOffice, the resulting OpenOffice.org project is
    ready to roll out its 3.0 release. Enhanced format compatibility and
    features put it on par with Microsoft Office.</cite></li>

    <li><a href=
    "http://www.expresscomputeronline.com/20081013/edit01.shtml">OpenOffice
    3: a preview</a> oleh Prashant Rao <span style="font-weight: bold;">Express
    India</span> <cite>OpenOffice is free, and for organizations that want to
    stay legal and yet provide an office suite to all their workers. it is an
    excellent solution. A mixed environment with power users on Office 2007
    and the rest on OpenOffice works well, as some of India?s biggest banks
    and BPO outfits have found out to their advantage.</cite></li>

  </ul>

<h3>Review OOo 2</h3>

  <p><strong>PC Pro Magazine</strong> mengirimkan komentarnya pada versi 2:
  <cite>Our pick of the low-cost office suites has had a much-needed
  overhaul, and now battles Microsoft in terms of features, not just
  price.</cite><br>
  OpenOffice.org 2 mendapatkan <img src="pix/6stars.gif" alt="six stars" border="0"
  height="10" width="69"> pada <a href=
  "http://www.pcpro.co.uk/reviews/80012/openoffice-2.html">Issue 135, Jan
  06</a>. Reviewer majalah menyimpulkan: <cite>OpenOffice jelas tidak kekurangan fitur dibandingkan dengan penguasa pasar dan sebagian besar dari fitur-fitur yang mudah digunakan berasal dari kebiasaan orang terhadap Microsoft Office dibandingkan dengan masalah dengan program itu sendiri. Dengan kondisi seperti ini, Anda harus mencoba penawaran OpenOffice sebelum mendonasikan UKP100 atau lebih pada tawaran Microsoft. Lagipula, ini gratis.</cite></p>

<h3>Review OOo 2.0</h3>
<ul>
  <li><a href=
    "http://www.eweek.com/article2/0,1895,2224467,00.asp">OpenOffice.org 2.3
    Impresses</a> oleh Tiffany Maleshefski, November 28, 2007 <span style=
    "font-weight: bold;">eWeek.com</span> <cite>Review: OpenOffice.org 2.3
    sports a nifty set of feature improvements, but the suite's sweetest
    features remain its low cost (free) and its strikingly broad platform
    support.</cite></li>

    <li><a href=
    "http://media.www.thetowerlight.com/media/storage/paper957/news/2007/10/22/Life/Tyler.Tech.OpenSource.A.Software.Alternative-3045983.shtml">

    Open-source a software alternative</a> Krysten Appelbaum, 10/21/07
    <span style="font-weight: bold;">College Publisher Network</span>
    <cite>OpenOffice.org is, as the name would suggest, a full open-source
    suite of office programs. Every program a student ever needs is in here,
    from a writing program to a presentation creator similar to
    PowerPoint.</cite></li>

    <li><a href=
    "http://www.cfo.com/article.cfm/9607908?f=msdynamics">Spreadsheets Are
    Free</a> John Edwards, August 02, 2007 <span style=
    "font-weight: bold;">CFO.com</span> <cite>Liberated from license fees,
    Calc can be downloaded and installed on as many PCs as you
    please.</cite></li>

    <li><a href="http://www.post-gazette.com/pg/07209/805072-96.stm">Users'
    Guide: A free Office alternative? Sweet</a> oleh Etan Horowitz, Saturday,
    July 28, 2007 <span style="font-weight: bold;">Orlando Sentinel</span>
    <cite>I was able to do virtually everything I could do in Office, such as
    create pivot tables from spreadsheets and add animations to slides. If
    you want free software that operates the most like Microsoft Office, this
    is it.</cite></li>

    <li><a href="http://www.itreviews.co.uk/software/s489.htm">OpenOffice.org
    2.2 outstanding free office suite</a> (29/06/2007) <span style=
    "font-weight: bold;">IT Reviews Recommended</span> <cite>We can't stress
    enough how impressive this is for a freebie suite. Both Writer and Calc
    in particular perform admirably compared to full-priced rivals, and
    Impress and Base are right up there in terms of power and
    usability.</cite></li>

    <li><a href=
    "http://www.eweek.com/article2/0,1895,2146421,00.asp">OpenOffice Sports
    All-Around Improvements</a> By Tiffany Maleshefski June 13, 2007,
    <span style="font-weight: bold;">eWeek.com</span> <cite>IT managers
    looking for alternatives to Microsoft Office?particularly those unwilling
    to make the leap to Office 2007?will find OpenOffice.org 2.2 well worth
    evaluating because, as the suite offers a good solution for cutting
    software costs while expanding platform options and minimizing
    compatibility issues.</cite></li>

    <li><a href=
    "http://thechronicleherald.ca/NovaScotia/561182.html">OpenOffice free
    office software suite</a> By Andrew D. Wright Monday February 26, 2007,
    <span style="font-weight: bold;">The ChronicleHerald</span>
    <cite>OpenOffice.org is a completely free Open Source office software
    suite that not only can read and write to the various commercial office
    software file formats, but also writes to the now-standard OpenDocument
    format.</cite></li>

  <li><a href="http://www.business-standard.com/iceworld/storypage.php?leftnm=lmnu9&amp;subLeft=1&amp;autono=92233&amp;tab=r">Another
office</a> oleh Leslie D'Monte 24 Mei 2006, <span style="font-weight: bold;">Business Standard</span>
<cite>This Office Suite can give established players a run for their money ...
anyone who wants a feature-rich but free office suite should give this
option a try.</cite>
  </li>
  <li><a href="http://www.pcadvisor.co.uk/reviews/index.cfm?reviewid=271">Microsoft Works Suite 2006</a>
  Software Review, February 21, 2006 <b>PC Advisor</b>
  <cite>Home users, small businesses and educational facilities on
super-tight budgets are now regarding OpenOffice.org as a valid
alternative to the dominance of Microsoft's mighty Office Suites.</cite>
  </li>
  <li><a href="http://www.syracuse.com/news/poststandard/index.ssf?/base/news-0/1140084398219190.xml&amp;coll=1">Free
Office software subs well for costly version</a> oleh Al Fasoldt
Sunday, 19 Februari 2006 <b>Syracuse Post Standard</b>
  <cite>I've been using a free alternative to Office for many
years, through a number of revisions.
The latest version, called OpenOffice, is exceptional in some ways.
Considering the price, it's downright outstanding
</cite>
  </li>
  <li><a href="http://www.democratandchronicle.com/apps/pbcs.dll/article?AID=/20060219/BUSINESS0103/602190331/1001/BUSINESS">Open
Office a lot like Microsoft product - and free
</a>By Nick Francesco - 19 Februari 2006 <b>Rochester
Democrat and Chronicle</b>
  <cite>Open Office (or, as they prefer, OpenOffice.org) is a
complete
office suite, much like the more familiar Microsoft Office. For those
of you
who are familiar with Microsoft Office, you'll feel right at home with
OpenOffice.org ... Give OpenOffice.org a try. It's free and you can
have it loaded on the same
computer at the same time as Microsoft Office.
  </cite>
  </li>
  <li><a href="http://www.linux-magazine.com/issue/63/OpenOffice.org_2.0_Review.pdf">The
latest OpenOffice comes with new file formats and many new features
[PDF, 1336 kB]</a>
oleh Michael Bona Issue 63: Februari 2006 <b>Linux Magazine</b>
  <cite>All in all, the developers have done a great job with
OpenOffice 2.0. This office package can do everything better than its
predecessor, just like you would expect of any healthy five-year-old.
  </cite>
  </li>
  <li><a href="http://www.eweek.com/article2/0,1759,1876087,00.asp">OpenOffice.org
2.0 Has Edge over Its StarOffice 8 Cousin</a>
oleh Jason Brooks 21 Oktober 2005 <b>eWeek.com</b>
  <cite>eWEEK Labs' tests of OpenOffice.org 2.0 show that it is an
excellent office productivity suite option, particularly in the case of
Linux distributions, which typically come bundled with a
well-integrated version of the suite.</cite>
  </li>
  <li><a href="http://www.eweek.com/article2/0,1895,1874157,00.asp">Why
OpenOffice.org 2.0 Is Your Best Choice</a>
Oleh Steven J. Vaughan-Nichols 20 Oktober 2005 <b>eWeek.com</b>
  <cite>OpenOffice.org's price tag: 0. Microsoft Office
Professional Edition 2003's list price: $499 new, $329 as an upgrade.
Day in and day out office usability? For all practical purposes,
they're about the same.
So, which would you rather 'buy?'</cite>
  </li>
</ul>
<h3>Preview OOo 2.0</h3>
<ul> 
  <li> <a href="http://computerworld.com.sg/ShowPage.aspx?pagetype=2&amp;articleid=2742&amp;pubid=3&amp;issueid=66">Migrating
to OpenOffice.org 90 per cent cheaper than to Microsoft
Office 12 </a>Vol. 11 Issue 23 | 23 September - 6 Oktober 2005 <b>Compterworld</b>
  <cite>The industry's two major office suites, Microsoft Office
and
OpenOffice.org, will soon be releasing new versions. Recent research
into these versions by large government departments indicates that for
many sites, it is now 10 times cheaper to migrate to the new
OpenOffice.org 2.0 than upgrading to Microsoft Office 12.</cite> </li>
  <li> <a href="http://www.suntimes.com/output/worktech/cst-fin-andy22.html">OpenOffice
is great alternative to Microsoft</a>
oleh Andy Ihnatko, 22 September 2005 <b>Chicago
Sun-Times</b> <cite>...you
won't use it because you hate Microsoft or because you
don't like tying your whole office's (or your government's) ability to
function to the proprietary whims of one single company. Maybe you
won't even use it just because it'll cost you $0 to Microsoft Office's
$365. You'll use it because OpenOffice 2.0 is an attractive and
compelling suite of office apps in its own right.</cite> </li>
  <li> <a href="http://www.pcmag.com/article2/0,1895,1851001,00.asp">Openoffice.org</a>
09.06.05 <b>PCMag.com</b> <cite> 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.</cite> 
  </li>
  <li> <a href="http://www.vnunet.com/personal-computer-world/software/2140229/openoffice-org">Openoffice.org
2 - a new, improved version that gives Microsoft a run for its money</a>
Oleh Cliff Joseph, 22 Juli 2005 <b>Personal
Computer World </b> <cite>...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.</cite> 
  </li>
  <li> <a href="http://news.ft.com/cms/s/1c5e53b8-b205-11d9-8c61-00000e2511c8.html">Open
source moves into Microsoft's Office block</a>
Oleh Simon London Published: 21 April 2005 03:00 <b>Financial
Times</b> <cite>The
latest incarnation of OpenOffice was last month released for testing by
users. Early reviews say it marks a big advance over earlier versions
of the free word processing, spreadsheet and presentation package.</cite>
  </li>
  <li> <a href="http://lwn.net/Articles/117952/">Looking
forward to OpenOffice.org 2.0</a>
Joe Brockmeier, 5 Januari 2003, <b>Linux
Weekly News</b> <cite>From
a test of the 1.9.65 build, it's pretty clear that the OpenOffice.org
project has a way to go before it's finished. However, this release
does provide a pretty good overview of what to expect, and it does look
like 2.0 will be a formidable suite when finished.</cite>
  </li>
</ul>
</body></html>
