<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
<title>First BrOffice.org Meeting</title>
<meta NAME="GENERATOR" CONTENT="OpenOffice.org 2.0  (Unix)">
<style>
<!--
-->
</style>
</head>
<body>
<h2>The First Brazil BrOffice.org (OpenOffice.org) Meeting </h2>
<h4>&nbsp;</h4>
<h4>First BrOffice.org meeting shows the strength of collaboration</h4>
<p>-Gustavo Pacheco &ndash; BrOffice.org Documentation Project</p>
<p>-Translated by Roberto Salomon </p>
<p>Innovation, collaboration and results. In its first National Meeting, on June 2, 2006 through a video conference link connecting over 20 Brazilian states and Canada, the BrOffice.org project showed once more the power of collaborative work.</p>
<p>Through the support of SENAI/CE, ITI, the Free Software Knowledge Community, the Legislative House of the State of Cear&aacute; and a large network of volunteers throughout Brazil, the First BrOffice.org National meeting proved the feasibility of large virtual meetings. In the words of the coordinator of the project,Claudio Ferreira, the challenge of organizing an event like this was fully rewarded by the satisfaction of bringing to a common space from the new user to  Louis Suarez-Potts, chair of the OpenOffice.org Community Council and Community Manager. Balancing technical and strategical themes, the meeting presented a broad overview of the development of BrOffice.org and the future of the project.</p>
<h2>C&eacute;sar Cals Neto: why support BrOffice.org?</h2>
<p>The opening of the meeting had the words of the representative of the Federation of Industries of the State of Cear&aacute; (FIEC), C&eacute;sar Cals Neto. The virtual format of this First National Meeting was possible mainly due to the participation of FIEC. Under Marcus Diogo da Silva's coordination, the meeting was organized with BrOffice.org's coordinators during the four previous months. Besides the video conference control, Fortaleza also coordinated the registration of participants.</p>
<p>In a few minutes, Cals Neto presented the reasons that led FIEC to support BrOffice.org and FOSS. According to him, &ldquo;competitiveness is, today, fundamental to any productive system and Free Software is one of the ways for us to become competitive, not just due to cost reduction, but for the possibility of developing more efficient software.&rdquo;</p>
<p>Cals Neto spoke also of the importance of the development of the BrOffice.org project and of the collaborative work: &ldquo;the broad reach of BrOffice.org and its importance as Free Software will allow for new generations of students to become better prepared professionals in the future.&rdquo;</p>
<h2>New in BrOffice.org</h2>
<p>One of the most important presentations of the meeting was presented in Fortaleza by the project's general coordinator, Claudio Ferreira Filho. Since the first coordination meeting of the BrOffice.org NGO, last May, it was known that activities of the project had to be presented clearly to the user community. Even after several months from the announcement of the name change to BrOffice.org and the constitution of the NGO, many people still did not have information regarding the status of the project as well as the activities being done.</p>
<p>The beginning of the presentation focused on the reasons for the change. Claudio made clear that BrOffice.org is a continuation of OpenOffice.org.br and not a fork from the original project. All code development done in Brasil is replicated to the international project. However, several adaptations are developed focusing specifically on the Brazilian user.</p>
<p>The legal problem regarding the use of the brand &ldquo;Open Office&rdquo; in Brazil made the project seek its formalization though the establishment of NGO (Non Governmental Organization) whose goals are to foster BrOffice.org's and OpenOffice.org's development, keep technical knowledge in the country and act towards the digital inclusion of the population. Claudio said that the establishment as a formal association allowed the project to trademark &ldquo;BrOffice.org&rdquo; and register the Internet domain names, giving developers, users and the project the legal safety required by all. Still in the beginning of his presentation, Claudio spoke about the new visual identity of the project, the new portal, which has approximately 300.000 hits per month, and the structure made available to developers (wiki, svn, and tracker). He informed the developers that identification is required for all contributions and also about the use of digital signatures.</p>
<p>Speaking about new projects, Claudio spoke about the work being done by several collaborators of the BrOffice.org project. Among other projects, the Spelling Dictionary, the &ldquo;Escrit&oacute;rio Aberto&rdquo; project, the Automated Document Generator, the Grammar checker, the Thesaurus and the digital inclusion, make for the difference between BrOffice.org and the binaries made available through the international project.</p>
<p>Regarding the difficulties faced by the project, the most important point was the need for hardware and software to compile new versions of BrOffice.org. It was pointed out that BrOffice.org under Windows is compiled on legally registered hardware and software. Through financing alternatives, the project is looking to minimize the costs of hardware acquisition and software licensing. One of the initiatives is the &ldquo;Invest in this idea &ndash; BrOffice.org&rdquo; seal, directed to companies that wish to foster the development of BrOffice.org in Brazil. The investments done in the NGO will be used, for example, to allow for major goals of the project to be reached, such as the simultaneous version release of BrOffice.org and OpenOffice.org. According to Claudio, the waited release of BrOffice.org 2.0.3 will hopefully be done in parallel to OpenOffice.org 2.0.3. Besides that, the financial resources will allow for future projects such as the usage of digital signatures in documents, for example.</p>
<h2>The Importance of ODF</h2>
<p>The next to speak was Roberto Salomon, one of the founders of the BrOffice.org NGO and coordinator of the meeting in Bras&iacute;lia. Salomon spoke about the OpenDocument Format (ODF), the standard file format of BrOffice.org and of several other corporate applications, both free and proprietary.</p>
<p>His presentation showed the importance of open standards for document exchange and pointed ODF as the major alternative for document storage over the next years. Since May 1<sup>st</sup>, ODF became an international industry standard by ISO &ndash; International  Organization for Standardization, under the number ISO/IEC 26300. According to Salomon, the standardization of open formats resembles the development of the Internet. Based on open standards, the Internet developed in a decentralized fashion allowing for the free circulation of information. Likewise, the usage of open standards will guarantee the access to information, even after many years.</p>
<p>Remembering that ODF is not a BrOffice.org exclusive, Salomon said that ODF allows users to regain full control over their documents. &ldquo;Nobody is forced to user BrOffice.org. Over 21 available products, free or closed, support ODF: WordPerfect, Lotus, IBM Workplace, KOffice, AbiWord,...&rdquo; With this, software authors won't keep their users by locking them in the document format, but through the quality of their products.</p>
<p>Users have already understood the context and, today, are more clear on the importance of open standards and of the interoperability of applications. In the corporate arena, in special, this is a basic need. Mentioning Boeing as a participant of the OASIS consortium, Salomon said that the aviation giant is interested in the format because, even after decades, the documents will continue to be functional and usable, without licensing dependencies generated by the use of proprietary formats.</p>
<p>Asked about the interoperability with Microsoft's Office new proprietary formats, Salomon said that, although Microsoft is reluctant in adopting ODF, the use of open standards is a path of no return and that communities of developers are seeking ways of breaking the barriers imposed by Microsoft by developing plug-ins that will allow for ODF in Microsoft Office.</p>
<h2>Brazilian Project with International Recognition</h2>
<p>Speaking from S&atilde;o Paulo, Carlos Menezes started the first technical panel of the afternoon speaking about the BrOffice.org projects aimed towards linguistics. Initially, Menezes presented the spelling dictionary, coordinated by Raimundo Moura and that already recognizes over 1.4 million words. The Thesaurus, coordinated by Murillo Lamas and F&aacute;bio Souza was also presented.</p>
<p>Regarding CoGrOO, a grammar checker for OpenOffice.org/BrOffice.org, Menezes said that approximately two years ago, along with three other researchers, he started the project to implement a grammar checker for OpenOffice.org. This project was one of the projects financed by FINEP en 2003.</p>
<p>CoGrOO was released last May and works with versions 1.x and 2.x of OpenOffice.org/BrOffice.org. The implementation was made in Perl an the user interface in Java. The application works in both Linux and Windows, but other ports are being planned for the future. Besides this, enhancements are being planned for the correction engine and new style rules will be developed as well as support for other languages. This is justified by the international attention that the project has obtained. The project has been mentioned as being one of the most advanced in linguistics. The success of the project was such that one of the developers' was accepted to develop a grammar check API for OpenOffice.org under Google's Summer of Code project.</p>
<p>Menezes also presented a comparison of CoGrOO with Regra, the proprietary grammar checker in Microsoft Office. The comparison was made relating true positives, which are real errors, and false positives, which are grammatically correct but incorrectly pointed as errors. In the comparison, CoGrOO's performance was better, marking less than half of the false positives of Regra. While Regra identified 26 false positives, CoGrOO identified only 10. The treatment of style errors is due for the next version.</p>
<p>Asked about the difficulty of CoGrOO's installation, Menezes said that CoGrOO 2 will be completely in Java, removing the current dependency in Perl. The support for free JVMs is also a question of time. Version 2 should be available by the end of 2006.</p>
<h2>Macros in BrOffice.org</h2>
<p>From Recife, Noelson Duarte, Brazil's major OpenOffice.org macro developer, made the second technical presentation of the meeting talking about the resources and organization of macros in BrOffice.org. The theme is one that attracts interest from users that are starting to use the application, especially in the corporate environment where, even at a reasonably complex level, the creation of macros is a widespread functionality.</p>
<p>Through the use of examples, Noelson demonstrated all the possibilities of the development of macros in BrOffice.org. The use of the API from different programming languages allows users to access a series of resources in document manipulation, the use of dialogs, the creation of interfaces, and the OpenOffice.org Basic, a comprehensive understanding of structures and flow control of the programs.</p>
<p>Regarding the collaborative work developed by Noelson, one of the commitments made over the break, where, in a brief meeting with Gustavo Pacheco, it was defined that the project will host the documents regarding macro development under Noelson's coordination.</p>
<h2>Louis Suarez-Potts in the Brazilian Meeting</h2>
<p>Live from Toronto, Canada, Louis Suarez-Potts, chair of the OpenOffice.org Community Council, started by thanking the possibility to speak to Brazil through a virtual collaborative environment. [Louis' virtual presence owed everything to the heroic work of Marcus Diogo da Silva, who arranged things from Brazil, no less.] Louis' presentation was about the responsibility of governments in relation to open standards and the use of OpenOffice.org, mentioned Microsoft as a counterexample and congratulated Brazil's public policies regarding Free Software.</p>
<p>Louis made the point that over the last decades, governments have used electronic means to store data and it is a responsibility of these governments to allow access to this information. Within this context, ODF appears as an adequate alternative to eliminate the dependency of proprietary file formats.</p>
<p>He reminded that paper documents do not need licensing to be read. Electronic documents, on the other hand, are dependent of specific devices. In the case of usage of proprietary formats, these are subject to the whims of the market and may be discontinued. Besides that, the reading of these documents require the licensing of proprietary software.</p>
<p>We pay a high price for the convenience of using Microsoft products. Contrary to paper and pen, these technological resources are proprietary. There is no guarantee that documents created today will be usable in the future.</p>
<p>Louis compared this situation with the Middle-Ages, where people had to pay to learn Latin, the official language for the recording of knowledge. &ldquo;A choice that must be made. I'll paint it starkly: On the one hand, we have a kind of neo-feudalism privileging the elites and costing the nation untold millions not just today but tomorrow. On the other, we have open standards coupled with the free open source and the promotion of markets and innovation. The first leads to an increasing dependency on foreign companies, the second drives the growth of national wealth.&rdquo;</p>
<p>Louis said that Brazil is giving an example to the world in moving towards FOSS. According to him, it is not enough to use open standards. It is necessary to use Free Software, enabling citizens to access public documents.</p>
<h2>Participation in the States</h2>
<p>Possibly one of the most moving moments of the meeting for the participants happened when Claudio Ferreira addressed each of the video conference links. For a brief moment, the participants of each link were able to interact with other cities and states.</p>
<p>One of the first collaborators of the project, C&eacute;sar Melchior, commented, from Porto Alegre, that it was the first time that he could interact directly with people that he had known only from e-mails.</p>
<p>The time was also used for collaborative announcements. From Paran&aacute;, it was announced that Writer, Calc and Impress training materials authored by SANEPAR &ndash; the local public water company. Vitorio Furusho also announced the availability of his Quick Guides, updated for BrOffice.org 2.0.x. According to Furusho, the training materials and the guides will be sent for publication in the BrOffice.org site in the next days.</p>
<h2>Success Cases</h2>
<p>Three success cases in the migration to BrOffice.org illustrated the second part of the meeting. Banco do Brasil, Brazilian Army, and FIEC presented their migration cases detailing strategies and techniques used in the deployment of the software.</p>
<p>From Bras&iacute;lia, the senior analyst Dinis dos Santos presented Banco do Brasil's case. Altogether, OpenOffice.org 2.0 was installed in all 4,000 branch offices, in the central management, and departments, adding up to 31 thousand workstations. According to Banco's information, the savings were in the order of 7 million Reais.</p>
<p>Soon after, in Fortaleza, it was the Brazilian Army's turn to present their case in the person of Major Alexandre. In the Army, migration was based on the strategic planning for Free Software in the Federal Government, from October, 2003. According do Major Alexandre's presentation, BrOffice.org is perfectly adequate for organizations of any size. However, one of the decisive aspects for their success was the training of human resources.</p>
<p>Ending the presentation of cases, C&eacute;sar Cals Neto, from FIEC, presented the institution's case of success, showing that over 80% of the 1000 workstation network already uses BrOffice.org. The project used S&atilde;o Paulo's Subway's Authority's experience as reference for their Free Software Migration.</p>
<h2>Round Table</h2>
<p>Jefferson Adelmo and Ulisses de Souza, representing the government, C&eacute;sar Cals Neto, representing the private companies, and Claudio Ferreira and Roberto Salomon, representing the community debated in the round table that closed the event. The chosen format was questions and answers between the members and later, it was opened to the several states so the participants could also ask questions.</p>
<p>Discussing the relationship between government, companies, users and the communities, Claudio suggested a better synchronism between the people and organizations interested in the development of Free Software in Brazil and asked about the possibilities of partnership between the public sector and the Free Software communities such as BrOffice.org.</p>
<p>The government representatives replied mentioning the importance of this kind of action and pointed out what each governmental organization did regarding not only the use but also the support given to Free Software projects. The participating organizations offered the community help in making available documents regarding their migration projects.</p>
<p>Asked about support from private companies, Cals Neto believes that support is fundamental to allow for projects to be sustainable and that support for events and meetings such as this First National Meeting, is a result of this support.</p>
<p>In his talk, Roberto Salomon, emphasized that Free Software, and specially BrOffice.org, is not a collaboration area just for developers. Any volunteer can be a collaborator in his/her area of knowledge.</p>
<p>In the last question for the participants, Claudio mentioned the project's concern in fulfilling user demands for professional certification and said that the project was already working on the matter to define, initially, a minimal certification corpus in order to, later, develop a certification process. He said, however, that the complexity of the process requires special attention for the work and the desired results.</p>
<h2>Results</h2>
<p>The First National BrOffice.org Meeting opened a new chapter in the history of Free Software events in Brazil. The virtual meeting had the support of over 1000 people throughout the country integrating the several local BrOffice.org communities and allowing for the interaction of participants. Several social groups benefited from the food donation by the participants. In Recife, over 30Kg of food was donated to the Sociedade Educacional e Creche Escolar Tancredo Neves, as related by Noelson Duarte. In Aracaju, Raimundo Moura informed that 70Kg of food were donated to the Sociedade Creche A&ccedil;&atilde;o Solid&aacute;ria Almir do Picol&eacute;.</p>
<p>Throughout the months of planning, the meeting underwent several modifications until it reached its final format. Programmed, initially, to happen in parallel to the seventh FISL, in April, the meeting was postponed to July. The organization hoped to have more time to articulate the event and make its execution possible. Despite that, there were several difficulties. Marcus Diogo da Silva, from FIEC and one of the people responsible for the event, remembers that &ldquo;we had to manage a real problem that was the downsizing of the event. We had a full day schedule but, unfortunately, only the afternoon was available in the video conference network.&rdquo;</p>
<p>The meeting was also a victory for the community. The vast majority of the organizers of the video conference links were participants in Free Software user and developer groups. For many of these volunteers, directly participating in the BrOffice.org project, the moment is one of evaluating results and, soon after, of hands on to make true the commitments made with the users, confirming the success of this First National BrOffice.org Meeting.</p>
</body>
</html>
