<HTML>
    <HEAD>
        <TITLE>Bienvenida and Willkommen</TITLE>
        <META NAME="description" CONTENT="Bienvenida &amp; Willkommen to NetBeans">
        <link rel="stylesheet" type="text/css" href="../../netbeans.css">
    </HEAD>
    
    <BODY>
        
        <h1>Bienvenida &amp; Willkommen to NetBeans IDE 5.5.1!</h1>
        
        <p><b>The NetBeans community is proud to announce NetBeans IDE 5.5.1 in Spanish and German.
        These two localizations are now available in addition to the previously released localizations for 
        Japanese, Portuguese, traditional and simplified Chinese.</b></p>
        
        <h2>Who Made the Translations?</h2>
        
        <div style="float:right">
        <p><img src="../../images_www/articles/localizations-551/david.jpg" border="1" width="100" /><img
            src="../../images_www/articles/localizations-551/aristides.jpg" border="1" width="100" /><br>David and Aristides</p></div>
            
        <p>The German and Spanish localization teams are comprised of members of the NetBeans community. 
            They met on developer forums or mailing lists and
            agreed that a localized version of the IDE would be a benefit for people speaking their language. 
            So they joined the TranslatedFiles project, and took the translation into their own hands.
            
            <p>Ruth Kusterer is the coordinator of the German translation team 
                whose 6 <a href="http://nblocalization.netbeans.org//index_de.html">members</a> 
                come from Switzerland and Germany.
                
                David &Aacute;lvarez Le&oacute;n and Aristides Villarreal are the coordinators of the Spanish translation team. 
                The Spanish team has 40 <a href="http://wiki.netbeans.org/SpanishTranslationMembers_es">members</a> 
            who come from Panama, Spain, Mexico, Guatemala, Chile, Argentina, Peru, Cuba, and Colombia.</p> 
        </p>
        
        <P>The teams would like to thank Janice Campbell and Masaki Katakai 
        from the TranslatedFiles team for their help with streamlining the translation process, 
        and their support and enthusiasm for the localization project.
        
        <p><em>We regret that <a href="http://avbravo.blogspot.com/2007/06/miembro-equipo-traduccin-fallece.html">Mario 
                Alberto Jim&eacute;nez</a> of Guatemala, a member of the Spanish translation team, 
            died in a car accident this month. The NetBeans community sends condolences to his family.</em>
        </p>
        
        <h2>What Has Been localized?</h2>
        
        <p>NetBeans IDE 5.5.1 is available in Japanese, Portuguese, German, Spanish, 
        traditional and simplified Chinese. Additionally,
        the Profiler and the CLDC Mobility Pack have been localized into Chinese and Japanese.
        
        <P>Tip: If you wish to use an add-on that has not been localized yet into your language, 
            we recommend you to install the Standard English version of the pack or plug-in.        
            
        <div align="center"><p><img src="../../images_www/articles/localizations-551/german-localization.gif" 
        border="1" width="600" /><br />This is what NetBeans IDE 5.5.1 looks like in German.</p></div>

        <h2>Is Localization Difficult?</h2>
        
        <p>When working in a team it's important to keep your translations consistent. 
        In the case of Spanish, the language is spoken on the American and the European continent, 
        and the team needed to agree on certain terms and phrases; not only to avoid regionalism,
        but also to bring repeating strings of the user interface in line.
        
        <p>To keep inconsistencies at a minimum, the NetBeans community uses OmegaT, a free translation memory tool. 
        This piece of software exposes an application's localizable strings,
        and displays previous translations everytime you come across a matching similar string.
        If you are interested in localization, it is worth learning more about
        <a href="http://nblocalization.netbeans.org/docs/HOWTOs/How-to-translate-NetBeans-using-OmegaT.html">how 
        to translate applications using OmegaT</a>.
        
        <P>Depending on the size and spare-time of the team, it takes a few months 
        to complete the translation of an application of the size of NetBeans IDE. 
        Additional time should be considered for quality and consistency testing.
        
        <div align="center"><p><img src="../../images_www/articles/localizations-551/spanish-localization.gif" 
        border="1" width="600"/><br />This is what NetBeans IDE 5.5.1 looks like in Spanish.</p></div>
        
        <h2>How do I Localize the IDE?</h2>
        
        <ol>
            <li>Join the <a href="http://nblocalization.netbeans.org//docs/first_steps.html">TranslatedFiles project</a>.</li>
            <li>Introduce yourself on the dev@nblocalization.netbeans.org/ mailing list and get to know 
            <a href="http://nblocalization.netbeans.org//index-teams.html">other community members</a>.</li>
            <li>Join the <a href="https://netbeans.org/projects/translatedfiles/lists"> TranslatedFiles
                mailing list</a> for your language. 
                If there is no list for your language, ask the TranslatedFiles project leaders to set it up for you.
            </li>
            <li>Feel free to create your own status page on the 
                <a href="http://wiki.netbeans.org/wiki/view/TranslatedFiles">NetBeans Translators' Wiki</a>
                to keep your team members up-to-date. Including the following information 
                (in your language) will help your team get started:
                <ul>
                    <li>Instructions how to join the TranslatedFiles project</li> 
                    <li>Instructions how to join your team's mailing list</li>
                    <li>The download link for the L10n-kit and the translation memory you are using</li>
                    <li>Links to current instructions on nblocalization.netbeans.org/, including how to commit files</li>
                </ul>
            </li>
            <li>Assign modules to team members and use the <a href="http://wiki.netbeans.org/wiki/view/TranslatedFiles">wiki</a> 
            to maintain a table of who is working on what.</li>
            <li>Use <a href="http://nblocalization.netbeans.org//docs/HOWTOs/How-to-translate-NetBeans-using-OmegaT.html">OmegaT</a>
            and the L10n-Kit to expose localizable strings and to create the new Bundles.properties files. </li>
            <li>First check whether the encoding and the translation are correct.
            Then you either commit the translated files directly into the <code>translatedfiles</code> CVS module. 
            If you don't have permission, send the files to your team lead who commits them for you. </li>
        </ol>
        
        <P>Tip: Don't forget to check older versions before you start your project: NetBeans IDE 5.0
            for instance does not only contain localized files for Japanese, Chinese, and Spanish,
            but also for Korean, Russian and French. You can save time and work by
            <a href="http://nblocalization.netbeans.org/docs/HOWTOs/How-to-migrate-5.5.html">migrating 
            existing files from 5.0 to 5.5</a>. Part of the process is to create a translation memory
            that will simplify your team's work.
        </p>
        
        <h2>Looking for documentation in your language?</h2>
        
        <p>Did you know NetBeans.org also offers you <a href="https://netbeans.org/community/releases/">release notes, 
        install instructions,</a> and a great number of <a href="https://netbeans.org/kb/">tutorials</a> 
        in Japanese, Chinese, and Brasilian Portuguese?
        
        <p>Several other tutorials, for example the 
            <a href="https://netbeans.org/kb/docs/java/quickstart.html">NetBeans Quickstart</a>, 
            are available in even more languages, such as German, Greek, Georgian, Spanish, or Albanian.
            Remember to check the language pop-up menu at the top of each page, or browse
            the <a href="https://netbeans.org/sitemaps/www_map.html">site map</a> for a complete list.
        </p>    
            
        <h2>Related Links</h2>
            
            <ul>
                <li><a href="http://wiki.netbeans.org/FaqInternationalCommunity">Which language communities are there?</a>
                Meet developers speaking Chinese, Czech, French, German, Indonesian, Japanese, Portuguese, Russian, or Spanish.</li>
                <li><a href="https://netbeans.org/community/contribute/dreamteam.html">The NetBeans Dream Team</a> 
                has members from all over the world who are your local NetBeans representatives.</li>
                <li><a href="http://nblocalization.netbeans.org//">Join the NetBeans TranslatedFiles project</a> 
                and help us translate the IDE and documentation into your native language.</li>
                <li><a href="https://netbeans.org/projects/translatedfiles/lists">Join a TranslatedFiles mailinglist</a>
                in either Chinese, Spanish, Portuguese, German, Italien, Indonesian, French, or other languages.</li>
                <br/>
                <li><a href="http://nblocalization.netbeans.org//index_es.html">Spanish Translation Team homepage</a></li>
                <li><a href="http://java.net/projects/">The Panama JUG</a></li>
                <li><a href="http://avbravo.blogspot.com">The Spanish translators' blog</a></li>
                <li><a href="http://groups.google.com/group/traduccionnetbeans">The Spanish translators' mailinglist</a></li>
                <li><a href="http://wiki.netbeans.org/SpanishTranslation">The Spanish translators' wiki</a></li>
                <br/>
                <li><a href="http://nblocalization.netbeans.org//index_de.html">German Translation Team homepage</a></li>
                <li><a href="http://www.jugm.de/">German JUG Munich</a></li>
                <li><a href="http://planetnetbeans.org/de/index.html">German NetBeans bloggers</a></li>
                <li><a href="http://wiki.netbeans.org/GermanTranslators">The German translators' wiki</a></li>
                <li><a href="http://www.netbeans-forum.de">NetBeans-Forum.de</a></li>
            </ul>
            
            <p>Thanks to <a href="http://avbravo.blogspot.com">Aristides Villarreal</a> for introducing me to the work of the Spanish team.</p>
        </p>
        
    </body>
</html>
