﻿<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3c.org/TR/1999/REC-html401-19991224/loose.dtd">
<HTML>
	<HEAD>
  <META http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <meta HTTP-EQUIV="Content-language" CONTENT="nl">

  <TITLE>Bijdragen aan netbeans.org</TITLE>
  <META content="Hier zijn enkele manieren hoe je kan bijdragen aan de NetBeans gemeenschap." name="description">
  <LINK href="../../netbeans.css" type="text/css" rel="stylesheet">
  <META content="NBUSER" name="AUDIENCE">
  <META content="ARTICLE" name="TYPE">
  <META content="GENERAL" name="TOPIC">
  </HEAD>
	<BODY>

<H1>Bijdragen aan netbeans.org</H1>
<p>Zoals je misschien al weet is NetBeans een <A href="../../about/os/index.html">open source project</A>.
Dat betekent dat hoewel bedrijven er commerciele producten op kunnen baseren,
		het toch voor het grootste gedeelte gedaan wordt door de gemeenschap in zijn
		geheel. Wat dat betekent is dat je bijvoorbeeld je kennis kan delen, en
		daardoor iemand anders kan helpen, hierbij ben jezelf ook gebaat. Als het een
		bug report&nbsp; of een vraag voor verbetering is, dan profiteert
		iedereen&nbsp;van de doorgevoerde verbeteringen of aanpassingen. In principe, als
		het over NetBeans gaat, zit je zelf in de bestuurdersstoel - zonder mensen die
		de software zouden gebruiken zou er voor dit alles geen reden zijn.

<p>
		Hier zijn enkele manieren hoe je kan bijdragen aan de NetBeans gemeenschap, elk
		met hun eigen beloning:

 <p>
 <UL>
					<LI>
						<B>Participeren op Mailing Lijsten</B>
						<BR>
 Er zijn verscheidene <A href="../../community/lists/top.html">actieve mailing lijsten&nbsp;</A>
 en nieuwsgroepen op netbeans.org, waar mensen die de software gebruiken van elkanders kennis kunnen profiteren. Om echt
 bruikbaar te zijn vereisen de lijsten <I>jouw</I> input! Wees niet bang om een
						bericht in te sturen - help anderen wanneer je kan, stuur je eigen vragen,
						commentaar en idee&euml;n in wanneer jou het uitkomt.

<P><LI><B>Stuur een&nbsp;Bug Report in</B>&nbsp;
						<BR>Bug reports zijn zeer waardevol voor ontwikkelaars, en een goede manier om bij
						te dragen aan het project! Denk aan de volgende zaken als je een&nbsp;
            <A href="../../community/issues.html">bug report instuurt</A> - wees er zeker van dat je de bug kan reproduceren,
						en geef een zeer expliciete beschrijving van je probleem.

<p><li><B>Stuur een&nbsp;Enhancement Request in</B>
						<BR>
						Als je iets in de IDE zou willen zien, of iets dat verbeterd kan worden, laat
						het ons dan weten! Enhancement requests moeten worden&nbsp; <A href="../../community/issues.html">
							ingestuurd met behulp van het&nbsp;issue tracking systeem</A>, hetzelfde
						geldt voor&nbsp;bugs.

<p><li><B>Draag bij aan de inhoud van de Website</B>
						<BR>
						Nieuwe inhoud en updates voor bestaande inhoud zijn altijd welkom!
						Artikelen zoals FAQs en HOWTOs zijn zeer handig,
						alsmede screenshots. Zie de volgende links voor meer informatie:
 <A href="../../community/guidelines/www-guide.html">Bijdragen aan HTML voor netbeans.org</A>.

<p><li><B>Vertalingen, Localizeringen</B>
 <BR>
  Ben je geinteresseerd in het localizeren van de inhoud van de website, of in
  het localizeren van de IDE zelf, in je eigen taal? We zouden graag je hulp hebben! Zie de
  <A href="localise.html">Localisation Quick Start</A> pagina voor meer informatie.



<p><li><B>Edit de&nbsp;Nieuwsbrief, Stuur verhalen in voor&nbsp;The Edge</B>
						<BR>
						De wekelijkse <A href="../../community/news/newsletter/index.html">
							NetBeans Newsletter</A> is samengesteld door de vrijwilligeres die
						bijdragen aan NetBeans - als je de huidige ontwikkelingen op de
mailinglijsten volgt, dan zou je de nieuwsbrief kunnen editen! Voor de <A href="../../community/news/newsletter/index.html">
maandelijkse Edge</A> nieuwsbrief zijn we altijd op zoek naar
						auteurs voor interviews, artikelen, partner spotlights ... als je
						geinteresseerd bent om een verhaal in te sturen,
<A href="https://netbeans.org/about/contact_form.html?to=2">neem dan contact met ons op</A>.

<p><li><B>Bijdragen aan Code</B>
						<BR>
						Zoals reeds eerder vermeld werd, is NetBeans een&nbsp; open-source project - alle
						source code is beschikbaar, en als je graag een bepaalde feature wil
hebben, of je zou een bug verbeterd willen zien, dan heb je zelf de mogelijkheid
om dat te laten gebeuren. Zie de secties over het <A href="patches.html">bijdragen
van patches</A> en het <A href="modules.html">bijdragen van modules</A> voor meer
informatie.

<LI><B>Blijf Alert</B>
						<BR>
						Heb je een artikel gevonden over NetBeans? Stuur ons een link. Weet je van een
						module die werkt met NetBeans, en je denkt dat het de gemeenschap zou
						interesseren? Laten we het dan in de module catalogus opnemen. Weet je van een
						bijeenkomst waar NetBeans zou moeten zijn? We kunnen het op onze agenda
						zetten. Help ons de NetBeans gemeenschap te laten groeien en te
						onderwijzen, en deel je kennis!
					</LI>
				</UL>

</BODY>
</HTML>
