﻿<HTML>
<HEAD>
<TITLE>Contribuirea la Proiectul NetBeans</TITLE>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<META NAME="description" CONTENT="How to make contributions to netbeans.org">
<link rel="stylesheet" type="text/css" HREF="../../netbeans.css">
<meta http-equiv="content-language" CONTENT="ro">
</HEAD>

<BODY>

<h1>Contribuirea la netbeans.org</h1>

<P>După cum probabil ştiţi, NetBeans este un <a href="../../about/os/">proiect open-source</a>. Acest lucru înseamnă că firmele pot crea produse comerciale din ceea ce este aici şi că acest proiect este condus în principal de comunitate. Acest lucru
înseamnă că, de exemplu, dacă puteţi contribui cu cunoştinţe care ajută
pe altcineva, veţi beneficia şi dvs. Fie că este vorba de rapoarte de bug-uri sau
solicitări de îmbunătăţiri, beneficiază toată lumea de instrumente mai bune după
implementarea remedierilor sau a îmbunătăţirilor. În esenţă, când este vorba despre
NetBeans, dvs. conduceţi - altfel spus, fără utilizatorii de software,
nu ar exista niciun motiv pentru toate acestea.

<P>Iată câteva modalităţi prin care vă puteţi aduce contribuţia la comunitatea NetBeans, care îşi culege propriile roade. Există multe moduri de a ajuta proiectul fără a contribui efectiv cu cod!

<p><h2>Suportul pentru comunitate, promovarea</h2>
<ul>
<li><b>Participaţi la listele de corespondenţă</b>
<br>Există câteva <a href="../../community/lists/top.html">liste de corespondenţă şi grupuri de ştiri</A> pe netbeans.org, unde persoanele care utilizează software-ul pot beneficia reciproc de expertiza celorlalţi. Pentru a fi cu adevărat utile, listele comunităţii au nevoie de aportul
<i>dvs.</i>!  Nu vă fie teamă să scrieţi - ajutaţi-i pe ceilalţi ori de câte ori puteţi!</li>



<p><li><b>Promovaţi NetBeans!</b>
<br>Dacă sunteţi utilizator NetBeans, vorbiţi despre asta! Pe piaţă există o concurenţă acerbă
şi mulţi dezvoltatori nu au auzit de NetBeans sau, mai rău, au
auzit, dar au înţeles greşit sau nu au auzit despre îmbunătăţirile
recente. Ajutaţi la răspândirea veştilor - vorbiţi despre punctele forte şi punctele slabe ale NetBeans
pe bloguri, pe liste de corespondenţă din domeniu, în reviste tipărite şi pe forumuri.
Aţi găsit (sau scris) un articol sau o recenzie legată de NetBeans? 
<A HREF="https://netbeans.org/about/contact_form.html?to=2">Ne-am bucura să o citim</a>!</li>
</ul>

<p><h2>Trimiterea de conţinut, traduceri</h2>
<ul>
<p><LI><B>Contribuiţi la conţinutul site-ului Web</B>
<BR>Aţi descoperit cum să rezolvaţi o problemă de utilizare complicată? 
<a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">Conţinut nou sau actualizări ale conţinutul existent</a> sunt întotdeauna binevenite! Articole ca Întrebări frecvente şi Îndrumări sunt foarte, foarte utile, precum sunt şi capturile de ecran şi filmele Flash. Pentru mai multe informaţii, consultaţi următoarele legături:
<A HREF="web-content.html">Îndrumări pentru contribuirea cu asistenţi de instruire</A>. Utilizaţi acest 
<a href="https://netbeans.org/projects/www/downloads">spaţiu Web gratuit pentru demonstraţiile cu care aţi contribuit</a>.
</li>

<p><LI><B>Traduceri, localizări</B>
<BR>Sunteţi interesat de eforturile de localizare a conţinutului site-ului Web sau chiar a IDE în limba dvs. maternă? Noi şi prietenii dvs. v-am aprecia ajutorul! Pentru informaţii, consultaţi
pagina <A HREF="localise.html">Începerea rapidă a localizării</A>. Unii membri ai comunităţii au creat deja
<a href="http://wiki.netbeans.org/wiki/view/FaqInternationalCommunity">forumuri în diferite limbi</a>, iar acum îi ajută pe ceilalţi 
    <a href="https://netbeans.org/kb/articles/learn-java.html#3">să se familiarizeze cu Java</a> şi NetBeans.
</li>

<p><LI><B>Editaţi buletinul informativ, trimiteţi articole pentru The Edge</B>
<BR> <A HREF="../news/newsletter/index.html">Buletinul informativ săptămânal NetBeans</A>
este creat de voluntari implicaţi în NetBeans - dacă
urmăriţi evenimentele curente de pe listele de corespondenţă, aţi putea edita un
buletin informativ! Buletinul informativ lunar <A HREF="../news/newsletter/index.html">Edge</A>
caută în permanenţă autori care să contribuie cu scrierea unui interviu, a unui articol, a unor profiluri de parteneri... dacă doriţi să trimiteţi un articol, vă rugăm
<A HREF="https://netbeans.org/about/contact_form.html?to=2">să ne contactaţi</A>. De asemenea, dacă aţi auzit despre un eveniment din zona dvs., unde este utilizat NetBeans, 
<A HREF="https://netbeans.org/about/contact_form.html?to=2">trimiteţi-ne o notă</a>
şi o vom promova în <a href="https://netbeans.org/community/news/calendar.html">calendarul nostru de evenimente</a>.
</li>
</ul>

<p><h2>Trimiterea rapoartelor de bug-uri, scrierea codului</h2>
<ul>
<p><Li><B>Completarea unui raport de bug</B>
<BR>Rapoartele de bug-uri sunt foarte utile dezvoltatorilor şi reprezintă un mod extraordinar de a contribui la proiect! Amintiţi-vă că aveţi nevoie de un pic de timp când
<A HREF="../issues.html">completaţi un raport de bug</A> - asiguraţi-vă că puteţi reproduce problema şi fiţi foarte explicit în descriere.
</li>

<p><LI><B>Completarea unei solicitări de îmbunătăţire</B>
<BR>Dacă este ceva ce aţi dori să vedeţi în IDE şi nu există sau
ceva ce vă puteţi imagina îmbunătăţit, comunicaţi-ne! Solicitările de îmbunătăţiri
trebuie <A HREF="../issues.html">completate în sistemul de urmărire a problemelor</A>, lucru valabil şi pentru bug-uri.
</li>

<p><LI><B>Contribuirea cu cod şi module de tip Plugin</B>
<BR>După cum s-a menţionat mai sus, NetBeans este un proiect open-source - întregul cod sursă este disponibil, iar dacă există o caracteristică pe care doriţi s-o vedeţi sau un
bug pe care doriţi să-l remediaţi, puteţi face ca aceste lucruri să se întâmple. 
Puteţi afla mai multe detalii despre <a href="http://platform.netbeans.org/tutorials/">dezvoltarea modulelor de tip Plugin</a>,
<A HREF="patches.html">contribuirea cu patch-uri</A> şi
<A HREF="modules.html">contribuirea cu module de tip Plugin</A>. Publicaţi-vă modulele de tip Plugin în <a href="http://plugins.netbeans.org/">Portalul de Plugin-uri</a>
şi obţineţi feedback de la membrii comunităţii!
</li>
</ul>

</body>
</html>
