﻿<HTML>
<HEAD>
<TITLE>Közreműködés a NetBeans projektben</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="hu">
</HEAD>

<BODY>

<h1>Közreműködés a netbeans.org webhely működésében</h1>

<P>Amint azt bizonyára Ön is tudja, a NetBeans egy <a href="../../about/os/">nyílt forráskódú projekt</a>. Ez azt jelenti, hogy miközben a vállalatok kereskedelmi termékeket hozhatnak létre az itt megjelenő fejlesztésekből, a webhely elsősorban közösség által működtetett szolgáltatás. Ha például olyan információkat tud közzétenni, amelyek valaki másnak segítséget nyújtanak, előnyökre tehet szert. Akár hibajelentésekről vagy fejlesztési kérelmekről legyen szó, mindenkinek javára válik, ha a javítások vagy fejlesztések telepítésével jobb eszközöket tud használni. A NetBeans projekt lényege, hogy Ön ül a vezetőülésben – ha nem lenne senki, aki ezt a szoftvert használja, nem lenne értelme a fejlesztéseknek.

<P>Az alábbi példákon keresztül bemutatjuk, hogyan vehet részt a NetBeans közösség munkájában, amelyből mindenki előnyöket kovácsolhat. Számos módon segítheti a projekt megvalósítását anélkül, hogy ténylegesen közreműködne a kód fejlesztésében!

<p><h2>Támogatási közösség, promóció</h2>
<ul>
<li><b>Részvétel a levelezőlistákon</b>
<br>A netbeans.org webhelyen különböző <a href="../../community/lists/top.html">levelezőlisták és hírcsoportok</A> találhatók, ahol a szoftver felhasználói a saját előnyükre fordíthatják mások tapasztalatait. Ahhoz, hogy a közösségi listák igazán hasznosak legyenek, szükség van az <i>Ön</i> megjegyzéseire is! Kérjük, küldje el már most észrevételeit – segítsen másoknak, ha tud!</li>



<p><li><b>Reklámozza a NetBeans rendszert!</b>
<br>Ha Ön NetBeans-felhasználó, terjessze a szoftverrel kapcsolatos ismereteit! Számos verseny indul az interneten, és sok fejlesztő még nem hallott a NetBeans rendszerről, vagy ami még rosszabb, hogy hallott róla, de téves információkkal rendelkezik, és vannak olyanok is, akik még nem hallottak a legújabb fejlesztésekről. Segítsen az információk terjesztésében – beszéljen a NetBeans erősségeiről vagy gyengeségeiről, a blogokról, a szakmai levelezőlistákról, a nyomtatásban megjelenő folyóiratokról, valamint a fórumokról..
NetBeans szoftverrel kapcsolatos cikket vagy tanulmányt talált (vagy írt)? 
<A HREF="https://netbeans.org/about/contact_form.html?to=2">Szívesen elolvassuk</a>!</li>
</ul>

<p><h2>Küldjön tartalmakat vagy fordításokat</h2>
<ul>
<p><LI><B>Vegyen részt a webhely tartalmának létrehozásában</B>
<BR>Kitalálta, hogyan lehet megoldani egy bonyolult használati esetet? 
<a href="http://wiki.netbeans.org/wiki/view/CommunityDocs">Az új tartalmakat, vagy a meglévő tartalomra vonatkozó frissítéseket</a> mindig szívesen fogadjuk! A GYIK és a HOGYAN LEHET...? cikkek nagyon hasznosak ugyanúgy, ahogy a képernyőről készült pillanatfelvételek és a Flash videók. Az alábbi hivatkozásokra kattintva további tájékoztatást olvashat:
<A HREF="web-content.html">Oktatóprogramok közzétételére</A>. Használja ezt az ingyenes<a href="https://netbeans.org/projects/www/downloads"> tárterületet a demók közzétételéhez</a>.
</li>

<p><LI><B>Fordítások, lokalizálások</B>
<BR>Szeretne részt venni a webhelytartalom vagy az IDE szoftver az Ön anyanyelvére való lokalizálásában! Mi és az Ön felhasználótársai nagyra értékelnénk a segítségét! További információkat a <A HREF="localise.html">Lokalizálás kezdő lépései</A> oldalon olvashat. Néhány közösségi tag korábban <a href="http://wiki.netbeans.org/wiki/view/FaqInternationalCommunity">különböző nyelvű fórumokat</a> hozott létre, és most segítik egymást a <a href="https://netbeans.org/kb/articles/learn-java.html#3">Java</a> és a NetBeans alkalmazás használatának megkezdésében.
</li>

<p><LI><B>Hírlevél szerkesztése, történetek küldése az Edge hírlevél számára</B>
<BR>A heti <A HREF="../news/newsletter/index.html">NetBeans-hírlevelet</A> a NetBeans projektben résztvevő önkéntesek állítják össze. Ha a levelezőlistákon követi az aktuális eseményeket, részt vehet a hírlevél szerkesztésében! A <A HREF="../news/newsletter/index.html">havonta megjelenő Edge</A> hírlevél folyamatosan keres olyan önkéntes szerzőket, akik interjúkat, cikkeket, partnerekről szóló ismertetőket írnak. Ha szeretne elküldeni egy történetet, <A HREF="https://netbeans.org/about/contact_form.html?to=2">lépjen velünk kapcsolatba</A>. Továbbá, ha a tartózkodási helyén megrendezendő olyan eseményről vagy konferenciáról hallott, ahol a NetBeans rendszert használják, <A HREF="https://netbeans.org/about/contact_form.html?to=2">küldje el nekünk megjegyzését</a>, és azt közzétesszük <a href="https://netbeans.org/community/news/calendar.html">eseménynaptárunkban</a>.
</li>
</ul>

<p><h2>Hibajelentések, írott kódok küldése</h2>
<ul>
<p><Li><B>Hibajelentés rögzítése</B>
<BR>A hibajelentések nagy segítséget nyújtanak a fejlesztők számára, és jelentős mértékben hozzájárulnak a projekt fejlesztéséhez! A <A HREF="../issues.html">hibajelentés rögzítésekor</A> szánjon egy kis időt arra, hogy reprodukálni tudja a problémát, és nagyon pontosan írja le a hibajelenséget.
</li>

<p><LI><B>Fejlesztési kérelem rögzítése</B>
<BR>Ha azt szeretné, hogy egy funkció szerepeljen az integrált fejlesztői környezetben, vagy épp azt szeretné, hogy ne szerepeljen, illetve ha úgy gondolja, hogy ki tudna fejleszteni egy bizonyos funkciót, tudassa velünk! A fejlesztési kérelmeket a <A HREF="../issues.html">hibakövetési rendszerben kell rögzíteni</A>, a hibajelentésekhez hasonlóan.
</li>

<p><LI><B>Kód és bővítménymodulok közzététele</B>
<BR>Ahogy azt már a fentiekben említettük, a NetBeans egy nyílt forráskódú projekt. A forráskód teljes egészében rendelkezésre áll, és ha van olyan funkció, amelyet fel kíván venni a rendszerbe, vagy olyan hiba, amelyet ki szeretne javítani, akkor lehetősége van arra, hogy ezeket a fejlesztéseket megvalósítsa. 
További információk <a href="http://platform.netbeans.org/tutorials/">a bővítménymodulok fejlesztéséről</a>, <A HREF="patches.html">a javítások közzétételéről</A>, valamint <A HREF="modules.html">a bővítménymodulok közzétételéről</A>. Tegye közzé bővítménymoduljait a <a href="http://plugins.netbeans.org/">Bővítmények portálján</a>, és olvassa el a közösség többi tagjától kapott visszajelzéseket!
</li>
</ul>

</body>
</html>
