<html>
<head>
<title>Interview with NetBeans Community Award 2006 Winner Ram&oacute;n Ramos</title>
<meta name="description" content="Interview with NetBeans Community Award 2006 Winner Ram&oacute;n Ramos">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
<meta name="Author" content="Ruth Kusterer">
</head>

<body>
<h1>Interview with NetBeans Community Award 2006 Winner Ram&oacute;n Ramos</h1>

<p><TABLE><tr>
<td><a href="http://www.jroller.com/page/ramlog"><img 
src="../../../images_www/articles/interviews/ramon-ramos.png" class="align-right"/></a></td>
<td width="10">&nbsp;</td>
<td><p>Ram&oacute;n Ramos lives and studies in Germany and is a long-time fan of NetBeans IDE.
He uses the NetBeans platform for student projects and is an enthusiastic Module developer
and <a href="http://www.jroller.com/page/ramlog">blogger</a>.</p></td>
</tr>
</TABLE></P>

<h3>Ram&oacute;n, you just won the community award 2006 for your contributions, what was your
first reaction? </h3>
 
<p>I read about my nomination in Roman's web log. That was good news. 
Then I thought, wow, can I win? To be honest, I really wanted to be among the winners.
And when I later saw luminaries like  Wade Chandler and Tom Wheeler
being nominated, too, I thought, uh-oh, this is going to be tough...

<p>When I heard my fellow community members had elected me 
one of the winners, that really made my day. Thank you!</p>

<h3>How long have you been using the NetBeans IDE? What got you hooked?</h3>

<p>I used NetBeans for the first time at a student job. 
I think it was about 2001, there was a
Forte 1.0 Release Candidate and I think there also was a NetBeans release at the
same time, I'm not sure anymore. Later I got a new job where I worked from home
a lot. During that time, I didn't use NetBeans, until
late in 2005, when I finally bought myself a new PC and I chose to base one of my
student projects on the NetBeans platform. 
This way I gained experience und got hooked.

<h3>Tell us about the plug-ins you wrote!</h3>

<p>I have written a couple of small plug-ins: 
My first module was <a href="http://www.jroller.com/page/ramlog/20060227">Web Search</a>, a plug-in 
for searching a word or phrase selected in the Editor in a web search engine. 
I also wrote a <a href="http://www.jroller.com/page/ramlog/20060430">Jode/Jad Decompiler integration module</a>,
and a simple <a href="http://www.jroller.com/page/ramlog/20060402">local history module</a>, 
and some more.

<p>Apart from that, I updated the old 
<a href="http://www.jroller.com/page/ramlog/20060410">AspectJ module for NetBeans 5.0</a>.
AspectJ is an <a href="http://en.wikipedia.org/wiki/Aspect-oriented_programming">aspect-oriented</a> 
extension to the Java programming language.

You can expect the now renamed AspectJ open-source project on sourceforge
(<a href="http://aspectj-netbeans.sourceforge.net/">http://aspectj-netbeans.sourceforge.net/</a>) 
to become active again soon.
This will give all the other interested community members the opportunity to contribute again
to this project and improve AspectJ support in NetBeans.

<p>All of these modules can be installed from my update center:
http://people.freenet.de/ramon.ramos/nb/updates.xml</p>


<h3>Where do you get ideas for new plug-ins?</h3>


<p>NetBeans gave me the opportunity to develop something that is useful for people.
Since I learned Java some years ago, I wanted to program something useful in
Java &mdash; but I couldn't think of anything that had not been done before. </p>

<p>So when I came back to NetBeans, I also began to read related web sites, 
mailing list posts, etc. This is how I found out some things that NetBeans was lacking but 
which seemed pretty easy to implement. Those things were
useful and I really wondered why they weren’t already there. So over the
holidays, I just went and implemented them. I was glad to see 
there were some features I could contribute to NetBeans.</p>

<p>Then, there are some <a href="http://www.javalobby.org/java/forums/t17999">(now old) feature wishlists for NetBeans</a> 
that I used as additional source of inspiration. I also took a look at the features in other IDEs to see what
they have that can be ported. I am also keeping track of feature
requests in mailing lists, and so on.</p>

<h3>What are your resources? </h3>
    
<p>
At first, I went through the <a href="http://platform.netbeans.org/tutorials/">tutorials</a>. 
They are really nice. Other resources are the <a href="http://wiki.netbeans.org/wiki/view/NetBeansDeveloperFAQ">Developers FAQ</a>, 
the <a href="https://netbeans.org/download/dev/javadoc/">API documentation</a> and javadocs, and then of course the
<a href="https://netbeans.org/community/lists/">mailing lists</a> 
with their incredibly helpful communities. Now and then, 
I also take a look at the NetBeans sources themselves.


<h3>Which IDE features help you most?</h3>

<p>Easy answer: The module development wizards. They are very well done and I'm looking forward
to seeing more of that. Way to go!</P>

<h3>If you could improve one thing about NetBeans, what would that be?</h3>
    
<p>I'd like to see more tutorials that focus on letting people enhance NetBeans itself. </p>


<h3>Which tutorial would you like to read next?</h3>

<p>I would like to read a very fat book about platform development.

<h3>Ram&oacute;n, thanks for the interview!</h3>
</body>
</html>



