Scala IDEs

> Using a simple text-editor, Scala is way more productive than Java, but
> under eclipse or even Netbeans, my recent experience tells me otherwise.
>
I sympathize with your sentiment, because I was also frustrated a long
time with the
state of the Scala Eclipse IDE. It does seem to work well for some
people, but for me, and it seems also for you, it's too shaky to
support large projects reliably. That's why I have finally taken the
plunge and got personally involved in rewriting the IDE/compiler
interface. Judge us again in 2-3 months, please. Meanwhile, you might
also consider IntelliJ; it has a very nice Scala IDE today.

Cheers

Recently I have also backed away from Scala development. I originally started out as a Java developer, then after a job change about 5 years ago, I switched to C# and the .NET eco-system, along with a foray into many various scripting languages. I briefly moved back to Java for a while, only to find that the language felt like it had completely and utterly stagnated. Then I discovered Scala. When I first started reading about Scala, I actually felt thrilled by what it offered - which is a feeling I honestly haven't felt about any programming language for almost twenty-five years. Initially, all went well...

Alas, the honeymoon period is over for me. I was productive in Scala for about a month, but once my project reached a certain size and complexity, I started to run into snags. At the time, I was using the NetBeans plugin, which was fine, though somewhat buggy. However, I struggled to get the unit test frameworks to integrate reliably with NetBeans, and after much faffing about, I decided to switch to the Eclipse plugin, which appeared to me to be more mature. Alas, I didn't fare much better with Eclipse (in particular, Maven and Eclipse mix together fairly poorly), and I hit the last straw when I wrote some code which contained errors I couldn't track down simply by writing more detailed unit tests - I needed to use a debugger. I struggled for about three weeks, on and off, trying to get Eclipse to debug my Specs unit tests. In the end, utterly exasperated, I gave up. It took me two days to port everything to C#, and I'll be finishing the project using MonoDevelop.

Sadly, my Scala journey has been ultimately rather disappointing. I still find Scala a very attractive language that holds lots of promise, but its relatively poor IDE support, including the inability to debug applications, means that I can't afford to spend any more of my time struggling with it - I have a living to earn and projects that need to be completed sooner, not later.

Maybe this time next year, I'll give the Scala IDEs another try in earnest.

Chris



2009/6/15 martin odersky <martin.odersky@epfl.ch>

> Using a simple text-editor, Scala is way more productive than Java, but
> under eclipse or even Netbeans, my recent experience tells me otherwise.
>
I sympathize with your sentiment, because I was also frustrated a long
time with the
state of the Scala Eclipse IDE. It does seem to work well for some
people, but for me, and it seems also for you, it's too shaky to
support large projects reliably. That's why I have finally taken the
plunge and got personally involved in rewriting the IDE/compiler
interface. Judge us again in 2-3 months, please. Meanwhile, you might
also consider IntelliJ; it has a very nice Scala IDE today.

Cheers

As someone who's fought through all the IDE problems with Scala for nearly two years I certainly understand your frustration. However, as Martin mentioned, IntelliJ's support for Scala is very nice. I haven't had problems with it in several months. It's code navigation is excellent, and it has full ScalaTest support. Hopefully the other IDE's will be this nice when and if you eventually try again, but if you can give IntelliJ a try, I think you'll be happy with it.

On Mon, Jun 15, 2009 at 5:26 PM, Chris Lambrou <christopherlambrou@gmail.com> wrote:

Recently I have also backed away from Scala development. I originally started out as a Java developer, then after a job change about 5 years ago, I switched to C# and the .NET eco-system, along with a foray into many various scripting languages. I briefly moved back to Java for a while, only to find that the language felt like it had completely and utterly stagnated. Then I discovered Scala. When I first started reading about Scala, I actually felt thrilled by what it offered - which is a feeling I honestly haven't felt about any programming language for almost twenty-five years. Initially, all went well...

Alas, the honeymoon period is over for me. I was productive in Scala for about a month, but once my project reached a certain size and complexity, I started to run into snags. At the time, I was using the NetBeans plugin, which was fine, though somewhat buggy. However, I struggled to get the unit test frameworks to integrate reliably with NetBeans, and after much faffing about, I decided to switch to the Eclipse plugin, which appeared to me to be more mature. Alas, I didn't fare much better with Eclipse (in particular, Maven and Eclipse mix together fairly poorly), and I hit the last straw when I wrote some code which contained errors I couldn't track down simply by writing more detailed unit tests - I needed to use a debugger. I struggled for about three weeks, on and off, trying to get Eclipse to debug my Specs unit tests. In the end, utterly exasperated, I gave up. It took me two days to port everything to C#, and I'll be finishing the project using MonoDevelop.

Sadly, my Scala journey has been ultimately rather disappointing. I still find Scala a very attractive language that holds lots of promise, but its relatively poor IDE support, including the inability to debug applications, means that I can't afford to spend any more of my time struggling with it - I have a living to earn and projects that need to be completed sooner, not later.

Maybe this time next year, I'll give the Scala IDEs another try in earnest.

Chris



2009/6/15 martin odersky <martin.odersky@epfl.ch>

> Using a simple text-editor, Scala is way more productive than Java, but
> under eclipse or even Netbeans, my recent experience tells me otherwise.
>
I sympathize with your sentiment, because I was also frustrated a long
time with the
state of the Scala Eclipse IDE. It does seem to work well for some
people, but for me, and it seems also for you, it's too shaky to
support large projects reliably. That's why I have finally taken the
plunge and got personally involved in rewriting the IDE/compiler
interface. Judge us again in 2-3 months, please. Meanwhile, you might
also consider IntelliJ; it has a very nice Scala IDE today.

Cheers

On Mon, Jun 15, 2009 at 05:59:27PM -0400, Josh Cough wrote:

>As someone who's fought through all the IDE problems with Scala for nearly
>two years I certainly understand your frustration. However, as Martin
>mentioned, IntelliJ's support for Scala is very nice. I haven't had problems
>with it in several months. It's code navigation is excellent, and it has
>full ScalaTest support. Hopefully the other IDE's will be this nice when and
>if you eventually try again, but if you can give IntelliJ a try, I think
>you'll be happy with it.

As a die-hard vim users, I've never been able to get past the
frustration of the feature-started basic editing IDE's have to learn
the additional features that the IDE's provide.

I've been writing a good bunch of code in Scala, just using vim.
However, the vim Scala indent code gets rather frustrating. I'm not
actually sure that Scala can be indented with fully parsing it, but
I've wondered if I should try to learn enough vim-script to try and
improve this indenting.

David

Not to incite a religious fight, but I found emacs' auto-indent
capabilities very reliable (although not 100% flawless, but close to it).

So far, I found that emacs is definitely a very stable and viable way
to edit scala source code. I tried 3 different IDEs. None of them comes
even close to being comparably stable. (I presume that vim is as
good in that respect, but I have not tried it)

On 6/15/09, David Brown wrote:
> On Mon, Jun 15, 2009 at 05:59:27PM -0400, Josh Cough wrote:
>
>
> > As someone who's fought through all the IDE problems with Scala for nearly
> > two years I certainly understand your frustration. However, as Martin
> > mentioned, IntelliJ's support for Scala is very nice. I haven't had
> problems
> > with it in several months. It's code navigation is excellent, and it has
> > full ScalaTest support. Hopefully the other IDE's will be this nice when
> and
> > if you eventually try again, but if you can give IntelliJ a try, I think
> > you'll be happy with it.
> >
>
> As a die-hard vim users, I've never been able to get past the
> frustration of the feature-started basic editing IDE's have to learn
> the additional features that the IDE's provide.
>
> I've been writing a good bunch of code in Scala, just using vim.
> However, the vim Scala indent code gets rather frustrating. I'm not
> actually sure that Scala can be indented with fully parsing it, but
> I've wondered if I should try to learn enough vim-script to try and
> improve this indenting.
>
> David
>

On Mon, Jun 15, 2009 at 3:43 PM, David Brown wrote:
> As a die-hard vim users, I've never been able to get past the
> frustration of the feature-started basic editing IDE's have to learn
> the additional features that the IDE's provide.
>
> I've been writing a good bunch of code in Scala, just using vim.
> However, the vim Scala indent code gets rather frustrating.  I'm not
> actually sure that Scala can be indented with fully parsing it, but
> I've wondered if I should try to learn enough vim-script to try and
> improve this indenting.

Same here. Care to give a list of things that bother you? One of my
summer projects is to mess with vim's scala support.

For instance, one personal pet peeve is the failure to indent the line
a =>, especially in the instance " list map { i =>". That's an easy
fix, and the first one I'm going to do.

FWIW, the Scala emacs mode, indentation, auto-completion, yasnippits, ctags, and .... for Scala are excellent.  SBT as a build tool is approaching outstanding and improving almost daily.

There are in fact areas where this combination is superior to the IDE environment, and a few where it is not.  For me, overall its no contest, IMHO emacs+sbt is an extremely effective combination and is the superior choice.

Using Netbeans with the Scala plugin, I've had to fight a bit with the
indentation (little things like having to type anything so the tab
aligns). However, using the global ident has always worked fine for
me.

I do have problems with the different classes finding each other for
things like fixing imports and autocompletion.

As to what I want from Netbeans that emacs doesn't do as well...
Fix imports - Pretty much has always been broken and I handle them
myself. Probably my biggest complaint with the current plugin
Autocompletion - Works sporadically
Error display - Works pretty much flawlessly. Displays an error
similar to the compiler

Josh

On Mon, Jun 15, 2009 at 4:03 PM, Christian
Szegedy wrote:
> Not to incite a religious fight, but I found emacs' auto-indent
> capabilities very reliable (although not 100% flawless, but close to it).
>
> So far, I found that emacs is definitely a very stable and viable way
> to edit scala source code. I tried 3 different IDEs. None of them comes
> even close to being comparably stable. (I presume that vim is as
> good in that respect, but I have not tried it)
>
> On 6/15/09, David Brown wrote:
>> On Mon, Jun 15, 2009 at 05:59:27PM -0400, Josh Cough wrote:
>>
>>
>> > As someone who's fought through all the IDE problems with Scala for nearly
>> > two years I certainly understand your frustration. However, as Martin
>> > mentioned, IntelliJ's support for Scala is very nice. I haven't had
>> problems
>> > with it in several months. It's code navigation is excellent, and it has
>> > full ScalaTest support. Hopefully the other IDE's will be this nice when
>> and
>> > if you eventually try again, but if you can give IntelliJ a try, I think
>> > you'll be happy with it.
>> >
>>
>>  As a die-hard vim users, I've never been able to get past the
>>  frustration of the feature-started basic editing IDE's have to learn
>>  the additional features that the IDE's provide.
>>
>>  I've been writing a good bunch of code in Scala, just using vim.
>>  However, the vim Scala indent code gets rather frustrating.  I'm not
>>  actually sure that Scala can be indented with fully parsing it, but
>>  I've wondered if I should try to learn enough vim-script to try and
>>  improve this indenting.
>>
>>  David
>>
>

I missed this bit out in my original posting. I used to be a regular user of IDEA and was a big fan. I actually started out using their Scala plugin, but at the time it was pretty ropey. The feedback I got from their support forums was that they were reducing their development towards Scala support due to a perceived lack of a market - I think they were concentrating more on Groovy. If that's changed, and their Scala support has improved significantly, they I'd be pleased to give it another try.

Thanks for the suggestion,

Chris


2009/6/15 Josh Cough <joshcough@gmail.com>

As someone who's fought through all the IDE problems with Scala for nearly two years I certainly understand your frustration. However, as Martin mentioned, IntelliJ's support for Scala is very nice. I haven't had problems with it in several months. It's code navigation is excellent, and it has full ScalaTest support. Hopefully the other IDE's will be this nice when and if you eventually try again, but if you can give IntelliJ a try, I think you'll be happy with it.

On Mon, Jun 15, 2009 at 04:12:39PM -0700, David Hall wrote:

>> I've been writing a good bunch of code in Scala, just using vim.
>> However, the vim Scala indent code gets rather frustrating.  I'm not
>> actually sure that Scala can be indented with fully parsing it, but
>> I've wondered if I should try to learn enough vim-script to try and
>> improve this indenting.
>
>Same here. Care to give a list of things that bother you? One of my
>summer projects is to mess with vim's scala support.

I haven't found a pattern to it. I would guess that about 1/3 of the
time it indents a line correctly, 1/3 of the time it inserts extra
indentation, and 1/3 of the time it removes indentation that should be
there. Fortunately, it's easy to fix in vim with ^T/^D.

I've half been tempted to just turn it off. I wrote C code for many
years without the editor knowing how to indent it.

So, how do the other IDE's compute the indentation. The rules for
implicit semicolons, although they seem to make intuitive sense, seem
difficult to program in vim's little indent language.

>For instance, one personal pet peeve is the failure to indent the line
>a =>, especially in the instance " list map { i =>". That's an easy
>fix, and the first one I'm going to do.

I suspect the problem is deeper than just a few things to be fixed.
The indentation seems to be a handful of heuristics.

If anything annoys me, it's the "hot" characters that change the
indentation of a line I'm already typing '>' seems to do it.

David

Ray,

Thanks for the tip about SBT. i use the Scala emacs mode + maven and life is -- mostly -- good.

Best wishes,

--greg

On Mon, Jun 15, 2009 at 4:17 PM, Ray Racine <ray.racine@gmail.com> wrote:

FWIW, the Scala emacs mode, indentation, auto-completion, yasnippits, ctags, and .... for Scala are excellent.  SBT as a build tool is approaching outstanding and improving almost daily.

There are in fact areas where this combination is superior to the IDE environment, and a few where it is not.  For me, overall its no contest, IMHO emacs+sbt is an extremely effective combination and is the superior choice.

--
L.G. Meredith
Managing Partner
Biosimilarity LLC
1219 NW 83rd St
Seattle, WA 98117

+1 206.650.3740

http://biosimilarity.blogspot.com

On Mon, Jun 15, 2009 at 07:17:30PM -0400, Ray Racine wrote:

>FWIW, the Scala emacs mode, indentation, auto-completion, yasnippits, ctags,
>and .... for Scala are excellent. SBT as a build tool is approaching
>outstanding and improving almost daily.

How hard is it to build JNI/native code with SBT? That's what ended
up driving me away from Maven and back to ANT.

David

I was switching between Eclipse and Notepad, or rather between Eclispe and command-line, until I set up IntelliJ to run my stuff. Now it is just perfect... a little bit slow, but behaves as a regular ide, integrated with scalatest, and I don't think I'm going back.

2009/6/15 Skeptic . <skeptic2000@hotmail.com>

Hi,

It's a sad day for me, because it's the day I go back to Java for my day-to-day programming.

 

In the last months, I have learned and love Scala, the language, for being a hybrid OO-FP language like I dreamed of since I learned Scheme for SICP.

 

Using a simple text-editor, Scala is way more productive than Java, but under eclipse or even Netbeans, my recent experience tells me otherwise.

 

Sure, local type inference is nice, but a reliable camel-case auto-complete is too.

 

Sure, objects + apply '()' syntax is nice, but hitting ctrl+space to get the constructor's parameters of a 3rd party API is too.

Another cost I under-estimated? I chose Scala because I wanted to keep access to the useful libraries I was used to. For one thing, wrapping them in Scala

is not always so easy to do, but worse, it's often not enough to give them a true Scala feel, leading to Java-styled Scala code creeping up.

 

I know I would appreciate more the resulting code in Scala, but I'm sure the other members of the team would prefer the Java version because they could more easily navigate/explore it trough the IDE functionalities. Don't even get me started about refactoring it.

 

I can’t imagine how great could be the experience of Scala with an IDE as great as eclipse is for Java and I really hope someone will make it happen before Scala misses the opportunity to become a "mainstream" language.

It was a pleasure learning Scala and the support here was great. Thanks for that.

P.S. Yeah I have tried the latest release versions of both eclipse and Netbeans.

Avec Windows Live, vous gardez le contact avec tous vos amis au même endroit.

--
Thanks,
-Vlad

I remember those days. Yes, things have changed quite a lot since then.

Chris Lambrou wrote:
> I missed this bit out in my original posting. I used to be a regular
> user of IDEA and was a big fan. I actually started out using their
> Scala plugin, but at the time it was pretty ropey. The feedback I got
> from their support forums was that they were reducing their
> development towards Scala support due to a perceived lack of a market
> - I think they were concentrating more on Groovy. If that's changed,
> and their Scala support has improved significantly, they I'd be
> pleased to give it another try.
>
> Thanks for the suggestion,
>
> Chris
>
>
> 2009/6/15 Josh Cough >
>
> As someone who's fought through all the IDE problems with Scala
> for nearly two years I certainly understand your frustration.
> However, as Martin mentioned, IntelliJ's support for Scala is very
> nice. I haven't had problems with it in several months. It's code
> navigation is excellent, and it has full ScalaTest support.
> Hopefully the other IDE's will be this nice when and if you
> eventually try again, but if you can give IntelliJ a try, I think
> you'll be happy with it.
>
>

My solution to the desireto use vim is to use Netbeans with the JVI
plugin (http://jv.sourceforge.net). I do compilation and other
project-oriented tasks in a console using Maven, and have found this
combination to be quite productive.

Kris

On Mon, Jun 15, 2009 at 4:43 PM, David Brown wrote:
> On Mon, Jun 15, 2009 at 05:59:27PM -0400, Josh Cough wrote:
>
>> As someone who's fought through all the IDE problems with Scala for nearly
>> two years I certainly understand your frustration. However, as Martin
>> mentioned, IntelliJ's support for Scala is very nice. I haven't had
>> problems
>> with it in several months. It's code navigation is excellent, and it has
>> full ScalaTest support. Hopefully the other IDE's will be this nice when
>> and
>> if you eventually try again, but if you can give IntelliJ a try, I think
>> you'll be happy with it.
>
> As a die-hard vim users, I've never been able to get past the
> frustration of the feature-started basic editing IDE's have to learn
> the additional features that the IDE's provide.
>
> I've been writing a good bunch of code in Scala, just using vim.
> However, the vim Scala indent code gets rather frustrating.  I'm not
> actually sure that Scala can be indented with fully parsing it, but
> I've wondered if I should try to learn enough vim-script to try and
> improve this indenting.
>
> David
>

+1 for emacs and sbt.  my only gripe about sbt is that it doesn't work straight out of box with scala-2.8.0-snapshot just yet.  hopefully mark will have it sorted out before 2.8 goes beta.

On Tue, Jun 16, 2009 at 7:17 AM, Ray Racine <ray.racine@gmail.com> wrote:

FWIW, the Scala emacs mode, indentation, auto-completion, yasnippits, ctags, and .... for Scala are excellent.  SBT as a build tool is approaching outstanding and improving almost daily.

There are in fact areas where this combination is superior to the IDE environment, and a few where it is not.  For me, overall its no contest, IMHO emacs+sbt is an extremely effective combination and is the superior choice.

--
.......__o
.......\<,
....( )/ ( )...

Still going strong with eclipse... :)

On Mon, Jun 15, 2009 at 11:43 PM, Walter Chang <weihsiu@gmail.com> wrote:

+1 for emacs and sbt.  my only gripe about sbt is that it doesn't work straight out of box with scala-2.8.0-snapshot just yet.  hopefully mark will have it sorted out before 2.8 goes beta.

On Tue, Jun 16, 2009 at 7:17 AM, Ray Racine <ray.racine@gmail.com> wrote:

FWIW, the Scala emacs mode, indentation, auto-completion, yasnippits, ctags, and .... for Scala are excellent.  SBT as a build tool is approaching outstanding and improving almost daily.

There are in fact areas where this combination is superior to the IDE environment, and a few where it is not.  For me, overall its no contest, IMHO emacs+sbt is an extremely effective combination and is the superior choice.

--
.......__o
.......\<,
....( )/ ( )...

Chris,

I find Emacs/Bash still superior to any of the IDEs. The one exception
is for global renaming which the IDEs do well and Emacs doesn't.
Personally I find Eclipse huge and overcomplicated, NetBeans huge,
simpler but too Ant focused, IntelliJ huge, complicated and slow but
nonetheless the one that actually works for languages like Groovy and
Scala.

IDEs may be fashionable but are they doing the right thing or has
creeping featurism taken over?

On Mon, 2009-06-15 at 22:26 +0100, Chris Lambrou wrote:
> Recently I have also backed away from Scala development. I originally
> started out as a Java developer, then after a job change about 5 years
> ago, I switched to C# and the .NET eco-system, along with a foray into
> many various scripting languages. I briefly moved back to Java for a
> while, only to find that the language felt like it had completely and
> utterly stagnated. Then I discovered Scala. When I first started
> reading about Scala, I actually felt thrilled by what it offered -
> which is a feeling I honestly haven't felt about any programming
> language for almost twenty-five years. Initially, all went well...
>
> Alas, the honeymoon period is over for me. I was productive in Scala
> for about a month, but once my project reached a certain size and
> complexity, I started to run into snags. At the time, I was using the
> NetBeans plugin, which was fine, though somewhat buggy. However, I
> struggled to get the unit test frameworks to integrate reliably with
> NetBeans, and after much faffing about, I decided to switch to the
> Eclipse plugin, which appeared to me to be more mature. Alas, I didn't
> fare much better with Eclipse (in particular, Maven and Eclipse mix
> together fairly poorly), and I hit the last straw when I wrote some
> code which contained errors I couldn't track down simply by writing
> more detailed unit tests - I needed to use a debugger. I struggled for
> about three weeks, on and off, trying to get Eclipse to debug my Specs
> unit tests. In the end, utterly exasperated, I gave up. It took me two
> days to port everything to C#, and I'll be finishing the project using
> MonoDevelop.
>
> Sadly, my Scala journey has been ultimately rather disappointing. I
> still find Scala a very attractive language that holds lots of
> promise, but its relatively poor IDE support, including the inability
> to debug applications, means that I can't afford to spend any more of
> my time struggling with it - I have a living to earn and projects that
> need to be completed sooner, not later.
>
> Maybe this time next year, I'll give the Scala IDEs another try in
> earnest.
>
> Chris

>

On Mon, 2009-06-15 at 22:26 +0100, Chris Lambrou wrote:
> I struggled for about three weeks, on and off, trying to get Eclipse
> to debug my Specs unit tests.

Not that it helps you much, but that works perfectly fine for me. What
did you use for maven integration, mvn eclipse:eclipse?

Best,
Ismael

On Mon, 2009-06-15 at 16:33 -0700, David Brown wrote:
> On Mon, Jun 15, 2009 at 07:17:30PM -0400, Ray Racine wrote:
>
> >FWIW, the Scala emacs mode, indentation, auto-completion, yasnippits, ctags,
> >and .... for Scala are excellent. SBT as a build tool is approaching
> >outstanding and improving almost daily.
>
> How hard is it to build JNI/native code with SBT? That's what ended
> up driving me away from Maven and back to ANT.

Or for those people who get hacked off with XML, there is Gradle or
Gant.

Also of course there are SCons and Waf.

Whilst it is always good to have a new build tool with new approaches
and features, progressing the state of the art, having a build tool that
is specific to one language creates an instant ghetto of stagnation. So
even though SBT may be good for Scala, I wonder if a better approach
might be to ensure there are good plugins for Gradle, SCons, Waf, Ant
and Maven?

Am 16.06.2009 08:39, Russel Winder schrieb:
> Chris,
>
> I find Emacs/Bash still superior to any of the IDEs. The one exception
> is for global renaming which the IDEs do well and Emacs doesn't.
I have to admit I have no idead about the power of Emacs... but saying
the global renaming is the only thing in IDEs which differ is not
believable ;-)

I guess the default things like syntax highlighting, code completion and
compile problems can also be done in Emacs, but I still believe that
coding in an IDE is faster and more reliable than in an editor.

Just a simple example:

- You dont need to think about naming your variables / methods at the
moment you create them as you can refactor it
- you can (and should) write code from behind - first the caller then
the implementation.
- create the methods you just wrote, create the getter and setters for a
class.
- Change the signature of a method, inline a method, extract a method,
invert if statements
- start the unit tests
- move methods
- code checking tools

and so on and so on... Refactoring is an essentiell process in
programming as decisions should not made to early. I maybe wrong but
from my Emacs days I couldnt do all that stuff in a easy and quick fix way.

So IDEs - in my opinion - are essentiell for a reliable and fast process
of development.

but just my 2cents.
Cheers

PS: sorry for spamming the mailing list with that

Truly, we should be using butterflies!

http://xkcd.com/378/



On Tue, Jun 16, 2009 at 8:23 AM, Andreas Jöcker <a.joecker@gis-systemhaus.de> wrote:

Am 16.06.2009 08:39, Russel Winder schrieb:
> Chris,
>
> I find Emacs/Bash still superior to any of the IDEs.  The one exception
> is for global renaming which the IDEs do well and Emacs doesn't.
I have to admit I have no idead about the power of Emacs... but saying
the global renaming is the only thing in IDEs which differ is not
believable ;-)

I guess the default things like syntax highlighting, code completion and
compile problems can also be done in Emacs, but I still believe that
coding in an IDE is faster and more reliable than in an editor.

Just a simple example:

- You dont need to think about naming your variables / methods at the
moment you create them as you can refactor it
- you can (and should) write code from behind - first the caller then
the implementation.
- create the methods you just wrote, create the getter and setters for a
class.
- Change the signature of a method, inline a method, extract a method,
invert if statements
- start the unit tests
- move methods
- code checking tools

and so on and so on... Refactoring is an essentiell process in
programming as decisions should not made to early. I maybe wrong but
from my Emacs days I couldnt do all that stuff in a easy and quick fix way.

So IDEs - in my opinion - are essentiell for a reliable and fast process
of development.

but just my 2cents.
Cheers

PS: sorry for spamming the mailing list with that

--

Andreas Jöcker
GiS - Gesellschaft für integrierte Systemplanung mbH
Junkersstr. 2
69469 Weinheim

E-Mail   a.joecker@gis-systemhaus.de
Telefon +49 6201 503-59
Fax     +49 6201 503-66

Gesellschaft für integrierte Systemplanung mbH
Geschäftsführer: Eckhard Haffmann, Alfred Gai, Bernd Heselmann
Sitz der Gesellschaft: Zeppelinstr. 11 - 91052 Erlangen
Amtsgericht Fürth/Bayern - Handelsregister-Nr. HRB 3435

You can do all those things, well, except inlining methods, extracting
methods and inverting ifs, with Scala plus any text editor, but
manually, knowing when you've finished because you get no more compile
errors. I realise this is less automatic, and agree that automation
is good.

But then half the refactorings in Eclipse (for Java) need some manual
labour afterwards, because the actual refactoring you want is slightly
different to those provided.

2009/6/16 Andreas Jöcker :
> Am 16.06.2009 08:39, Russel Winder schrieb:
>> Chris,
>>
>> I find Emacs/Bash still superior to any of the IDEs.  The one exception
>> is for global renaming which the IDEs do well and Emacs doesn't.
> I have to admit I have no idead about the power of Emacs... but saying
> the global renaming is the only thing in IDEs which differ is not
> believable ;-)
>
> I guess the default things like syntax highlighting, code completion and
> compile problems can also be done in Emacs, but I still believe that
> coding in an IDE is faster and more reliable than in an editor.
>
> Just a simple example:
>
> - You dont need to think about naming your variables / methods at the
> moment you create them as you can refactor it
> - you can (and should) write code from behind - first the caller then
> the implementation.
> - create the methods you just wrote, create the getter and setters for a
> class.
> - Change the signature of a method, inline a method, extract a method,
> invert if statements
> - start the unit tests
> - move methods
> - code checking tools
>
> and so on and so on... Refactoring is an essentiell process in
> programming as decisions should not made to early. I maybe wrong but
> from my Emacs days I couldnt do all that stuff in a easy and quick fix way.
>
> So IDEs - in my opinion - are essentiell for a reliable and fast process
> of development.
>
> but just my 2cents.
> Cheers
>
> PS: sorry for spamming the mailing list with that
>
> --
>
> Andreas Jöcker
> GiS - Gesellschaft für integrierte Systemplanung mbH
> Junkersstr. 2
> 69469 Weinheim
>
> E-Mail   a.joecker@gis-systemhaus.de
> Telefon +49 6201 503-59
> Fax     +49 6201 503-66
>
> Gesellschaft für integrierte Systemplanung mbH
> Geschäftsführer: Eckhard Haffmann, Alfred Gai, Bernd Heselmann
> Sitz der Gesellschaft: Zeppelinstr. 11 - 91052 Erlangen
> Amtsgericht Fürth/Bayern - Handelsregister-Nr. HRB 3435
>
>

> > I find Emacs/Bash still superior to any of the IDEs.
[...]
> I have to admit I have no idead about the power of Emacs... but saying
> the global renaming is the only thing in IDEs which differ is not
> believable ;-)
[...]
> I guess the default things like syntax highlighting, code
> completion and
> compile problems can also be done in Emacs, but I still believe that
> coding in an IDE is faster and more reliable than in an editor.

Well, I do not know what exactly emacs is able to provide,
although I have the impression that it is more capable than
vim, which OTOH is my favorite editor and worked very well
for learning different prog languages and doing scripting a.s.o.
And was indeed my substitute for the missing GroovyConsole in
Scala.

BUT: Talking about Scala is in my opinion talking about the
future of enterprise development, and I suppose that
emacs doesn't provide all the capabilities of an Integrated(!)DE
which are used in large scale EE projects:

* Managing multi-language, multi-project workareas
* Support for helpful information (e.g.javadoc) through popup-help
* Integration of not only textual representations but also
graphical ones:
. UML design tools, or reverse engineering UML-viewers
. Database connectivity and visualisation plugins
. Visualisation of VCS-state, warn/error levels a.s.o.
. Hierarchical representations not only of packages but
also of type hierarchies, unit test results, VCS repositories
* Task-management plugins including bug tracker integration
* multi-view debugging sessions
* AND: The ability to program the IDE itsself without having
to learn YAPL : Vim-Script or emacsLISP or whatelse.
Plugins are JVM-language products, possibly based on OSGi and
other techniques also used in the app development anyway.

So privately I play with Netbeans which works well enough for
my little projects, and my company is dedicated to Eclipse as
supported-by-techdep. platform. Scala's career in enterprises
will indeed depend on good and continually improving IDE support, which I expect to

Refactoring is nice, really!
But on larger systems I'm finding that the biggest pain point is when it comes to just exploring a codebase, specifically:

• An outline view showing the structure of the program, either by packages/classes or by directories/files/classes, ideally both should be available.  This is especially important given Scala's ability to deeply nest structure and the separation of class naming and file naming.  As with Java editing in Eclipse, the outline must be able to sync with the code currently being edited.
• Ctrl+click, or equivalent, to navigate from the use-site of an identifier to the declaration-site.
• Ctrl+Shift+T, or equivalent, to quickly open a type of a known name

My gut feeling is that this is more important than refactoring, especially at this stage in the evolution of Scala; the language is currently growing rapidly in terms of developer mindshare and is attracting new users, many of whom will begin learning it by looking at pre-existing code such as lift.  If people are scared away by a poor first experience with the tools, then they might never look at the language again, and we'll be missing a golden opportunity to inspire new advocates.

Of course, the power tools *will* have to arrive at some point, but they're just that tiny bit less urgent.



On Tue, Jun 16, 2009 at 9:23 AM, Ricky Clarkson <ricky.clarkson@gmail.com> wrote:

You can do all those things, well, except inlining methods, extracting
methods and inverting ifs, with Scala plus any text editor, but
manually, knowing when you've finished because you get no more compile
errors.  I realise this is less automatic, and agree that automation
is good.

But then half the refactorings in Eclipse (for Java) need some manual
labour afterwards, because the actual refactoring you want is slightly
different to those provided.

2009/6/16 Andreas Jöcker <a.joecker@gis-systemhaus.de>:
> Am 16.06.2009 08:39, Russel Winder schrieb:
>> Chris,
>>
>> I find Emacs/Bash still superior to any of the IDEs.  The one exception
>> is for global renaming which the IDEs do well and Emacs doesn't.
> I have to admit I have no idead about the power of Emacs... but saying
> the global renaming is the only thing in IDEs which differ is not
> believable ;-)
>
> I guess the default things like syntax highlighting, code completion and
> compile problems can also be done in Emacs, but I still believe that
> coding in an IDE is faster and more reliable than in an editor.
>
> Just a simple example:
>
> - You dont need to think about naming your variables / methods at the
> moment you create them as you can refactor it
> - you can (and should) write code from behind - first the caller then
> the implementation.
> - create the methods you just wrote, create the getter and setters for a
> class.
> - Change the signature of a method, inline a method, extract a method,
> invert if statements
> - start the unit tests
> - move methods
> - code checking tools
>
> and so on and so on... Refactoring is an essentiell process in
> programming as decisions should not made to early. I maybe wrong but
> from my Emacs days I couldnt do all that stuff in a easy and quick fix way.
>
> So IDEs - in my opinion - are essentiell for a reliable and fast process
> of development.
>
> but just my 2cents.
> Cheers
>
> PS: sorry for spamming the mailing list with that
>
> --
>
> Andreas Jöcker
> GiS - Gesellschaft für integrierte Systemplanung mbH
> Junkersstr. 2
> 69469 Weinheim
>
> E-Mail   a.joecker@gis-systemhaus.de
> Telefon +49 6201 503-59
> Fax     +49 6201 503-66
>
> Gesellschaft für integrierte Systemplanung mbH
> Geschäftsführer: Eckhard Haffmann, Alfred Gai, Bernd Heselmann
> Sitz der Gesellschaft: Zeppelinstr. 11 - 91052 Erlangen
> Amtsgericht Fürth/Bayern - Handelsregister-Nr. HRB 3435
>
>

Sorry, unfinished message was sent accidentally
(Does anyone know how to reconfigure this damn
ctrl-enter in outlook ?? :-( )

-----------> the complete one:

> > I find Emacs/Bash still superior to any of the IDEs.
[...]
> I have to admit I have no idead about the power of Emacs... but saying
> the global renaming is the only thing in IDEs which differ is not
> believable ;-)
[...]
> I guess the default things like syntax highlighting, code
> completion and
> compile problems can also be done in Emacs, but I still believe that
> coding in an IDE is faster and more reliable than in an editor.

Well, I do not know what exactly emacs is able to provide,
although I have the impression that it is more capable than
vim, which OTOH is my favorite editor and worked very well
for learning different prog languages and doing scripting a.s.o.
And was indeed my substitute for the missing GroovyConsole in
Scala.

BUT: Talking about Scala is in my opinion talking about the
future of enterprise development, and I suppose that
emacs doesn't provide all the capabilities of an Integrated(!)DE
which are used in large scale EE projects:

* Managing multi-language, multi-project workareas
* Support for helpful information (e.g.javadoc) through popup-help
* Integration of not only textual representations but also
graphical ones:
. UML design tools, or reverse engineering UML-viewers
. Database connectivity and visualisation plugins
. Visualisation of VCS-state, warn/error levels a.s.o.
. Hierarchical representations not only of packages but
also of type hierarchies, unit test results, VCS repositories
* Task-management plugins including bug tracker integration
* multi-view debugging sessions
* AND: The ability to program the IDE itsself without having
to learn YAPL : Vim-Script or emacsLISP or whatelse.
Plugins are JVM-language products, possibly based on OSGi and
other techniques also used in the app development anyway.

So privately I play with Netbeans which works well enough for
my little projects, and my company is dedicated to Eclipse as
supported-by-techdep. platform.
Scala's career in enterprises will indeed depend on good and
continually improving IDE support, which I expect to see in the
future anyway with Scala finding more and more interested people
and by that contributors.

Hopefully Sun/Oracle will see the many chances too and not
regard Scala being a rival.

Thanks for listening
Det

Just to give a quick run-down on the state of Scala IDE's, as I see it:

The IntelliJ IDE has matured really well; JetBrains has poured a lot
of good work into it. They were actively marketing it at JavaOne and
have seen a lot of interest form the public. IntelliJ is the only IDE
that uses their own presentation compiler, whereas the other two IDEs
use scalac.

Netbeans has a fairly conservative and robust interface with scalac. I
have not used it myself. What I hear from others is that it works
pretty well, except maybe that it can be a bit slow on large files and
projects.

The current Eclipse IDE is the most ambitious in what concerns to
incrementalilty. In effect it tries to turn scalac into an incremental
compiler to be used by the IDE. The potential gain is very fast
updates even for large projects and files. But in practice this has
turned out to be an uneasy marriage. scalac is not made to be
incremental (and, in my mind, it should not be, because that would
pose too many constraints on the language and compilation scheme).

What we try to do:

I am currently working with Miles Sabin and Iulian Dragos on a
redesigned IDE / compiler interface. We plan to deploy this first for
Eclipse, but it should work equally well for Netbeans, or for Visual
Studio in our recently revived push to do a .NET version of Scala
within the ProgLab project. Instead of hacking incremental compilation
into scalac, we make use of laziness, which is is already inherent in
scalac's architecture. In essence, it's very easy for the scalac
typechecker to zoom in on a particular code point, without regarding
any subtrees that precede or follow it. I believe this will be fast
enough for hyperlinking and code completion even on very large files.
And it will dramatically reduce the width of the interface between IDE
and compiler, as well as improving its reliability.

Cheers

Andreas,

On Tue, 2009-06-16 at 09:23 +0200, Andreas Jöcker wrote:
[ . . . ]
> I guess the default things like syntax highlighting, code completion and
> compile problems can also be done in Emacs, but I still believe that
> coding in an IDE is faster and more reliable than in an editor.

In the end there is personal preference: an individual works best using
the tools they find it easiest and most comfortable to work with. What
is right for one person may, or may not, be right for another.

> Just a simple example:
>
> - You dont need to think about naming your variables / methods at the
> moment you create them as you can refactor it

This is an inappropriate approach in my view. Care and attention to
detail, including variable names, should be important at all times.
Using "refactor" features is hacking for laziness.

> - you can (and should) write code from behind - first the caller then
> the implementation.

Actually I'd write the test first and then the code. :-)

> - create the methods you just wrote, create the getter and setters for a
> class.

Assuming you need setters and getters, not all classes need them, and if
you don't need them I think you shouldn't provide them.

> - Change the signature of a method, inline a method, extract a method,
> invert if statements

AST-based editing (rather than regexp-based editing) does have its
plusses.

> - start the unit tests

"gradle test" on the command line does this for me, and the tests
generally run faster than from in an IDE. The only difference is that
you don't get lots of unnecessary graphics to watch whilst waiting.

> - move methods

AST-based editing does have its plusses.

> - code checking tools

"gradle cobertura" on the command line generally does this for me.

> and so on and so on... Refactoring is an essentiell process in
> programming as decisions should not made to early. I maybe wrong but
> from my Emacs days I couldnt do all that stuff in a easy and quick fix way.

I guess this leads to a quasi-religious debate about what refactoring
is. I believe that IDEs are devaluing the meaning of the term by
applying it to various AST-based editing actions that do not really
apply a refactoring transform.

On the other hand any change to the code that does not cause the tests
to fail could be deemed to be a refactoring.

In general, IDEs do beat Emacs when it comes to serious global
refactoring. This comes back to being AST based rather than regexp
based.

> So IDEs - in my opinion - are essentiell for a reliable and fast process
> of development.

If it works for you then go for it. There are occasions when I use an
IDE but generally I find them too heavywieght. OK Emacs is hardly
lightweight (it does after all claim to be a kitchen sink as well as an
editor :-) but once you have an edit server running, adding new buffers
is very lighweight.

For me having each buffer in a separate frame is a huge plus. The
constraint that an IDE forces me into single frame working with only
tabs is a huge downside. OK there are lots of other sub-frames in lots
of pretty organizations, but for editing I want the flexibility that
using the window manager offers me.

But this is my preferences, which is not for others.

> but just my 2cents.
> Cheers
>
> PS: sorry for spamming the mailing list with that

Exchanging ideas and experiences is a crucial part of community and
culture. As long as we all present our ideas as our experience,
potentially helpful to others, that is good. The only time to worry is
when someone says something along the lines of "this is my experience, I
am right, and unless you agree with me you are subhuman". Or words to
that effect. Fortunately on the email lists I read, this very, very
rarely happens.

>> Just a simple example:
>>
>> - You dont need to think about naming your variables / methods at the
>> moment you create them as you can refactor it
>>
>
> This is an inappropriate approach in my view. Care and attention to
> detail, including variable names, should be important at all times.
> Using "refactor" features is hacking for laziness.
>
definitely not... If i write a method / variable with only a vague
imagination of what the method / variable provides (and you cant tell me
that at every point in your process you exactly know what one thing will
do) I dont want to waste my time with minutes of thinking "mhm what does
the method do - how should it be called - is A or B better"
You can bet at the end you name it C...
of course this does NOT mean just to write any name - of course at the
time of producing your code the names should be fully self-explaining.
This was the intension I wanted to say
>> - you can (and should) write code from behind - first the caller then
>> the implementation.
>>
>
> Actually I'd write the test first and then the code. :-)
>
Thats honorable and I do the same... but when it comes to getting the
red bar green you have to start the implementation and then it is
preferable to start at the end....
>> - create the methods you just wrote, create the getter and setters for a
>> class.
>>
>
> Assuming you need setters and getters, not all classes need them, and if
> you don't need them I think you shouldn't provide them.
>
of course - it was just a simple example of the power of the system
>> - Change the signature of a method, inline a method, extract a method,
>> invert if statements
>>
>
> AST-based editing (rather than regexp-based editing) does have its
> plusses.
>
>
cant say anything to that... dont know how Eclipse works in the
background - it just does :)

Ah... you'r not using pure Emacs/Shell as I thought - if you are using
gradle that changes things a bit ;-)

Bygones

i think what Dirk & Kevin wrote previously are probable more important
points than I said...

Its fighting over the holy grail... we use what we are used to and what
we are prefer - if awesome tools are the result of either ways... go ahead

At the end no one cares about the tool you used to create your killer
app... so :)

Cheers
Andreas

On Tue, Jun 16, 2009 at 5:08 PM, martin odersky wrote:
> Just to give a quick run-down on the state of Scala IDE's, as I see it:
>
> The IntelliJ IDE has matured really well; JetBrains has poured a lot
> of good work into it. They were actively marketing it at JavaOne and
> have seen a lot of interest form the public. IntelliJ is the only IDE
> that uses their own presentation compiler, whereas the other two IDEs
> use scalac.
>
> Netbeans has a fairly conservative and robust interface with scalac. I
> have not used it myself. What I hear from others is that it works
> pretty well, except maybe that it can be a bit slow on large files and
> projects.
>
> The current Eclipse IDE is the most ambitious in what concerns to
> incrementalilty. In effect it tries to turn scalac into an incremental
> compiler to be used by the IDE. The potential gain is very fast
> updates even for large projects and files. But in practice this has
> turned out to be an uneasy marriage. scalac is not made to be
> incremental (and, in my mind, it should not be, because that would
> pose too many constraints on the language and compilation scheme).
>
> What we try to do:
>
> I am currently working with Miles Sabin and Iulian Dragos on a
> redesigned IDE / compiler interface. We plan to deploy this first for
> Eclipse, but it should work equally well for Netbeans, or for Visual
> Studio in our recently revived push to do a .NET version of Scala
> within the ProgLab project. Instead of hacking incremental compilation
> into scalac, we make use of laziness, which is is already inherent in
> scalac's architecture. In essence, it's very easy for the scalac
> typechecker to zoom in on a particular code point, without regarding
> any subtrees that precede or follow it. I believe this will be fast
> enough for hyperlinking and code completion even on very large files.
> And it will dramatically reduce the width of the interface between IDE
> and compiler, as well as improving its reliability.

That will be cool, I'll follow the progress, for NetBeans.

Cheers
Caoyuan

On Tue, Jun 16, 2009 at 11:21 AM, Caoyuan wrote:
> On Tue, Jun 16, 2009 at 5:08 PM, martin odersky wrote:
>> Just to give a quick run-down on the state of Scala IDE's, as I see it:
>>
>> The IntelliJ IDE has matured really well; JetBrains has poured a lot
>> of good work into it. They were actively marketing it at JavaOne and
>> have seen a lot of interest form the public. IntelliJ is the only IDE
>> that uses their own presentation compiler, whereas the other two IDEs
>> use scalac.
>>
>> Netbeans has a fairly conservative and robust interface with scalac. I
>> have not used it myself. What I hear from others is that it works
>> pretty well, except maybe that it can be a bit slow on large files and
>> projects.
>>
>> The current Eclipse IDE is the most ambitious in what concerns to
>> incrementalilty. In effect it tries to turn scalac into an incremental
>> compiler to be used by the IDE. The potential gain is very fast
>> updates even for large projects and files. But in practice this has
>> turned out to be an uneasy marriage. scalac is not made to be
>> incremental (and, in my mind, it should not be, because that would
>> pose too many constraints on the language and compilation scheme).
>>
>> What we try to do:
>>
>> I am currently working with Miles Sabin and Iulian Dragos on a
>> redesigned IDE / compiler interface. We plan to deploy this first for
>> Eclipse, but it should work equally well for Netbeans, or for Visual
>> Studio in our recently revived push to do a .NET version of Scala
>> within the ProgLab project. Instead of hacking incremental compilation
>> into scalac, we make use of laziness, which is is already inherent in
>> scalac's architecture. In essence, it's very easy for the scalac
>> typechecker to zoom in on a particular code point, without regarding
>> any subtrees that precede or follow it. I believe this will be fast
>> enough for hyperlinking and code completion even on very large files.
>> And it will dramatically reduce the width of the interface between IDE
>> and compiler, as well as improving its reliability.
>
> That will be cool, I'll follow the progress, for NetBeans.
>
I'm looking forward to that! We'll continue to drop updates to trunk
next week, once Miles is back from vacation. The main stuff on the
compiler side is in package nsc.interactive.

Cheers

On Tuesday June 16 2009, Kevin Wright wrote:
> Truly, we should be using butterflies!
>
> http://xkcd.com/378/

That's what I keep saying!

RRS

On Monday June 15 2009, Russel Winder wrote:
> Chris,
>
> I find Emacs/Bash still superior to any of the IDEs. The one
> exception is for global renaming which the IDEs do well and Emacs
> doesn't. Personally I find Eclipse huge and overcomplicated, NetBeans
> huge, simpler but too Ant focused, IntelliJ huge, complicated and
> slow but nonetheless the one that actually works for languages like
> Groovy and Scala.
>
> IDEs may be fashionable but are they doing the right thing or has
> creeping featurism taken over?

My impression is that JetBrains (IDEA's publisher) rarely says "no" to a
feature request. I don't think this is generally a good thing.

I like IDEA well enough and given that I have never found any IDE I
tried before (going back to my C/C++ days) at all palatable, that's
about the best I can hope for.

However, I would be a lot less productive if I couldn't get to a shell,
Vim, sed, egrep, sort, etc. I write little (and sometimes not so
little) shell scripts at the drop of a hat. And since IDEA has let
plain old text search-and-replace slowly rot, I sometimes use jEdit,
whose multi-file search-and-replace is the best I've found anywhere. I
especially like its ability to find and replace across line boundaries.

Randall Schulz

They said no to a feature request of mine. :(

I suggested that, say, new Function() { public
Integer f(String s) { return s.length(); } } be folded to s =>
s.length().

This has been implemented for Eclipse in the form of lambda4jdt, which
works but is at an early stage.

2009/6/16 Randall R Schulz :
> On Monday June 15 2009, Russel Winder wrote:
>> Chris,
>>
>> I find Emacs/Bash still superior to any of the IDEs.  The one
>> exception is for global renaming which the IDEs do well and Emacs
>> doesn't. Personally I find Eclipse huge and overcomplicated, NetBeans
>> huge, simpler but too Ant focused, IntelliJ huge, complicated and
>> slow but nonetheless the one that actually works for languages like
>> Groovy and Scala.
>>
>> IDEs may be fashionable but are they doing the right thing or has
>> creeping featurism taken over?
>
> My impression is that JetBrains (IDEA's publisher) rarely says "no" to a
> feature request. I don't think this is generally a good thing.
>
> I like IDEA well enough and given that I have never found any IDE I
> tried before (going back to my C/C++ days) at all palatable, that's
> about the best I can hope for.
>
> However, I would be a lot less productive if I couldn't get to a shell,
> Vim, sed, egrep, sort, etc. I write little (and sometimes not so
> little) shell scripts at the drop of a hat. And since IDEA has let
> plain old text search-and-replace slowly rot, I sometimes use jEdit,
> whose multi-file search-and-replace is the best I've found anywhere. I
> especially like its ability to find and replace across line boundaries.
>
>
> Randall Schulz
>

On Tuesday June 16 2009, Ricky Clarkson wrote:
> They said no to a feature request of mine. :(

Me, too, but I'm a complete oddball.

> I suggested that, say, new Function() { public
> Integer f(String s) { return s.length(); } } be folded to s =>
> s.length().

You wanted this as a surface-level presentation thing? The code would
remain Java (naturally) but would be presented in a more Scala-ish /
Haskell-esque form?

I'm not surprised they didn't go for that.

> This has been implemented for Eclipse in the form of lambda4jdt,
> which works but is at an early stage.

Interesting. Too bad Eclipse is so obnoxious about the way it handles
basic text selection...

This idea reminds me again of my wish for a programming editor that used
a deep knowledge of the language's syntax and semantics to present code
to each developer in the format they prefer while keeping a canonical
representations (possibly an AST) as the underlying code (very few
people like my code formatting choices). Integration with source-code
management might be an issue, especially if an AST were the underlying
representation, but not an insurmountable one.

I've just recently started learning about Stratego/XT and it makes me
wish for an SDF encoding of the Scala grammar.

Randall Schulz

On Tue, 2009-06-16 at 07:33 -0700, Randall R Schulz wrote:
[. . . ]
> This idea reminds me again of my wish for a programming editor that used
> a deep knowledge of the language's syntax and semantics to present code
> to each developer in the format they prefer while keeping a canonical
> representations (possibly an AST) as the underlying code (very few
> people like my code formatting choices). Integration with source-code
> management might be an issue, especially if an AST were the underlying
> representation, but not an insurmountable one.

During the 1980s there was a lot of work on syntax directed editors, and
indeed variant rendering as you are thinking of. Unfortunately,
computing resources were such that they were slow. Performance being
everything (at least in decision makers minds), Emacs and Vi were the
only choices, unless you were using CP/M, MSDOS etc. in which case it
was whichever text editor you loaded up. Then of course GUIs became the
rage so anything text-oriented was abandoned in favour of "point and
shoot".

Funny how all the IDEs are now realizing that syntax directed editing
can actually be a good thing for program development. (Yes I know this
is a statement contrary to my position in another thread :-) Perhaps
Eclipse/NetBeans/IDEA will do the right thing and do syntax directed
editing properly.

What goes around comes around.

Perhaps the Scala plugin for Eclipse could be at the forefront of this?

I suspect not though as integration with the current Eclipse editor will
be necessary. Sad.

[ . . . ]

On 16-Jun-09, at 7:01 AM, Ricky Clarkson wrote:

> They said no to a feature request of mine. :(
>
> I suggested that, say, new Function() { public
> Integer f(String s) { return s.length(); } } be folded to s =>
> s.length().

They're getting there... :)

http://blogs.jetbrains.com/idea/2009/03/closure-folding-in-intellij-
idea-9-maia/

-0xe1a

On Tue, 2009-06-16 at 11:25 +0200, Andreas Jöcker wrote:
[ . . . ]
> definitely not... If i write a method / variable with only a vague
> imagination of what the method / variable provides (and you cant tell me
> that at every point in your process you exactly know what one thing will
> do) I dont want to waste my time with minutes of thinking "mhm what does
> the method do - how should it be called - is A or B better"
> You can bet at the end you name it C...
> of course this does NOT mean just to write any name - of course at the
> time of producing your code the names should be fully self-explaining.
> This was the intension I wanted to say

It really comes down to how good the programmer is, and how experimental
the code is.

The problem for me is that far too many average programmers are getting
overly lazy and slipshod on the assumption that they will "fix it
later". They then find themselves in a spaghetti of ideas and partial
implementation and it takes ages to dig themselves out of it.
Exploratory programming is an important tool and technique -- indeed
most of my programming is of this sort these days as I am not doing
production maintenance work -- but in most situations just a few minutes
extra reflective thought up front can save hours of work later.

I don't think we are actually disagreeing!

[ . . . ]

> Its fighting over the holy grail... we use what we are used to and what
> we are prefer - if awesome tools are the result of either ways... go ahead

Argument, as long as it is in good spirit, and as long it doesn't get
overly quasi-religious has to be good for progressing the subject.

The only danger of sticking with current preference is that an indivdual
might miss an improvement they will like if they try it.
Open-mindedness is important.

> At the end no one cares about the tool you used to create your killer
> app... so :)

Indeed!

It is unfortunate though that the term "killer app" has got into the
language. It implies that all super successful software is about
killing.

martin odersky wrote:

> I sympathize with your sentiment, because I was also frustrated a long
> time with the
> state of the Scala Eclipse IDE. It does seem to work well for some
> people, but for me, and it seems also for you, it's too shaky to
> support large projects reliably. That's why I have finally taken the
> plunge and got personally involved in rewriting the IDE/compiler
> interface. Judge us again in 2-3 months, please. Meanwhile, you might
> also consider IntelliJ; it has a very nice Scala IDE today.

Are there also plans to enhance/support the NetBeans Scala plugin? I've
compared the latest Eclipse and NetBeans releases and I just have the
feeling that Eclipse feels a bit kludgy regarding its plugin architecture.

You have to add this or that plugin repository manually and take care of
the dependencies. In NetBeans I can immediately add almost all plugins I
need through the IDE. NetBeans just seems to be "of a piece" here. Also
the Maven integrations is much better in NetBeans at the moment.

I just hope that the Scala community doesn't focus on Eclipse only.

I suspect that Netbeans won't be supported or developed further once the Oracle takeover of Sun is complete.
So it would probably be better to focus all our efforts on the eclipse plugin...

I agree with you that Maven support in eclipse is still very poor, so hoping to see some good things come out of the IAM project!


On Wed, Jun 17, 2009 at 1:42 PM, Sven Jacobs <sven.jacobs@web.de> wrote:

martin odersky wrote:

> I sympathize with your sentiment, because I was also frustrated a long
> time with the
> state of the Scala Eclipse IDE. It does seem to work well for some
> people, but for me, and it seems also for you, it's too shaky to
> support large projects reliably. That's why I have finally taken the
> plunge and got personally involved in rewriting the IDE/compiler
> interface. Judge us again in 2-3 months, please. Meanwhile, you might
> also consider IntelliJ; it has a very nice Scala IDE today.

Are there also plans to enhance/support the NetBeans Scala plugin? I've
compared the latest Eclipse and NetBeans releases and I just have the
feeling that Eclipse feels a bit kludgy regarding its plugin architecture.

You have to add this or that plugin repository manually and take care of
the dependencies. In NetBeans I can immediately add almost all plugins I
need through the IDE. NetBeans just seems to be "of a piece" here. Also
the Maven integrations is much better in NetBeans at the moment.

I just hope that the Scala community doesn't focus on Eclipse only.

Kevin Wright wrote:

> I suspect that Netbeans won't be supported or developed further once the
> Oracle takeover of Sun is complete.
> So it would probably be better to focus all our efforts on the eclipse
> plugin...

I personally wouldn't bet on that horse unless it's proven! Even if
Oracle kills commercial support NetBeans would live on since it's open
source.

Who knows, perhaps it even gets a boost when Oracle adopts it in favour of their JBuilder clone
-Carsten

On Wed, Jun 17, 2009 at 2:57 PM, Kevin Wright <kev.lee.wright@googlemail.com> wrote:

I suspect that Netbeans won't be supported or developed further once the Oracle takeover of Sun is complete.
So it would probably be better to focus all our efforts on the eclipse plugin...

I agree with you that Maven support in eclipse is still very poor, so hoping to see some good things come out of the IAM project!


On Wed, Jun 17, 2009 at 1:42 PM, Sven Jacobs <sven.jacobs@web.de> wrote:

martin odersky wrote:

> I sympathize with your sentiment, because I was also frustrated a long
> time with the
> state of the Scala Eclipse IDE. It does seem to work well for some
> people, but for me, and it seems also for you, it's too shaky to
> support large projects reliably. That's why I have finally taken the
> plunge and got personally involved in rewriting the IDE/compiler
> interface. Judge us again in 2-3 months, please. Meanwhile, you might
> also consider IntelliJ; it has a very nice Scala IDE today.

Are there also plans to enhance/support the NetBeans Scala plugin? I've
compared the latest Eclipse and NetBeans releases and I just have the
feeling that Eclipse feels a bit kludgy regarding its plugin architecture.

You have to add this or that plugin repository manually and take care of
the dependencies. In NetBeans I can immediately add almost all plugins I
need through the IDE. NetBeans just seems to be "of a piece" here. Also
the Maven integrations is much better in NetBeans at the moment.

I just hope that the Scala community doesn't focus on Eclipse only.

On Wed, Jun 17, 2009 at 4:04 PM, Carsten Saager <csaager@gmail.com> wrote:

Who knows, perhaps it even gets a boost when Oracle adopts it in favour of their JBuilder clone

Or we all have to switch to JDeveloper... ;)
 

-Carsten

On Wed, Jun 17, 2009 at 2:57 PM, Kevin Wright <kev.lee.wright@googlemail.com> wrote:

I suspect that Netbeans won't be supported or developed further once the Oracle takeover of Sun is complete.
So it would probably be better to focus all our efforts on the eclipse plugin...

I agree with you that Maven support in eclipse is still very poor, so hoping to see some good things come out of the IAM project!


On Wed, Jun 17, 2009 at 1:42 PM, Sven Jacobs <sven.jacobs@web.de> wrote:

martin odersky wrote:

> I sympathize with your sentiment, because I was also frustrated a long
> time with the
> state of the Scala Eclipse IDE. It does seem to work well for some
> people, but for me, and it seems also for you, it's too shaky to
> support large projects reliably. That's why I have finally taken the
> plunge and got personally involved in rewriting the IDE/compiler
> interface. Judge us again in 2-3 months, please. Meanwhile, you might
> also consider IntelliJ; it has a very nice Scala IDE today.

Are there also plans to enhance/support the NetBeans Scala plugin? I've
compared the latest Eclipse and NetBeans releases and I just have the
feeling that Eclipse feels a bit kludgy regarding its plugin architecture.

You have to add this or that plugin repository manually and take care of
the dependencies. In NetBeans I can immediately add almost all plugins I
need through the IDE. NetBeans just seems to be "of a piece" here. Also
the Maven integrations is much better in NetBeans at the moment.

I just hope that the Scala community doesn't focus on Eclipse only.

--
Viktor Klang
Scala Loudmouth

Not even if hell freezes over!  They use JDeveloper internally and it's packed full for stuff for working with databases and the Oracle Application Developer Framework.

A more likely scenario is that netbeans will get cherry-picked for components to integrate into E4



On Wed, Jun 17, 2009 at 3:04 PM, Carsten Saager <csaager@gmail.com> wrote:

Who knows, perhaps it even gets a boost when Oracle adopts it in favour of their JBuilder clone
-Carsten

On Wed, Jun 17, 2009 at 2:57 PM, Kevin Wright <kev.lee.wright@googlemail.com> wrote:

I suspect that Netbeans won't be supported or developed further once the Oracle takeover of Sun is complete.
So it would probably be better to focus all our efforts on the eclipse plugin...

I agree with you that Maven support in eclipse is still very poor, so hoping to see some good things come out of the IAM project!


On Wed, Jun 17, 2009 at 1:42 PM, Sven Jacobs <sven.jacobs@web.de> wrote:

martin odersky wrote:

> I sympathize with your sentiment, because I was also frustrated a long
> time with the
> state of the Scala Eclipse IDE. It does seem to work well for some
> people, but for me, and it seems also for you, it's too shaky to
> support large projects reliably. That's why I have finally taken the
> plunge and got personally involved in rewriting the IDE/compiler
> interface. Judge us again in 2-3 months, please. Meanwhile, you might
> also consider IntelliJ; it has a very nice Scala IDE today.

Are there also plans to enhance/support the NetBeans Scala plugin? I've
compared the latest Eclipse and NetBeans releases and I just have the
feeling that Eclipse feels a bit kludgy regarding its plugin architecture.

You have to add this or that plugin repository manually and take care of
the dependencies. In NetBeans I can immediately add almost all plugins I
need through the IDE. NetBeans just seems to be "of a piece" here. Also
the Maven integrations is much better in NetBeans at the moment.

I just hope that the Scala community doesn't focus on Eclipse only.

And replace it with what? JDeveloper?

On Wed, Jun 17, 2009 at 9:57 AM, Kevin Wright <kev.lee.wright@googlemail.com> wrote:

I suspect that Netbeans won't be supported or developed further once the Oracle takeover of Sun is complete.
So it would probably be better to focus all our efforts on the eclipse plugin...

I agree with you that Maven support in eclipse is still very poor, so hoping to see some good things come out of the IAM project!


On Wed, Jun 17, 2009 at 1:42 PM, Sven Jacobs <sven.jacobs@web.de> wrote:

martin odersky wrote:

> I sympathize with your sentiment, because I was also frustrated a long
> time with the
> state of the Scala Eclipse IDE. It does seem to work well for some
> people, but for me, and it seems also for you, it's too shaky to
> support large projects reliably. That's why I have finally taken the
> plunge and got personally involved in rewriting the IDE/compiler
> interface. Judge us again in 2-3 months, please. Meanwhile, you might
> also consider IntelliJ; it has a very nice Scala IDE today.

Are there also plans to enhance/support the NetBeans Scala plugin? I've
compared the latest Eclipse and NetBeans releases and I just have the
feeling that Eclipse feels a bit kludgy regarding its plugin architecture.

You have to add this or that plugin repository manually and take care of
the dependencies. In NetBeans I can immediately add almost all plugins I
need through the IDE. NetBeans just seems to be "of a piece" here. Also
the Maven integrations is much better in NetBeans at the moment.

I just hope that the Scala community doesn't focus on Eclipse only.

--
Daniel C. Sobral

Something I learned in academia: there are three kinds of academic reviews: review by name, review by reference and review by value.