IMPORTANT: Experience development with Idea

Hi,

The need for writing this pos has arisen from my recent and past experience
of using Idea.
For the very first time I used Idea it was shock to me. IDE seemed to be so
intelligent, so
brilliant, it just guessed the way I worked. Hiding toolwindows, intentions,
inspections, smart
refactorings and all that stuff was clear a huge advantage of Idea over
other competitors.

As time passed, Idea added many MINOR, not revolutional features and
competitors started
to follow this style of IDE. For now, Eclipse seems to be the most advanced
competitor and in
fact they've come pretty darn close to what we have in Idea (ok. I agree,
some of the features
are way too complicated, not so smart, but, for the hell, they exist and can
be used for free).

Time for next step, to prove that Idea is clearly the leader among Java
IDEs.
IMHO what makes Idea so cool is its friendliness. We can improve this in
many, many ways.

It all started some time ago. In recent builds we have the following
features:
- tracking user decisions to intelligently suggest most commonly used
methods
- intelligent progress window that shows you ways in which you can improve
your work with Idea - in the meanwhile of
time consuming operations
- we have Productivity Guide which show what Idea features are used and how
often (although it seems to incorrectly monitor feature usage, as for me)

But, lately, not much power is devoted to these features. Not very many
users vote for that. Why?
That's because we, EAP'ers have mastered IDEA in parallel with their
creators. We test and use every new feature, so for whom this features are?

For all other people, createing a 'mass' of Jetbrains customers. In my
company, we have recently bought several Idea copies. Most of the people
migrated from JBuilder and Eclipse to Idea with no problem. But with
current, limited help, they have no chance to master Idea in the way I have
mastered it.

For me, the following steps are to be performed to improve existing
situation (then we can talk about new features):
- tracking user should be improved to support other kind of autocompletion,
not only methods
- tips list in intelligent progress window should be updated to include all
the tips of the day from Idea 4.0 and more, so that use can learn while
waiting
for time consuming operations
- productivity guide should work as expected and feature list should be much
longer, mentioning not only 'killer features' but these nice small things
that
make Idea so cool IDE to use

Then come new features. I believe in future of Idea as INTELLIGENT IDE. This
mean much more that Idea has to offer novadays.
This means learning from the user about his habits, code conventions, most
commonly used things such as:
- learning code style from live code (you point Idea to live code - a
project, and Idea 'learns' code style and adjusts settings to match habits
in the code)
- smart code templates (Idea learns your commonly used code constructs and
stores them in the form of dynamic templates, for eg. you are used to write
for loop to iterate over collection...)
- going hand in hand with programmer to point out mistakes and things that
can be possibly errors - with power of InspectionGadgets Idea should be a
little
more invasive when helping programmer - I would love a toolwindow with
inspections at current cursor position, which is visible all the time
- a way to define dependency constraints and when you try to break 'em -
Idea should cry very loudly. I am talking about 'compile-time aspects' -
checks that
can be fired to check dependencies and other constraints
- updating CVS plugin so that it can be comparable with Eclipse's - in fact
I think that CVS integration in Eclipse is the reference for all other...
- Idea should track user gestures and suggest more convenient way to do
things (if you for examples did extract methid by choosing it from menu,
Idea should point in popup - that you can use context menu or shortcut key).

Enough for 5.0?
I'll add:
- J2EE generic Open API (without weblogims as Hani says)
- full JSP 2.0 support
- more IG quickfixed - I think there plenty of inspections that can have
quick fixed builtin.

Welcome to discussion, EAPers and Jetbrainers.



--
---
Michal Szklanowski
Java Architect


37 comments
Comment actions Permalink

Hello, Michal!
You wrote on Mon, 24 May 2004 23:59:58 +0200:

MS> As time passed, Idea added many MINOR, not revolutional features and
MS> competitors started to follow this style of IDE. For now, Eclipse
MS> seems to be the most advanced competitor and in fact they've come
MS> pretty darn close to what we have in Idea (ok. I agree, some of the
MS> features are way too complicated, not so smart, but, for the hell,
MS> they exist and can be used for free).

Oh... please no more again :) Are you lookking for 4.0 features?
That about GUI Designer, Generics support (this is only IDE that can handle
generics so good), ANT 1.6, Modularity, Productivity Guide, a lot of new
Refactorings?
And, please, look at M9 Eclipse to see that Eclipse is freezed...

MS> But, lately, not much power is devoted to these features. Not very
MS> many users vote for that. Why?

Did you see change log?

MS> That's because we, EAP'ers have mastered IDEA in parallel with their
MS> creators. We test and use every new feature, so for whom this
MS> features are?

For you!

MS> For all other people, createing a 'mass' of Jetbrains customers. In
MS> my company, we have recently bought several Idea copies. Most of the
MS> people migrated from JBuilder and Eclipse to Idea with no problem.
MS> But with current, limited help, they have no chance to master Idea
MS> in the way I have mastered it.

No help is requires for development IDEA. Just start type with IDEA and you
will see how it work... in all other IDE you realy need for help!
BTW, Productivity Guide is realy powerfull feature!

MS> Enough for 5.0?
MS> I'll add:
MS> - J2EE generic Open API (without weblogims as Hani says)
MS> - full JSP 2.0 support - more IG quickfixed - I think there plenty
MS> of inspections that can have quick fixed builtin.

No comment...
Are you realy belive that this features for 5.0?

But i agree IDEA must have improvements in XML/JSP support.

Thanks!
Alexey Efimov - Java Developer
Tops BI
http://www.topsbi.com


0
Comment actions Permalink

Michal Szklanowski wrote:

Hi,



For me, the following steps are to be performed to improve existing
situation (then we can talk about new features):
- tracking user should be improved to support other kind of
autocompletion, not only methods
- tips list in intelligent progress window should be updated to include
all the tips of the day from Idea 4.0 and more, so that use can learn
while waiting
for time consuming operations
- productivity guide should work as expected and feature list should be
much longer, mentioning not only 'killer features' but these nice small
things that
make Idea so cool IDE to use


I can imagine the advertising: "Our 4.0 version is packed with features. Pay
$500 and they are yours!". "Our 5.0 version will help you to discover all
the features of 4.0. Just pay $XXX and it is yours!" :))


Then come new features. I believe in future of Idea as INTELLIGENT IDE.
This mean much more that Idea has to offer novadays.
This means learning from the user about his habits, code conventions, most
commonly used things such as:
- learning code style from live code (you point Idea to live code - a
project, and Idea 'learns' code style and adjusts settings to match habits
in the code)


Very good idea, IMO. And not too difficult to implement at all.

- smart code templates (Idea learns your commonly used code constructs and
stores them in the form of dynamic templates, for eg. you are used to
write for loop to iterate over collection...)


We have to think more about this one. Duplicates analysis that we already
have may help to discover such stuff, but IMO there is a problem with Live
Templates as a way to express certain idioms: they do not suppor round-trip
and once they are expanded, they are lost. Maybe something in the lines of
Alain Ravet Camouflage plugin may help?

- going hand in hand with programmer to point out mistakes and things that
can be possibly errors - with power of InspectionGadgets Idea should be a
little
more invasive when helping programmer - I would love a toolwindow with
inspections at current cursor position, which is visible all the time
- a way to define dependency constraints and when you try to break 'em -
Idea should cry very loudly. I am talking about 'compile-time aspects' -
checks that
can be fired to check dependencies and other constraints


IMO we can use JDK 1.5 annotations to make many of our constraints expilicit
and make IDEA check them. First thing that comes to mind is non-nullable
references, but I am sure we can come up with many more ideas.

- updating CVS plugin so that it can be comparable with Eclipse's - in
fact I think that CVS integration in Eclipse is the reference for all
other...


What are CVS integration features of Eclipse that IDEA lacks?

- Idea should track user gestures and suggest more convenient way
to do things (if you for examples did extract methid by choosing it from
menu, Idea should point in popup - that you can use context menu or
shortcut key).


Mmm, not sure about this one at all. For one thing, the menu item explicitly
shows that it has a shortcut associated with it. If user fails to see that,
he will fail to see a popup.
I wonder what other user gestures we may track.


Enough for 5.0?
I'll add:
- J2EE generic Open API (without weblogims as Hani says)
- full JSP 2.0 support
- more IG quickfixed - I think there plenty of inspections that can have
quick fixed builtin.


Well, I do not think this all is enough for a major release.

What ewould the others say?

Freindly,
Dmitry
--
Dmitry Lomov
Software Developer
JetBrains Inc.
http://www.jetbrains.com
"Develop with pleasure!"

0
Comment actions Permalink

Alexey Efimov wrote:

Hello, Michal!
You wrote on Mon, 24 May 2004 23:59:58 +0200:
MS> For all other people, createing a 'mass' of Jetbrains customers. In
MS> my company, we have recently bought several Idea copies. Most of the
MS> people migrated from JBuilder and Eclipse to Idea with no problem.
MS> But with current, limited help, they have no chance to master Idea
MS> in the way I have mastered it.

No help is requires for development IDEA. Just start type with IDEA and you
will see how it work... in all other IDE you realy need for help!
BTW, Productivity Guide is realy powerfull feature!


For what it's worth (speaking only as a developer working mostly on
Fabrique), I agree with Michal's sentiments that the future of IDEA
should be much deeper integration with the programmer and his habits and
guiding the programmer to become more productive and learn more about
programming as he goes. I'd like to note that this is the second time
someone is asking for more immediate dependency-rule violation warnings
(more than just a red/yellow line in the sidebar). This shows that such
features are important and there is an underlying desire to see these
types of features.
Remember when 'refactoring' was just a book and something way off in the
land of Smalltalk? Java developers talked about it, even did it by hand,
but few actually expected to find a tool so intelligent that it could
actually do it for them.
Now, people are starting to think 'Wouldn't it be great if there was an
IDE that could help me become a better programmer, rather than just
being a passive tool that I use to program?' Well, I can't speak for the
actual future of IDEA -- that's not in my realm at the moment -- but it
is definitely one possible future. Talk to Sergey Dmitriev, he's
always thinking about the future of software development tools.
By the way, one other possible future of IDEA is as a much more fully
'extensible' tool, and I don't just mean 'plugin support', but
extensible for your project: intelligent code generation, building your
own refactorings, inspections, and whatnot, 'extending' the programming
language via tool support (code transformation), etc. These two futures
are not necessarily mutually exclusive either. The reason I like the
'human integration' future is that it makes IDEA much more broadly
desirable by existing programmers. The 'extensible IDE' future is
interesting for more advanced programmers (at least in the short term).
--
Rob Harwood
Software Developer
JetBrains Inc.
http://www.jetbrains.com
"Develop with pleasure!"

0
Comment actions Permalink

On 24-05-2004 23:59, Michal Szklanowski wrote:

- updating CVS plugin so that it can be comparable with Eclipse's - in fact
I think that CVS integration in Eclipse is the reference for all other...


I haven't used Eclipse lately, maybe you can explain in what way its CVS
plugin is better than IDEA's?

- more IG quickfixed - I think there plenty of inspections that can have
quick fixed builtin.


For which inspections would you like to have a quick fix? I may be able
to implement some.

Bas

0
Comment actions Permalink

Hello, Rob!
You wrote on Tue, 25 May 2004 12:46:07 +0400:

RH> By the way, one other possible future of IDEA is as a much more
RH> fully 'extensible' tool, and I don't just mean 'plugin support',
RH> but extensible for your project: intelligent code generation,
RH> building your own refactorings, inspections, and whatnot,
RH> 'extending' the programming language via tool support (code
RH> transformation), etc. These two futures are not necessarily
RH> mutually exclusive either. The reason I like the 'human
RH> integration' future is that it makes IDEA much more broadly
RH> desirable by existing programmers. The 'extensible IDE' future is
RH> interesting for more advanced programmers (at least in the short
RH> term).

Sorry, but the main idea of 'extensible feature' is extension of available
features?
I think that is only words in air, that is extensible feature inside of
IDEA? It a plugin i guess.
So, i thing, that this request i must be directed into improving modularity
of API.

Only one thing in IDEA is 'incomplite' - is Open API. Development of plugin
for IDEA is not very simple, not documented and so on.

But, Open API is task of EAP development, not JetBrains. We must create
'best plugins' and ask JetBrainers to open api for this. I guess.

Thanks!
Alexey Efimov - Java Developer
Tops BI
http://www.topsbi.com


0
Comment actions Permalink


Norris Shelton
Sun Certified Java Programmer




Dmitry Lomov (JetBrains) wrote:

>Michal Szklanowski wrote:
>

>
>>Hi,
>>
>>[...]
>>
>>For me, the following steps are to be performed to improve existing
>>situation (then we can talk about new features):
>>- tracking user should be improved to support other kind of
>>autocompletion, not only methods
>>- tips list in intelligent progress window should be updated to include
>>all the tips of the day from Idea 4.0 and more, so that use can learn
>>while waiting
>> for time consuming operations
>>- productivity guide should work as expected and feature list should be
>>much longer, mentioning not only 'killer features' but these nice small
>>things that
>> make Idea so cool IDE to use
>>
>>
>
>I can imagine the advertising: "Our 4.0 version is packed with features. Pay
>$500 and they are yours!". "Our 5.0 version will help you to discover all
>the features of 4.0. Just pay $XXX and it is yours!" :))
>

>
>>Then come new features. I believe in future of Idea as INTELLIGENT IDE.
>>This mean much more that Idea has to offer novadays.
>>This means learning from the user about his habits, code conventions, most
>>commonly used things such as:
>>- learning code style from live code (you point Idea to live code - a
>>project, and Idea 'learns' code style and adjusts settings to match habits
>>in the code)
>>
>>
>
>Very good idea, IMO. And not too difficult to implement at all.
>

>
>>- smart code templates (Idea learns your commonly used code constructs and
>>stores them in the form of dynamic templates, for eg. you are used to
>>write for loop to iterate over collection...)
>>
>>
>
>We have to think more about this one. Duplicates analysis that we already
>have may help to discover such stuff, but IMO there is a problem with Live
>Templates as a way to express certain idioms: they do not suppor round-trip
>and once they are expanded, they are lost. Maybe something in the lines of
>Alain Ravet Camouflage plugin may help?
>

>
>>- going hand in hand with programmer to point out mistakes and things that
>>can be possibly errors - with power of InspectionGadgets Idea should be a
>>little
>>more invasive when helping programmer - I would love a toolwindow with
>>inspections at current cursor position, which is visible all the time
>>- a way to define dependency constraints and when you try to break 'em -
>>Idea should cry very loudly. I am talking about 'compile-time aspects' -
>>checks that
>>can be fired to check dependencies and other constraints
>>
>>
>
>IMO we can use JDK 1.5 annotations to make many of our constraints expilicit
>and make IDEA check them. First thing that comes to mind is non-nullable
>references, but I am sure we can come up with many more ideas.
>

>
>>- updating CVS plugin so that it can be comparable with Eclipse's - in
>>fact I think that CVS integration in Eclipse is the reference for all
>>other...
>>
>>
>
>What are CVS integration features of Eclipse that IDEA lacks?
>

>
>>- Idea should track user gestures and suggest more convenient way
>>to do things (if you for examples did extract methid by choosing it from
>>menu, Idea should point in popup - that you can use context menu or
>>shortcut key).
>>
>>
>
>Mmm, not sure about this one at all. For one thing, the menu item explicitly
>shows that it has a shortcut associated with it. If user fails to see that,
>he will fail to see a popup.
>I wonder what other user gestures we may track.

>

I have to completely disagree with this. I coded with Idea for over a
year before I stumbled upon CTRL+space. I wish there was a way to make
the CTRL+space autocomplete automatic after a delay. My co-workers who
started using Idea 4 months ago, always discover something when they see
me using Idea. "How did you do that?". There was the suggestion to
show possible key-strokes, but I think it stalled. I guess the big
thing is that programmers are lazy and most will not spend the time to
learn the application in depth. Unfortunately, those are the masses
that you need to become your new customers (think $$$).

>
>>Enough for 5.0?
>>I'll add:
>>- J2EE generic Open API (without weblogims as Hani says)
>>- full JSP 2.0 support
>>- more IG quickfixed - I think there plenty of inspections that can have
>>quick fixed builtin.
>>
>>
>
>Well, I do not think this all is enough for a major release.
>
>What ewould the others say?
>
>Freindly,
>Dmitry

>

0
Comment actions Permalink

Alexey Efimov wrote:

Sorry, but the main idea of 'extensible feature' is extension of available
features?
I think that is only words in air, that is extensible feature inside of
IDEA? It a plugin i guess.
So, i thing, that this request i must be directed into improving modularity
of API.


Note: 'Future', not 'feature'. I was proposing a possible future
direction for IDEA, not a specific feature. That possible future would
be to have IDEA highly extensible from the user's point of view, not
just for plugin developers, so it is not specifically related to Open API.

--
Rob Harwood
Software Developer
JetBrains Inc.
http://www.jetbrains.com
"Develop with pleasure!"

0
Comment actions Permalink

On Tue, 25 May 2004 10:53:33 +0200, Bas Leijdekkers
<leijdekkers@no.spam.please.carp-technologies.nl> wrote:

On 24-05-2004 23:59, Michal Szklanowski wrote:

>> - updating CVS plugin so that it can be comparable with Eclipse's - in
>> fact
>> I think that CVS integration in Eclipse is the reference for all
>> other...
>

I haven't used Eclipse lately, maybe you can explain in what way its CVS
plugin is better than IDEA's?

>

Tree diff

--
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/

0
Comment actions Permalink

Norris Shelton wrote:


Norris Shelton
Sun Certified Java Programmer




Dmitry Lomov (JetBrains) wrote:

>>Michal Szklanowski wrote:
>>
>>
>>
>>>Hi,
>>>
>>>[...]
>>>
>>
>>
>>>- Idea should track user gestures and suggest more convenient way
>>>to do things (if you for examples did extract methid by choosing it from
>>>menu, Idea should point in popup - that you can use context menu or
>>>shortcut key).
>>>
>>>
>>
>>Mmm, not sure about this one at all. For one thing, the menu item
>>explicitly shows that it has a shortcut associated with it. If user fails
>>to see that, he will fail to see a popup.
>>I wonder what other user gestures we may track.
>>
>>


I have to completely disagree with this.


What do you disagree with? I was criticizing one specific suggestion - popup
suggesting to use a shortcut when menu item is explicitely invoked.
Your example has nothing to do with this, since Completion is not likely to
be invoked from menu.

I coded with Idea for over a
year before I stumbled upon CTRL+space. I wish there was a way to make
the CTRL+space autocomplete automatic after a delay.


I believe that the solution for that is already there: Productivity Guide.
Do you think it does not work? Any better ideas?

My co-workers who
started using Idea 4 months ago, always discover something when they see
me using Idea. "How did you do that?".


What are those features, generally?

Cheers,
Dmitry
--
Dmitry Lomov
Software Developer
JetBrains Inc.
http://www.jetbrains.com
"Develop with pleasure!"

0
Comment actions Permalink


"Michal Szklanowski" <szklanowski@nospam.aster.pl> wrote in message
news:c8trb0$l5r$1@is.intellij.net...

- tracking user should be improved to support other kind of

autocompletion,

not only methods


I don't know what you mean by that. There are already three different types
of autocomplete: Basic, Smart Type, and Class Name. And they do a lot more
than method autocomplete.

- tips list in intelligent progress window should be updated to include

all

the tips of the day from Idea 4.0 and more, so that use can learn while
waiting for time consuming operations
- productivity guide should work as expected and feature list should be

much

longer, mentioning not only 'killer features' but these nice small things
that make Idea so cool IDE to use


This is true, but it should also provide a way to prevent the tip window
from automatically closing while the user is reading it. Perhaps a checkbox
or something.

Then come new features. I believe in future of Idea as INTELLIGENT IDE.

This

mean much more that Idea has to offer novadays.
This means learning from the user about his habits, code conventions, most
commonly used things such as:
- learning code style from live code (you point Idea to live code - a
project, and Idea 'learns' code style and adjusts settings to match habits
in the code)


Sure, but how often would you use this....unless you're a consultant and
want to adapt your coding style to match your client's style and you change
client assignments frequently. Even then, I think that I would rather edit
my code using my preferred style and then run a batch process to convert it
to match the clients style when I am done.
As a matter of fact, there is a feature request in tracker that would
support displaying files in your preferred coding style whenever they are
loaded into the editor. IMHO, that would be the best option. Then the code
could be stored with a standard coding style and displayed in the style that
best suits the individual developer.

- smart code templates (Idea learns your commonly used code constructs and
stores them in the form of dynamic templates, for eg. you are used to

write

for loop to iterate over collection...)


I think that the existing "save as live template" is sufficient for this.

- going hand in hand with programmer to point out mistakes and things that
can be possibly errors - with power of InspectionGadgets Idea should be a
little
more invasive when helping programmer - I would love a toolwindow with
inspections at current cursor position, which is visible all the time


I would not want this to be "invasive". A toolwindow that the user can open
and close (or permanantly disable) would be fine, but if it was constantly
interrupting me with pop-up windows, I would not be happy.

- a way to define dependency constraints and when you try to break 'em -
Idea should cry very loudly. I am talking about 'compile-time aspects' -
checks that
can be fired to check dependencies and other constraints


Again, not invasive.

- updating CVS plugin so that it can be comparable with Eclipse's - in

fact

I think that CVS integration in Eclipse is the reference for all other...


CVS is not the only version code control system out there. They all provide
essentially the same functions with some minor variations. The user
experience should be almost the same regardless of which VCS is being used.
Only VCS implementation-specific items should require custom user
interfaces. The rest should be handled transparently to the user with a
common IDEA GUI.

- Idea should track user gestures and suggest more convenient way to do
things (if you for examples did extract methid by choosing it from menu,
Idea should point in popup - that you can use context menu or shortcut

key).


Again, not invasive. I would hate a popup. Maybe a tooltip. But isn't
this what the productivity guide is for?

>

Enough for 5.0?


No.

I'll add:
- J2EE generic Open API (without weblogims as Hani says)
- full JSP 2.0 support
- more IG quickfixed - I think there plenty of inspections that can have
quick fixed builtin.


- Full HTML/JavaScript/JSP mixed content page support, including smart
complete, reformatting, and refactoring.
- Support for finding common code blocks/methods in classes which extend a
common base class or implement a common interface with the option to move
those methods to the base class or create an intermediate class to contain
them.
- When typing code in a class, suggest the use of a base class method that
has a similar "signature".
- Support round-trip modeling (UML) similar to TogetherSoft.
- Improve memory management so that it is completely transparent to the
developer. (i.e. no pauses, ever.)
- Complete and improve the help documentation (using Technical Writers who
are extremely fluent in whatever language that version of the documentation
is in). This is a professional product and the documentation should be
complete when the product is released.

>

Welcome to discussion, EAPers and Jetbrainers.
---
Michal Szklanowski
Java Architect

>
>

---
Tim


0
Comment actions Permalink


>- more IG quickfixed - I think there plenty of inspections >that can have quick fixed builtin.

Fewer than you would imagine, given the current OpenAPI. Pretty much everything that can be automatically fixed is automatically fixed. However, if JetBrains opened up the refactoring processors, considerably more could be done with semi-automated fixes. Right now the only refactorings that an IG inspection can trigger are "Rename" and "Move" (and I haven't even figured out how to make "Move" work yet). Give me the ability to trigger "Extract Interface", "Replace Constructor With Factory Method", "Encapsulate Fields" or (most especially) "Use Interface Where Possible", and there are a lot of things that IG could be extended to semi-automatically fix.

--Dave Griffith

0
Comment actions Permalink

Then come new features. I believe in future of Idea

as INTELLIGENT IDE.

This mean much more that Idea has to offer

novadays.

This means learning from the user about his habits,

code conventions, most

commonly used things such as:
- learning code style from live code (you point

Idea to live code - a

project, and Idea 'learns' code style and adjusts

settings to match habits

in the code)


Very good idea, IMO. And not too difficult to
implement at all.


I agree as well. It makes IDEA easier and more powerful. This goes beyond templates and code styles. So many times have I seen my coworker do something manually when it could be done automatically through a refactoring. Especially now with the duplication removal.

- smart code templates (Idea learns your commonly

used code constructs and

stores them in the form of dynamic templates, for

eg. you are used to

write for loop to iterate over collection...)


We have to think more about this one. Duplicates
analysis that we already
have may help to discover such stuff, but IMO there
is a problem with Live
Templates as a way to express certain idioms: they do
not suppor round-trip
and once they are expanded, they are lost. Maybe
something in the lines of
Alain Ravet Camouflage plugin may help?

There are more little things that can be done. Pre-selecting options (iterate). IMHO the round trip aspect does not really apply since we are mainly talking about forward generating here. I am not looking at refactoring my old code. I just want IDEA to assist in writing mine by learning my ways of coding. In fact it isn't just my way of coding but the project structures. If IDEA could integrate the patterns and idioms used in the project and be able to guide developers in coding towards these, it would go a long way towards consistent coding.

- going hand in hand with programmer to point out

mistakes and things that

can be possibly errors - with power of

InspectionGadgets Idea should be a

little
more invasive when helping programmer - I would

love a toolwindow with

inspections at current cursor position, which is

visible all the time

- a way to define dependency constraints and when

you try to break 'em -

Idea should cry very loudly. I am talking about

'compile-time aspects' -

checks that
can be fired to check dependencies and other

constraints

IMO we can use JDK 1.5 annotations to make many of
our constraints expilicit
and make IDEA check them. First thing that comes to
mind is non-nullable
references, but I am sure we can come up with many
more ideas.


We do this with a junit test that runs jdepend to break the build. However IDEA should have an option to run the dependency check as part of its build or better, provides this incrementally as an inspection (along with the optimize import on the fly). Dependency check should be just a normal step of the build and should be callable from an external build (ant).

Jacques

0
Comment actions Permalink

Enough for 5.0?
I'll add:
- J2EE generic Open API (without weblogims as Hani

says)

- full JSP 2.0 support
- more IG quickfixed - I think there plenty of

inspections that can have

quick fixed builtin.


Well, I do not think this all is enough for a major
release.

What ewould the others say?


Dmitry,

Just call it 4.2 but PLEASE PLEASE give IDEA back it J2EE laurels as soon as possible.
J2EE has always been amongst the last thing to complete since 3.0. 4.0 and 4.1 EAP J2ee support were horribly broken until the last moment. To me that sends a clear message and prevents some of your usual EAPers from participating in the EAP.

0
Comment actions Permalink

Jacques Morel wrote:

Dmitry,

Just call it 4.2 but PLEASE PLEASE give IDEA back it J2EE laurels as soon as possible.


+100.
Or change the scope of 4.1 to include this - call it 4.5 or whatever you
like.

Jon

0
Comment actions Permalink

programming as he goes. I'd like to note that this is
the second time
someone is asking for more immediate dependency-rule
violation warnings
(more than just a red/yellow line in the sidebar).


Rob, while I agree with most of your statement, the paragraph above has me concerned. All it takes is 2 requests for a need to display a need for its validity in a product? If that were the case, I'd say JSP2, Maven, Velocity, PHP, Python and my grandmother's coding language should have been incorporated a long time ago :)

R

0
Comment actions Permalink

Got completely beat up for this, and perhaps justifiably because I wasn't exactly nice about it... but indeed, PLEASE give IDEA back it's J2EE laurels and high standards it deserves. If it takes 2 requests to get Rob Harwood's attention about a needed feature (just giving you flack Rob, not being real serious), then this is one that should have merited more consideration than the integration of IG and IPP (for example), since these were already freely available.

R

0
Comment actions Permalink


>IMO we can use JDK 1.5 annotations to make many of our >constraints expilicit
>and make IDEA check them. First thing that comes to mind is >non-nullable
>references, but I am sure we can come up with many more >ideas.

Non-nullable references, side-effect free functions, aliasing/ownership restrictions, a whole menagerie of concurrency annotations, etc. etc. Within the next couple of years, the 1.5 annotation stuff is likely to trigger the deployment on developer's desktops of a fair number of ideas that have heretofore only be available as heavyweight research tools from the program verification community. IDEA can fit into this pretty easily, in at least 3 areas:

1) Creating the rules. The inspections tools and API provide a strong base for this, although ideally they would be extended with OpenAPI for global inspections and (ideally) opening up the refactoring processors.

2) Annotation assistant. Just like IDEA can auto-introduce "final" to declarations, it should be able to introduce "@not_null" or "@pure", if requested. This will save a huge amount of effort, and fits in nicely with the existing quick-fix structure.

3) Code folding. One can imagine these annotations getting to be a fair chunk of the code's total lines. Valuable, and worth the effort, but that doesn't mean you want to see them all the time. Just like javadoc, IDEA should support folding of annotations.

--Dave Griffith

0
Comment actions Permalink

Just a comment on your question of cvs weaknesses: Generally, I don't find much difference feature-wise between Idea's and Eclipse's cvs support (or should we be talked more generically about VCS support). Eclipse is organized in a different way, which is kind of cool, but feature-wise they appear to me pretty close.

However, the big weakness I've found in Idea (and maybe Eclipse does this better), is the merge tool. It's so promising, but just doesn't quite live up to the promise. I find I try to do the merge with tool, and about 75% of the time give up and fall back to examining cvs's old markers instead.

1. Merge doesn't work when merging branches. That's when I encounter the most and trickiest conflicts.
2. The "Apply non-conflicting changes" doesn't apply the same set of changes that cvs would. Cvs seems to have a more aggressive definition of a "non-conflicting change". That means using the Merge tool requires more manually conflict resolution. It also means that a "cvs conflict" is different from an "Idea" conflict. I often try to resolve conflicts using both the Merge tool and the markers that cvs leaves behind, but the resulting conflicts are different, so you can't really use the two techniques in concert.
3. Whenever a change is applied (a conflicting or non-conflicting change), it would nice to show a visual indication of the apply change and which side it came from. Now, when you apply a change, the diff indication disappears. This I guess helps the developer know when the merge is complete. But it's helpful to go back and see what changes were applied and where the came from. This is particularly useful in the case of a conflicting change. It would be so nice to see whether code from the right or left was accepted wholesale, or whether changes from the right and left were manually merged into a new block of code. Some color set could be used to show which side was accepted, which side rejected, or show that the merged block is different from both.
4. The Merge tool still doesn't quite solve white-space conflict problems. I really want the ability to ignore whitespace before detecting conflicts. When there is a white-space-only conflict, presumable Idea should opt for what's in the file being merged into (the merge target revision). When there is a significant change conflicting with a white-space change, Idea should take the significant change, and ignore the whitespace change. Presumably, if developers want to closely control code formatting, they'll run the formatter after the merge is complete anyway, so merging white-space changes isn't necessary.

0
Comment actions Permalink


>What are those features, generally?

Just last week, I had to show a fellow developer the Ctrl-N familiy, and Ctrl-W. He's a very bright guy, had been using IDEA for three months, and had no clue that they existed. Considering I use each of those features at least 50 times a day, I estimate that he missed out on a lot of productivity by searching the project view for files, and mousing to do selections. The productivity guide should be a godsend for stuff like this, but it's gonna be important to have everything in there, even stuff you just assume everyone knows.

--Dave Griffith

0
Comment actions Permalink

Robert S. Sfeir wrote:

>>programming as he goes. I'd like to note that this is
>>the second time
>>someone is asking for more immediate dependency-rule
>>violation warnings
>>(more than just a red/yellow line in the sidebar).


Rob, while I agree with most of your statement, the paragraph above has me concerned. All it takes is 2 requests for a need to display a need for its validity in a product? If that were the case, I'd say JSP2, Maven, Velocity, PHP, Python and my grandmother's coding language should have been incorporated a long time ago :)

R

I didn't say that two requests means the IDEA team is going to focus on
it. I said two requests shows it's important (at least to some), and
there is an underlying desire (assuming they aren't the only two people
who want it). Since I agree with the request, in my mind that a) makes
it more important (to me, of course) and b) shows that there really is
an underlying desire. The fact that the two requests happened both very
recently to me shows that it's an idea that people have been thinking
about but hasn't risen to the surface until recently. It's quite
probable that the first request instigated the second, but that only
amplifies the point. Also, it is very much unlike Maven and AspectJ in
that these are high-profile technologies (of course there will be a lot
of requests), whereas dependency rule warnings are quite low profile
(it's surprising that there are multiple requests).

--
Rob Harwood
Software Developer
JetBrains Inc.
http://www.jetbrains.com
"Develop with pleasure!"

0
Comment actions Permalink

Dave Griffith wrote:
> Just last week, I had to show a fellow developer the Ctrl-N
familiy, and Ctrl-W.
> He's a very bright guy, had been using IDEA for three months, and
> had no clue that they existed.
> .. he missed out on a lot of productivity
and

> The productivity guide should be a godsend for stuff like this,
> but it's gonna be important to have everything in there, even
> just assume everyone knows.


I agree 100%, but for the format of the guide

And I would add that this info/service is as cruelly missing as it is
easy to satisfy: all it would take is "just" 2 JetBrainers, and 2-4
days, to record short multimedia demos/tutorial WITH VOICE (I insist).
Some would be general, some would be very specific.

The current batch, available at
http://www.jetbrains.com/idea/training/
is a good start, but it's so limited it looks like a good intention
that's been interrupted when Black Death came, and all the people left
the village, overnight.

Next time somebody would ask you why you stick to IDEA, when Eclipse is
free, you would just send him the demos page url. He'd sit and watch,
for 15 minutes, or an hour, watch TV, and be sold. Or not.
You could make special demos for management, for the press, for EJB
developers, BEA, Tomcat, etc...

To summarize: I think that multimedia demos, WITH voice:
- are cruelly missing
- are easy to produce
- bring a huge ROI for JetBrains AND us

Alain

0
Comment actions Permalink

Ditto.

Norris Shelton
Sun Certified Java Programmer




Dave Griffith wrote:

>>What are those features, generally?
>>
>>
>
>Just last week, I had to show a fellow developer the Ctrl-N familiy, and Ctrl-W. He's a very bright guy, had been using IDEA for three months, and had no clue that they existed. Considering I use each of those features at least 50 times a day, I estimate that he missed out on a lot of productivity by searching the project view for files, and mousing to do selections. The productivity guide should be a godsend for stuff like this, but it's gonna be important to have everything in there, even stuff you just assume everyone knows.
>
>--Dave Griffith

>

0
Comment actions Permalink

This can't be stressed enough. J2EE development is the Idea
step-child. Never respected. :(

What is so weird about this is that 5 of the 6 web developers at my
company have switched from JBuilder X Ent to IntelliJ.

Norris Shelton
Sun Certified Java Programmer




Jacques Morel wrote:

>>>Enough for 5.0?
>>>I'll add:
>>>- J2EE generic Open API (without weblogims as Hani
>>>
>>>
>>says)
>>
>>
>>>- full JSP 2.0 support
>>>- more IG quickfixed - I think there plenty of
>>>
>>>
>>inspections that can have
>>
>>
>>>quick fixed builtin.
>>>
>>>
>>Well, I do not think this all is enough for a major
>>release.
>>
>>What ewould the others say?
>>
>>
>>
>
>Dmitry,
>
>Just call it 4.2 but PLEASE PLEASE give IDEA back it J2EE laurels as soon as possible.
>J2EE has always been amongst the last thing to complete since 3.0. 4.0 and 4.1 EAP J2ee support were horribly broken until the last moment. To me that sends a clear message and prevents some of your usual EAPers from participating in the EAP.
>
>

>

0
Comment actions Permalink

Dave Griffith wrote:

Just last week, I had to show a fellow developer the Ctrl-N familiy, and Ctrl-W. He's a very bright guy, had been using IDEA for three months, and had no clue that they existed. Considering I use each of those features at least 50 times a day, I estimate that he missed out on a lot of productivity by searching the project view for files, and mousing to do selections. The productivity guide should be a godsend for stuff like this, but it's gonna be important to have everything in there, even stuff you just assume everyone knows.


I will be solving this in about a month from now by making a
presentation on IDEA 4 and its new features to our local R&D group. I've
done this before for IDEA 3 as well. I'll have to be careful this time
though, I ran out of time with my IDEA 3 presentation ;)

Ciao,
Gordon

--
Gordon Tyler (Software Developer)
Quest Software <http://java.quest.com/>
260 King Street East, Toronto, Ontario M5A 4L5, Canada
Voice: 416-643-4846 | Fax: 416-594-1919

0
Comment actions Permalink


U¿ytkownik "Dave Griffith" <dave.griffith@cnn.com> napisa³ w wiadomo¶ci
news:9842600.1085493132600.JavaMail.itn@is.intellij.net...
>

>- more IG quickfixed - I think there plenty of inspections >that can have

quick fixed builtin.
>

Fewer than you would imagine, given the current OpenAPI. Pretty much

everything that can be automatically fixed is automatically fixed. However,
if JetBrains opened up the refactoring processors, considerably more could
be done with semi-automated fixes. Right now the only refactorings that an
IG inspection can trigger are "Rename" and "Move" (and I haven't even
figured out how to make "Move" work yet). Give me the ability to trigger
"Extract Interface", "Replace Constructor With Factory Method", "Encapsulate
Fields" or (most especially) "Use Interface Where Possible", and there are a
lot of things that IG could be extended to semi-automatically fix.
>
Maxim, would you give Dave its toys? :)
I bet you could. We've seen what he's done with IG, if you
open refactoring API a bit, quite amazing things should happen.


0
Comment actions Permalink

3) Code folding. One can imagine these annotations
getting to be a fair chunk of the code's total lines.
Valuable, and worth the effort, but that doesn't
mean you want to see them all the time. Just like
javadoc, IDEA should support folding of
annotations.


And I think not in the same way the current code is folded. Annotations are, by their nature, exposed to the user through alternative means. Code folding is a mechanism to temporarily hide information that is exposed through the editor.

If we code-fold annotations, they still "take up space" in that the user "knows" they are still there.

I would go so far as to say that you shouldn't even see them, unless you enter some kind of "mode". And then, yes, folding would work fine.

By the way, import statements should generally fall into that category as well. They are things that can be automatically managed.

Mike

0
Comment actions Permalink

In article <c8vin4$6o5$1@is.intellij.net>, Tim Haley
<ymaraner@yahoo.com> wrote:

- Complete and improve the help documentation (using Technical Writers who
are extremely fluent in whatever language that version of the documentation
is in). This is a professional product and the documentation should be
complete when the product is released.


When IntelliJ had first released Idea and had few native English
speakers on staff, I contributed help files for inclusion in Idea. I
had experience as a technical writer (I'd written a computer book and
several scientific papers and book chapters) and teacher, and loved
using Idea, so I didn't mind donating my time to help improve Idea.

I don't claim to be an expert on every area of Java (I tend to write
client-side and JDBC apps, so I'm unfamiliar with other technologies
that I don't tend to use), but I'd be perfectly willing to act as
editor/proofreader for Idea's English documentation.

Dr. Scott Steinman
Professor, Southern College of Optometry
Chair, Open-Source Visual Programming Language Group

0
Comment actions Permalink

Yes, I couldn't agree more. An open refactoring API would be awesome.

0
Comment actions Permalink

Michal Szklanowski wrote:


U¿ytkownik "Dave Griffith" <dave.griffith@cnn.com> napisa³ w wiadomo¶ci
news:9842600.1085493132600.JavaMail.itn@is.intellij.net...

>>
>> >- more IG quickfixed - I think there plenty of inspections >that can
>> >have

quick fixed builtin.

>>
>> Fewer than you would imagine, given the current OpenAPI. Pretty much

everything that can be automatically fixed is automatically fixed.
However, if JetBrains opened up the refactoring processors, considerably
more could
be done with semi-automated fixes. Right now the only refactorings that
an IG inspection can trigger are "Rename" and "Move" (and I haven't even
figured out how to make "Move" work yet). Give me the ability to trigger
"Extract Interface", "Replace Constructor With Factory Method",
"Encapsulate Fields" or (most especially) "Use Interface Where Possible",
and there are a lot of things that IG could be extended to
semi-automatically fix.

>>

Maxim, would you give Dave its toys? :)


I am not Maxim, but it is planned.

Cheers,
Dmitry
--
Dmitry Lomov
Software Developer
JetBrains Inc.
http://www.jetbrains.com
"Develop with pleasure!"

0
Comment actions Permalink


"Dave Griffith" <dave.griffith@cnn.com> wrote in message
news:32119820.1085495793477.JavaMail.itn@is.intellij.net...

Non-nullable references, side-effect free functions, aliasing/ownership

restrictions, a whole menagerie of concurrency annotations, etc. etc.
Within the next couple of years, the 1.5 annotation stuff is likely to
trigger the deployment on developer's desktops of a fair number of ideas
that have heretofore only be available as heavyweight research tools from
the program verification community. IDEA can fit into this pretty easily,
in at least 3 areas:

2) Annotation assistant. Just like IDEA can auto-introduce "final" to

declarations, it should be able to introduce "@not_null" or "@pure", if
requested. This will save a huge amount of effort, and fits in nicely with
the existing quick-fix structure.

This is already done with @Override annotation, and will be supported with
all other stuff that we will introduce. Note however, that using annotations
forces the client to have annotation classes when compiling, so we must be
very careful when introducing new annotations.

>

3) Code folding. One can imagine these annotations getting to be a fair

chunk of the code's total lines. Valuable, and worth the effort, but that
doesn't mean you want to see them all the time. Just like javadoc, IDEA
should support folding of annotations.
+1


0

Please sign in to leave a comment.