<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <link rel="stylesheet" type="text/css" href="../../../netbeans.css"
 media="screen">
  <meta name="author" content="Tinuola Awopetu">
  <meta name="keywords"
 content="NetBeans IDE, NetBeans Platform, NetBeans Dream Team, Vincent Brabant">
  <title>NetBeans Dream Team Interview: Vincent Brabant</title>
</head>
<body>
<h1>Series: Meet the Dream Team Members<br>
</h1>
<i>(In January 2007, we announced the 11 charter members of the <a
 href="http://wiki.netbeans.org/wiki/view/NetBeansDreamTeam">NetBeans
Dream Team</a>, a community-oriented group of highly skilled NetBeans
users devoted to promoting NetBeans and working on the NetBeans
project. In these interviews discover who they are, why they are
passionate
about NetBeans and what goals they have for the NetBeans project.)</i><br>
<br>
<br>
<h1>Vincent Brabant</h1>
<img alt="Vincent Brabant"
 src="../../../images_www/articles/dreamteam/vincent-brabant.jpg"
 style="width: 185px; height: 204px;" align="left" hspace="10"
 vspace="5">
<h4>Congratulations on becoming a member of the Dream Team.</h4>
It's a dream that became reality. :-)<br>
<br>
<h4>Do you have any immediate projects you want to tackle as a Dream
Team member?</h4>
1. Do a NetBeans presentation in French at Sun Tech Days in Paris.<br>
2. Translate the <a
 href="https://netbeans.org/kb/articles/NBFieldGuide.html">NetBeans
book</a> into French, if possible.<br>
3. Provide more Flash demos.<br>
<br>
<h4>You've been an active NetBeans community member for over four
years, what aspects of NetBeans's evolution have stood out for you?</h4>
What I like in NetBeans is the out-of-the-box experience. Once this
installation is done, I am instantly productive. It is not necessary to
install a lot of other modules to be able to work. And when I want to
go further I can install a Pack that works nicely together with the
IDE. But If I want to extend it, it's also possible thanks to
<a href="http://www.nbextras.org/">nbextras.org</a>. But there are some
things that are missing in NetBeans, like the
ability to import a EAR or a War or a JAR and transform it into a
project, and run it. It's very useful when you want to test some
open-source project. <br>
<br>
Also, I really have no idea how many people are
working for NetBeans, but it seems like it's an army. When you look at
the work done last year it's just incredible how productive they have
been.<br>
<br>
The fact that NetBeans projects are driven by Ant (or by Maven, if you
use the mevenide) is also really nice stuff. You have a lot of power
in your
hands thanks to this approach. For example, if you want to run some
code like
PMD/CheckStyle each time you compile your project, it's possible.
If you want to add CodeCoverage each time you are testing your
application, it's possible.
<br>
<br>
<h4>As a result of your localization efforts, have
more French-speaking developers switched to NetBeans or expressed more
interest in the IDE?</h4>
Yes, certainly. I received a lot of mail saying “Thank You” for&nbsp;
translating NetBeans IDE Field Guide draft chapters, and also for
French-only tutorials and demos. But I was more happy when I saw
people starting to contribute tutorials in French. The only problem was
that French-speaking users were not going to <a
 href="http://fr.netbeans.org">fr.netbeans.org</a>.
So, I decided to also go where French-speaking Java developers were:
<a href="http://developpez.com">developpez.com</a>. The traffic there
is much larger.<br>
<br>
What I would like to see is a history of people that decided to switch
to Netbeans after looking at my demos. Someone I met at Javapolis told
me he was using Eclipse, but when he saw my demos, he decided to try
them and finally he switched to NetBeans.<br>
<br>
<h4>Why aren't French-speaking developers going to fr.netbeans.org?</h4>
I really don't know. Once, I asked the question on the nbdiscuss_fr
mailing list; in general, people prefer to look at the official
NetBeans website. But the link to fr.netbeans.org is too hidden. When
people see that a "Choose Page Language" option exists at the top of
netbeans.org they are taken to the <a
 href="https://netbeans.org/index_fr.html">French index</a> and not
to fr.netbeans.org<br>
<br>
<h4>In an old <a
 href="http://tempwww.netbeans.org/community/articles/interviews/vincent_brabant.html">interview</a>,
you said NetBeans needed to appeal to
non-English developers; do you still feel the same?</h4>
Yes, I said that, and I continue to think it's true. The
<a href="http://www.sun.com/aboutsun/pr/2007-01/sunflash.20070131.1.xml">Multilingual
releases</a> are really nice stuff. The <a
 href="https://netbeans.org/community/articles/brazil55-release.html">Brazilian</a>
guys did a very good job. And Maxym Mykhalchuk, who translated NetBeans
into <a href="https://netbeans.org/index_ru.html">Russian</a>, did
a huge job. He was nearly alone in that translation
effort. <br>
<br>
<h4>What advise can you offer others who want to promote NetBeans in
their own language?</h4>
1. Start a blog and ask to add it on <a
 href="http://planetnetbeans.org/">Planet NetBeans</a>.<br>
2. Write Flash demos. (Start with Wink; you can later move to another
demo tool like Macromedia Captivate.)<br>
3. Visit the <a href="http://nblocalization.netbeans.org//">Translation
Project</a> pages.<br>
4. Join a Java user group or site in your language, and be active there
as a NetBeans evangelist.<br>
<br>
<h4>How can the various language communities work closer together?</h4>
We are already working closer via the Translation Project pages. Maybe
we could also share other resources and translate them, if needed.<br>
&nbsp;<br>
<h4>How often do you still contribute to the NetBeans site?</h4>
Not a lot in fact. Sometimes, I push Wink demos on the NetBeans
website. But I&nbsp; concentrate mainly on the French NetBeans
community through
developpez.com, which is NetBeans oriented. There are more advantages
to this group: First, the website is very active and the audience is
larger than the one I could expect on NetBeans itself. Second, there is
a team of French-speaking writers, so I am not alone anymore. I have
support for announcements, blogging, technical reviews, and more. &nbsp;<br>
<br>
<h4>NetBeans 6.0 will be released by the end of this year. How do you
think it’ll
be received by developers and the IDE market?</h4>
The focus of NetBeans 6.0 is mainly with the editor: tips, code
completion, code generator, inline refactoring, enhanced visual editor,
refactoring with Jackpot, etc. And thanks to that, the gap between
NetBeans's editor and those of other IDEs will be reduced. A lot of
people like Matisse, and they switched to NetBeans as a result. But
they continue to use another editor to edit their source code.
With NetBeans 6.0, I am pretty sure they will use the NetBeans
editor, and stop using other editors. And I think a lot of people will
join the NetBeans community when NetBeans
6.0 is released.<br>
&nbsp;<br>
But I would like to say the following to the NetBeans team: Oh please,
oh please, do something for the edition of guarded block code. For
example, adding context around the text area instead of seeing an
empty text area. And also be sure that code completion will work
correctly in the guarded block code. <br>
<br>
Something else I see is the fact that a new book about development of
NetBeans modules will be published this year. I am pretty sure we will
see an explosure of NetBeans modules once the book will be available.
We are already
seeing more and more modules since the release of NetBeans 5.0. But I
expect more modules after the publishing of the book.<br>
<br>
<h4>Which is the sexier language: French or Java?</h4>
French. Because it's not a computer language; it's a human language.
And I prefer speaking to people than to computers.<br>
<br>
<div style="text-align: right;"><span style="font-style: italic;">(February
2007)</span><br style="font-style: italic;">
</div>
<h2>More Dream Team Profiles</h2>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-bien.html">Adam
Bien</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-bold.html">Emilian
Bold</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-chandler.html">Wade
Chandler</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-giudici.html">Fabrizio
Giudici</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-plewe.html">Joerg
Plewe</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-senger.html">Vinicius
Senger</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-silva.html">Edgar
Silva</a><br>
<a
 href="https://netbeans.org/community/articles/interviews/dreamprofile-urrutia.html">Ibon
Urrutia</a><br>
<br>
</body>
</html>
