<html>
<head>
<title>Interview with Collin Doering - Our youngest NetBeans user?</title>
<meta name="description" content="Interview with Collin Doering - Our youngest NetBeans user?">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
</head>

<body>


<h2><a name="Interview_with_Collin_Doering_a"> </a><a name="Interview_with_Collin_Doering_a_"> </a> Interview with Collin Doering - Our youngest NetBeans user? </h2> 

<table><tr><td>
<p><img src="../../../images_www/articles/interviews/collin.png" alt="Collin Doering" class="align-left">
</p><h3><a name="Question_1_Collin_can_you_tell_u"> </a> Question #1: Collin, can you tell us about yourself - who you are and what you do? </h3>
<p>
My name is Collin Doering; I am 15 years old and from a small
town about an hour away from Toronto, Ontario in Canada. I am still in
high-school but my favorite hobby, and hopefully future job, is Computer
Science. I specifically enjoy programming in Java but do a little of
C++,C.
</p></td></tr></table><p>
</p><h3><a name="Question_2_When_did_you_start_wi"> </a> Question #2: When did you start with programming? Tell us something about your previous experiences with software development. </h3>
<p>
I started programming in grade 7 with QBasic, but got bored very fast
because I could not do very much with it. Then I switched to a
programming language called Turing made by Holt Software. 
</p><p>
In the spring of grade 8, I heard about Java; after some investigation
I found this was the language for me. At that time I often came home
from school and would sit down for four to six hours of learning and
programming. After a few months I was able to move onto Swing
applications - I created a simple
Notepad and programmed a Diary for my little sisters. Over my grade 9
to 10 summer I
worked full time. Then mid-way through the summer I started designing
the new Diary version 2. This was when I switched to NetBeans. I had
worked with it a little, as well as Eclipse, but I did not understand
all of its features. At this time I also bought my first Java book.
</p><p>I skipped a grade in Computer Science, therefore
putting me in a grade 11/12 split. By then I was a fulltime NetBeans
user and promoted it to my classmates. I mentioned it to my teacher
but he said he would just stick with the plain editor. I bought two
more Java books, a UML design book and a C++ book. One thing that I
spent a lot of time looking into was how the Java APIs works; I learned
some of the design patterns used and how
everything fit together. I learned more on my favorite topic:
inheritance. Now I am half way done with grade 10 and turn 16 in May.
</p><p>
</p><p>
</p><h3><a name="Question_3_Why_is_NetBeans_your"> </a><a name="Question_3_Why_is_NetBeans_your_"> </a> Question #3: Why is NetBeans your favorite IDE for Java development? What are your favorite features in NetBeans? </h3>
<p>NetBeans is my favorite IDE for Java development because,
basically, every tool is available to me in one "Super Powered" IDE. I
would have to say my favorite feature of NetBeans IDE 5.0 is definitely
Project Matisse. It is incredible how much development time it
saves. I also like the new refactoring and the new CVS support. The
editor is faster in this version, which is also nice. One newly
discovered favorite feature is the new module support.
This has become my new hobby: programming NetBeans modules and learning
the NetBeans Platform architecture and API.
</p><p>
</p><h3><a name="Question_4_What_features_would_y"> </a> Question #4: What features would you like to see improved in NetBeans? </h3>
<p>
I would like to see UML support in the next version of
NetBeans; I was almost thinking of programming one myself. I would
also like to see Java Studio Enterprise 8, Java Studio Creator and Sun
Studio come into NetBeans, so you can do any type of development.
</p><p>
</p><h3><a name="Question_5_Did_you_try_any_other"> </a> Question #5: Did you try any other Java IDEs and if yes, what do you think about them? </h3>
<p>
Yes, I have tried the additional IDEs: Eclipse 3.1, Java
Studio Creator, and Java Studio Enterprise 8. Although Java Studio
Creator and Java Studio Enterprise 8 are build on top of NetBeans
(version 4.1), I still included them in this list because they are all
unique IDEs. 
</p><p>
First off, when I tried Eclipse 3.1, I did like it but
one thing I did not like was the Look and Feel. Besides that, there are
lots of "plugins" for eclipse and that is good, but kind of a pain,
because a lot of them cost money. One thing I want NetBeans to do 
is stay Open-Source and free. 
</p><p>
Java Studio Creator is great but it is
directed at J2EE programming which is not my specialty. Java Studio
Enterprise 8 was very appealing because it has a UML module. I tested
it and I found some parts of the module "unstable" and annoying like
some of the code generation and some visual formatting errors. 
</p><p>
So I went NetBeans!!
</p><p>
</p><p>
</p><img src="../../../images_www/articles/interviews/collin-desk.jpg" alt="Collin Doering" class="align-right" height="300">
<h3><a name="Question_6_How_did_you_learn_Jav"> </a> Question #6:
How did you learn Java - do you read books or do you attend any
courses? Do you visit Java conferences? What would you recommend is the
best way to learn Java? </h3>
<p>
I learned Java by a few methods: one is a lot of reading; tutorials and
many books. Recently I took the day off school to go to the NetBeans
World Tour in Toronto. This was a very nice learning experience.
</p><p>
I especially like the servlet and midlet communicating with one another, 
the amount of RAM being used on the server. One of my favorite parts
of the conference
was when I got to meet "The Father of Java", James Gosling.
</p><p>
I wanted to go to all the Sun Tech Days but I was not able to. Next year
I already am planning on going to every one and trying for my first
certification exam.
</p><p>
I would say the best way to lean Java would be to read lots and make
sure you understand what is happening in the background (the API and such).
</p><p>
</p><h3><a name="Question_7_I_know_you_re_keeping"> </a> Question #7: I know you're keeping a blog at <a href="http://rekahsoft.blogspot.com/" target="_top">http://rekahsoft.blogspot.com</a> and you wrote you're planning to contribute to NetBeans. What are your plans for the contributions? </h3>
<p>
I have already started with a "Time Management" Module. The
developer will create "tasks" and attach them to certain file/s. When
they start the IDE, my module will keep track of how much time they
spend in each file. If the IDE is minimized all timers are paused. The
timer will only count time for the document that is correctly open and
is the selected tab. 
</p><p>
This module will allow developers to keep track
of their time. When I have more experience developing under the
NetBeans platform, I would like to contribute to other projects. One I
had in mind was a UML project.
</p><p>
</p><h3><a name="Question_8_I_m_pleasantly_surpri"> </a> Question #8:
I'm pleasantly surprised by your activity. You must have already
studied some of the NetBeans APIs - what do you think about them? Are
they easy to understand? Is there enough documentation? </h3>
<p>
I very much enjoy the <a href="https://netbeans.org/download/dev/javadoc/">NetBeans APIs</a>. They are very interesting.
They are pretty simple to understand and for NetBeans 5.0 there is
plenty of <a href="https://netbeans.org/kb/trails/platform.html">documentation and code examples</a>.
</p><p>
</p><h3><a name="Question_9_I_read_your_interesti"> </a> Question #9: I read your interesting story with your Java teacher. Tell us what happened. </h3>
<p>
First off, my Java teacher is a great guy and his circumstance
is a hard one to fill. He has to create lessons that people just
starting Java can understand, but that don't bore students who already
know a bit or more than him in my case. So because of this, I am very
bored in this class and spend most of my time programming my own
things or helping the 12 grade students. I am known to them as their "Walking
Documentation". My teacher is a math teacher and does not have a
degree in programming at all. So when it comes to mathematical logic
in programs he is very good. He has said that I am better at Java and
Programming; we even sometimes joke about it.
</p><p>
</p><h3><a name="Question_10_I_also_read_on_your"> </a><a name="Question_10_I_also_read_on_your_"> </a> Question #10: I also read on your blog that you recommend people to switch to NetBeans. Why do you recommend it? </h3>
<p>
Collin: I would recommend people to switch to NetBeans because of the
power, stability and saved time in NetBeans. Every tool is available
even to students like me and if there are not they come out very soon
or your could even create them yourself.
</p><p>
</p><h3><a name="Question_11_Is_there_anything_el"> </a> Question #11: Is there anything else you'd like to say - any message for the NetBeans community? </h3>
<p>
Collin: Keep up the good work; you guys are doing a phenomenal job!!
Even though I am young, don't count me out now or in the future!!
</p>

</body>
