I know this is an exact duplicate, but a year has gone by and Scala seems to be a fast moving thing, so I figure it might be acceptable to ask again:
What is the best IDE for Scala development right now?
I know the Eclipse plugin is a work in progress and undergoing a complete re-write for Scala 2.8 but I saw a colleague use a nightly-build recently and it was extremely poor.
I use IntelliJ IDEA (the Community Edition 9 is free) and the scala plugin for it is really good. Excellent syntax highlighting, code navigation etc. It's not as good as the Java support but then I wouldn't necessarily expect that. It's good enough that I feel I'm more productive than I would have been in Java!
It has Specs integration and console integration as well.
I tried both Eclipse, NetBeans and IntelliJ IDEA,
Eclipse is the worst in my opinion. It is slow, sometimes messes up the syntax highlighting, almost always messes up the autocompletion and the whole IDE gets unresponsive from time to time. I would not recommend it for any kind of use except for self torturing.
NetBeans works better than the Eclipse plugin. Better highlighting, much better autocompletion but it has been reporting errors on a fairly complex syntax all over the source. But when i hit run, the code compiles just well. Could not understand why. Another issue is that autocomplete can not suggest private members of classes when you are writing inside the body of that class. Poor!
IntelliJ IDEA works just fine. I recommend that if you are seriously leaning against Scala development.
I hope that the Eclipse plugin will be more mature in time but given that it had plenty of time to become mature, I'm not a big fan of the idea. Scala has a great potential, being a well thought, programmer friendly language and running on JVM (which means great performance and high availability) but the poor IDE support is the worst thing for such language. Writing PHP on a simple text editor is acceptable but Scala, with such complex syntax and requirement to use the bloated Java libraries, there is a need of assistance. Maybe the current Scala community with functinal and Java background can not understand this but you can not expect newcomers to easily adopt to such a language instantly.
Anyway, go for IntelliJ IDEA...
Your main options are a fully fledged IDE like IntelliJ IDEA, NetBeans or Eclipse, or a text editor with some Scala awareness like TextMate or Emacs.
Personally, I like IntelliJ the best. I've been using it for Java development for many years, especially due to its refactoring and code navigation power. The Scala plugin was quite rough to start with, but is improving constantly. It's open source, I've been contributing bug reports and a few bug fixes.
The IDE plugins have all been working hard to be ready for Scala 2.8. It's been a moving target during the last 6 months, especially given that binary compatibility was broken as new features were added. So you might update to a new build of the compiler and then wait for supporting libraries (e.g. specs, scalatest) to be updated and recompiled.
Now that the Scala 2.8 Beta is imminent these problems are less frequent.
IntelliJ implements its own parser and type inference, as it does for Java. This lets it be more tolerant of errors and to immediately understand your code as you are editing. The type inference is not complete yet. Eclipse delegates most of this work to scalac, which means it they should always agree, but the information is only regenerated when you save files and the compiler is re-run. I don't know how NetBeans works in this regard.
Right now, IntelliJ's IDEA. And one big difference from now to a year ago is that a free, open source version of IDEA is available.
Personally, I use IDEA CE 9.0.1, but leave compilation&testing to SBT, which I keep running on another window, with cc or ~test.
In the context of 2.8, I have used Eclipse 3.5.x with the nightly plug-in and IDEA Community Edition 9.0. IDEA has been clearly better for me, except for compilation times. But I use sbt in parallel and it takes care of that.
My main issues with the Eclipse plug-in are:
Inability to change my tab settings in Eclipse (though that seems to work for others)
Code compiles but some errors are still highlighted and I need to close and reopen the file
Auto-completion just returns a lot of choices
I did not have those issues in IDEA 9.0 build #IC-93.13 with the recent plug-in 0.3.385. Additionally IDEA shows me unused import statements.
All plug-ins seem to be evolving quite quickly and are actively developed and I suspect that what is true today may not be in one month. I hope that in a few months from now, we will just be able to use our favorite IDE and have good Scala support.
(note this is a repost of my recent answer to the original question)
Related
I'm well into learning Scala now and enjoying it very much; I hope to start future projects in it, rather than Java. What I'm enjoying less is the (relatively) poor IDE support. I've found both IDEA and Eclipse with the Scala Plugin (including nightly builds) to be a bit unreliable or difficult to use - I want something I can always depend on. E.g. yesterday I couldn't get a fresh install of eclipse+plugin to run my tests at all, or even open an editor window!
I'm considering hopping between Eclipse/IDEA depending on which suits the task at hand best and more importantly cutting my dependence on the IDE for building and running tests (ScalaTest). This is non-trivial for me since I've grown up on Java in Eclipse; leaving Eclipse SVN to use GIT was initially a big deal. Given that I only have time to learn one tool, should it be Ant, Maven, buildr, sbt,.... ? How do other people work?
I have used both Maven and sbt with Scala and found both of them pretty easy to use.
However, sbt feel much more closer to Scala as its build files are written in Scala itself (as opposed to XML in Maven) and sbt feature a build REPL, has continuous compilation and testing etc.
So I would advise you to use sbt for a simple Scala project.
But in case you want to create standard Java projects like WAR, EJB etc, I feel like Maven has a better support for them.
Also Maven has an enormous plugin ecosystem which enables you to do virtually everything, code coverage, reporting, code standard checking, documentation generation, and a lot more.
I'd use SBT with IDEA. Though I haven't tried it, I know there's some support for integration of SBT and IDEA.
Anyway, SBT is a great basis for all Scala building&testing needs.
EDIT: Uuuups. Sorry. Actually I misread your question and only commented on IDEs. When it comes to building the project I use make ;) because it is well integrated into Vim
while I wouldn't want to do ANY Java Project without IDE, I'm currently doing a fairly large project just in Vim. I know that's a quite a "stone-age approach" but it works just fine.
On one hand I was fed up by the buggy/slow/lacking Scala support of all IDEs. I tried Scala, netbeans and IDEA and found working with them (in Scala) rather painful.
On the other hand Scala has some properties that help when working with a simple Editor: you can have more classes in one file so I usually define a whole package in one file which again doesn't grow too large, since Scala class are usually very (or even extremely) small. So I usually have only two or three files open at a time and hence don't need a package/file management.
I couldn't get code folding by languages tags to work but folding by indentation works just fine if you stick to Scala's indentation conventions.
One thing that doesn't work is auto-completion. But then again, this makes me write more loosely coupled objects ;)
Buildr supports Scala and Java as first class languages, with support for ScalaCheck and ScalaSpecs, and of course also has enough plugins to make it a good contender for Maven.
Just adding my two cents. I think you should give Netbeans a try too. Its supposed to be the most Scala-friendly among the three major players (Eclipse, Idea and Netbeans).
I have been having a lot of fun with Netbeans 6.8 and scala-2.8.0.r22602-b20100720020114
It is fair to say that I wouldn't be programming Scala now if it hadn't been for the Netbeans plugin. I have spent a fair bit of time trying to get it to work as smoothly with the others, but without much success.
I use Netbeans for developing and Ant for standalone build. Info on configuring Ant for Scala here:
http://scriptlandia.blogspot.com/2007/04/how-to-compile-and-run-scala-program.html
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 1 year ago.
Improve this question
This is the same question for older version of Scala, but they say that Eclipse plugin has been improved vastly. Is it the best IDE now? How do different Scala IDE compare today?
I've been pretty successful with IDEA 9. I've briefly tried both Netbeans and Eclipse and wasn't able to get what I wanted. Eclipse's code-complete didn't behave as well as I'd have liked, and I couldn't find a way to make Netbeans handle Scala scripts; It'd just complain that the file wasn't a class.
To be clear, I've been using IDEA for a few years for Java, so keep that in mind:)
For the moment, Scala Plugin in IntelliJ IDEA is the best. It handles Scala 2.8 well. IntelliJ IDEA Community Edition is now free and open source (and works with Scala), so I can't see any reason for not using it.
The plugin is still somewhat buggy (many "false negatives", i.e. the code without red underscores may not compile successfully; but almost no "false positives"), but perfectly usable. The best thing is that you can use IDEA's excellent debugger with Scala (not without some issues, but it actually works!).
FSC (Fast Scala Compiler) is also supported in latest builds. A huge time-saver.
The plugin development team is quite responsive. Some of the guys work directly in JetBrains and possess intimate knowledge about IDEA platform, so the development progresses fast.
JetBrains IDEA's Scala plug-in handles 2.7 and 2.8 equally well.
I cannot make any comparisons because I have used only IDEA.
Using Eclipse Helios with the dev-version of the new Scala(2.8) plugin, as there isn't an official release yet. That is beta, definitively -- but I can't confirm the frequently expressed opinion that this plugin is outright horrible ;-)
I'd say, the experience is already OK-ish, and indeed better than the current state of affairs with the Groovy plugin. OTOH, the experience with plain Java is way more smooth (feels like flying at times), and the current CDT I'd rate somewhat in between.
Incremental compile and error highlighting work quite well for me; tweaking a DSL implementation into form just by continuously rewriting your code until the error markers are gone -- without ever having to test-run your program -- is outright fun and just again shows that FP / static typing rocks!
Problems encountered from time to time:
- implicits and nested types in other compilation units (esp. nested / super packages) aren't picked up at times when there are still other errors around; they will be picked up after an full build
- there seems to be a memory leak in the version I'm using right now (from end august 2010), necessitating to restart the workbench after some hours of work
- beware when you're using AspectJ, to make sure you get a version of the Scala plugin which relies on a JDT weaving bundle version which also works with AJDT
PS: I'm using maven builds in all my projects and generated the eclipse projects with the eclipse-maven-plugin, and then imported them as plain-flat eclipse projects. I can just strongly recommend everyone to keep away from the M2-eclipse plugin (for maven) in its current (2010) state, it makes your workbench painfully slow, is buggy and has lots of almost unpredictable behaviour, because it constantly tries to do magic things behind the scenes (and besides that, the aspectj support is broken since this spring)
i use both eclipse and IDEA
eclipse supports type detection is
better than IDEA (it is very
neccessery thing if you want program
in functional style that you can be
aware from type of expressions and
variables.)
Edit1: IDEA supports type detection like eclipse but you have
to define a value in your functions
for example: def
testTs[A](a:List[String],b:List[A])
= for{
ai <- a
bi <- b
} yield (ai,bi) } should be converted to def
testTs[A](a:List[String],b:List[A]):List[(String,A)]={
val result = for{
ai <- a
bi <- b
} yield (ai,bi) } also instead of hover your mouse over variables you must press ctrl+q when your mouse is hover on that variable
eclipse have some problems in code
completion (when you use a variable
in next line and you want get a
property of this variable eclipse
show wrong code suggestions)
in IDEA ruining a scala application
is 5 sec slower than eclipse (there is some solution for bust IDEA run time but these have side effect have some problems)
in idea there is a well known problem with double click speed that show itself in many cases like opening a file or selecting an string in source... you can increase double click time out by creating (or editing) /home/.Xresources and add this line: *.multiClickTime: 400
Edit1: in summery i prefer to use IDEA rather than eclipse
My experiences clearly point to IntelliJ IDEA:
About six months ago, when I started a serious Scala (multi module) project, I had to abandon Eclipse as my favorite Java IDE and switched to IntelliJ (9.0.x). Eclipse Scala IDE was way to buggy and often stopped responding at some point, even for the most simple projects. For CI (Hudson) and command line build, I depend on Maven (with Scala plugin). The Maven dependencies (incl. Scala libs) are picked up nicely by IntelliJ.
A few days back I updated to IDEA X (CE) with the current plugin (nightly build) and work became even smoother. Although fsc still terminates after a while when inactive.
From what I see, I'd like to add, that there seems to be way more activity on the IntelliJ side to respond to bugs and improve the plugin continuously. Correct me when I'm wrong, but Eclipse Scala IDE development seems almost stalled. Still no 'official' Helios release!
NB: Just to provide some context (not bragging, really): The aforementioned project consists of about 25 Scala modules (POMs), 5 Java modules, 325 Scala files with a total of about 360 Scala classes, case classes and traits (> 19 kLOC, including comments). My platform is OS X 10.6, Scala 2.8.1, Java 1.6.
UPDATE: After having the need for pretty extensive refactorings (mainly move class, rename package), I discovered that the recent IDEA 10.0.1 plugin 0.4.413 (and probably older versions, too) has quite some problems getting stuff right. I don't want to explain the specifics, but I (almost ever) ended up manually fixing unresolved references or otherwise messed-up code. You can have a look at http://youtrack.jetbrains.net to get an idea.
For everyone who is really considering doing some serious development with Scala, I strongly recommend to evaluate the IDEs in question beyond the basics. When you are into an agile approach, which in my option requires a painless refactoring support without surprises (especially in multi-module projects), things are pretty tight at the moment.
It would be pretty neat, if someone came up with a IDE independent specification-like list of refactorings (and desired outcomes), which could be used to verify an IDE's refactoring support.
A non-answer: None.
Based on what a perceived majority says, IDEA is probably the best Scala IDE today. And it (read: the Scala plugin) sucks. It does not handle fsc well, type inference is a mess, many errors are not shown, a number of non-errors are marked as errors, it is slow (when inspections are turned on), the test runner silently swallows aborting (!= failing) tests, ...
So I switched to a simple text editor with syntax highlighting on one and a maximized shell with SBT (simple build tool) on the other screen. Awesome! SBT is responsive (you can let file changes trigger recompilation of affected code and even reruns of tests), manages dependencies very smoothly and has helpful output (esp for tests; using ScalaTest). SBT increased my productivity compared to IDEA a lot.
You lose code completion, of course, altough geany offers me identified symbols. But as long as IDEs don't get type inference to work properly code completion does not help, anyway.
Some people care a lot about code refactoring. Well, the IDEs apparently don't make a good job there either. Even if they would, I'd rather only open them for this particular task than use them all the time.
I think that the best option so far is the ScalaIDE for Eclipse. You can go to the ScalaIDE Web Site and look around to see by yourself.
http://scala-ide.org/
Strong points I see about it are:
documentation,
tutorials,
constant releases,
support from Typesafe.
Here below a summary of the main features:
Scala IDE provides support for development of Scala applications in the Eclipse platform. Its main target is the support for the Scala language and the integration with the Eclipse Java tools. It provides many of the features Eclipse users have come to expect including:
Support for mixed Scala/Java projects and any combination of Scala/Java project dependencies. Type driven operations are transparent across Scala and Java files and projects, allowing straightforward references from Scala to Java and vice versa.
A Scala editor with syntax highlighting, inferred type, hyperlinking to definitions, code completion, error and warning markers, indentation, brace matching.
Project and source navigation including Scala support in the Package explorer view with embedded outline, outline view, quick outline, open type, open type hierarchy.
Incremental compilation, application launching with integrated debugger, hyperlinking from stack traces to Scala source, interactive console.
Support for Eclipse plug-in and OSGi development including hyperlinking to Scala source from plugin.xml and manifest files.
UPDATE: the features and advantages are mentioned on this answer are for version 2.9 and 2.10 of Scala, because it has been already discontinued. see here:
"The 2.0.1 release is only available for Scala 2.9, if you would like to use the Scala IDE with Scala 2.8, please install the 2.0.0 release (support for Scala 2.8 has been discontinued after the 2.0.0 version)"
The officially endorsed and supported (by Typesafe) for Scala 2.9 is Eclipse. The current version is far superior to prior versions and includes a context-aware REPL, full-featured debugger, and even the ability to debug REPL statements. I think this question needs to be updated and the answers revisited.
I don't recommend the Scala IDE/Eclipse. It doesn't have a lot of the features that are even available for Eclipse with Java. And there are bugs.
I am using the latest NetBeans and haven't tried anything else. I've met at least 2 notable bugs in NetBeans while coding in Scala:
One: NB occasionally come unable to run a program, hanging on classpath scanning.
Solution: Create a new project, copy your code there and go on.
Comment: This bug is more than 10 years old.
Two: Sometimes NB can't see members of particular namespaces or classes and complains when you use them.
Solution: Just ignore and go on - compiler founds no errors and the program works.
I'd recommend IDEA's plugin for now.
The Scala plugin for NetBeans is quite nice too. It doesn't yet support NetBeans 6.9, the newest release, though, and you still need to download it manually instead of installing it directly from the plugin manager inside NetBeans.
However, it integrates better with Maven projects than IDEA's plugin does (this is true for NB and IDEA in general, in my opinion).
It partly depends on your style of working, as all the options have strengths and weaknesses.
If you need refactoring across mixed java/scala projects, then IntelliJ is your only option.
If you want to do any work on the compiler or a compiler plugin, then Eclipse has the advantage of being able to launch a runtime workspace with a custom compiler build, including breakpoints. It also improved massively for the 2.8 Scala release.
Netbeans is a fine choice to go with if you're already very familiar with that platform, the costs of learning a new environment may well outweigh any benefits, and all three solutions are improving rapidly.
I haven't tried netbeans scala plugin yet, but I find that Intellij IDEA plugin is at any way much better a scala ide than the Scala eclipse plugin, which is sooooo slow that drives me crazy.
Though swing applications don't work well with my tiling window manager.
try IDEAX the latest community edition of Intellij IDEA (version 10), it has improved scala plugin which has faster code compilation and exceution in addition to that it has
Maven3 and SBT support with which we can develop Lift applications.
IntelliJ IDEA community edition + Scala Plugin + SBT plugin
For recent versions (2021) the question which ide takes a big portion of the home page https://scala-lang.org/
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 11 years ago.
I am just starting at a job in which I will be using a lot of ColdFusion. What is the best IDE/Editor to use?
I'd like to provide my personal reasoning behind why you might choose any of these editors (at least the ones I'm familiar with). Just saying "use this, use that" is not at all helpful. To large degree, the question is wrong. There's rarely a "best IDE" for a language; rather, there are multiple environments, each suiting particular needs. Here goes:
1) Dreamweaver
Why you would use it: its history as a designer tool makes it much easier for "non-coder" types to start cranking out websites. If you're a solo developer building a lot of "Tom's Corner Store" type of sites, even if they require some CF Coding (mailing list, subscribers, current specials, light content management, etc), its design tools, "template" features, and ease-of-deployment (ftp) make it an attractive choice. It has good-enough code coloring and code completion for the built-in CF tags and functions. It can interrogate user-defined functions in the same page. It has excellent CSS support. You can find a wealth of extensions, too. It's pretty stable and, in my experience, hasn't been very "crashy". It will do a fair amount of code generation for you as well (whether that code is "good" is debatable). All in all Dreamweaver is incredible software for web site designers.
Why you wouldn't use it: It is not free, and it is certainly not a "coder's editor". While it provides for extensions, they're typically interface-focused (javascript validation, etc), unlike say Eclipse plugins, which can run the gamut. For large projects, it simply does not have the code navigation features that many coders come to expect. It's web-focused. So if you're a polyglot, or even just like to dabble in compiled languages (java, etc), then you'll need to keep another editor on hand for those tasks.... you won't be able to do it all in one place. ColdFusion unit testing support is nonexistent in Dreamweaver. There is no step debugging for ColdFusion.
2) CFEclipse plugged into Eclipse.
Why you'd use it: CFEclipse is going on 6 years old now and has matured significantly. It's been quite stable for the last few years and most crashiness has been due to Eclipse itself and not CFEclipse (which was not true in the early days). Recently CFEclipse has seen an infusion of fresh blood and features are being added to make coding in it even more productive. It contains a wealth of keyboard shortcuts, many of the toolbar features people love from ColdFusion Studio days, and Eclipse's in-built code navigation features (namely, Ctrl-Shift-R for finding files quickly).
It has content assist for native CF Tags and functions, and some support for in-page variables, though that's never worked all that well. It does not support in-page functions, nor does it provide native true component insight (i.e. insight into components that you write and use in other code). It will support component insight to some extent with Dictionaries, but even then, it requires a lot of work on the part of the dictionary creator. Most people find dictionaries too much work to maintain, in my experience.
The lastest version of CFEclipse contains the best CFML formatting you'll find.
For me, "method explorer" and "Snip Tree View" -- particularly keyboard shortcuts for inserting snippets -- have been big productivity boosters.
If you work with ColdSpring, ModelGlue, Mach-II, ColdBox, and other frameworks with xml configuration files, CFEclipse's Framework Explorer is brilliant.
Because it's a plugin to Eclipse, you can do everything else you'd want to do in Eclipse. You wanna code java? You can. You want webservice support? you got that. You want to do step debugging, you can do so with the free Adobe-provided extensions for Eclipse.
The large plugin ecosystem is one of the most attractive features of Eclipse, and you shouldn't discount this when deciding on an editor. For example, I would not want to work without Mylyn, which integrates with issue tracking and in my experience has transformed the way I work, much for the better.
Eclipse's version control system support is excellent as well. Subversion is well supported; there's a VSS plugin; and recently a git plugin (if not two) has been accepted into the Eclipse foundation so we'll see native git support very soon (you can get it now with a plugin).
Eclipse's ANT support is excellent.
You can easily plug the MXUnit Eclipse plugin into Eclipse for unit testing your CFML (full disclosure: I contribute to MXUnit).
Finally, I have full confidence that the folks working on CFEclipse -- Denny, Mark, Jim, Peter, et al. -- will continue to work toward keeping CFEclipse as the best open source CFML IDE available. These are some of the brightest minds in the ColdFusion community and are passionate about their mission. If you choose to use CFEclipse, you are not choosing to use an IDE that will be supplanted by ColdFusion Builder. This project is in good hands.
Why you wouldn't use it: it's a code IDE, not a design tool like Dreamweaver. It's not perfect... code assist can be too aggressive in its suggestions. Eclipse itself, especially when you pile it up with all kinds of plugins, can get unstable on lesser machines. Finally, people who don't like the "Project" view of the world often have complaints about it because they're used to working directly with the file system view of the world. Its deployment support is nowhere near as simple as Dreamweaver, though you can find plugins that get close.
3) ColdFusion Builder
Why you'd use it: all of what I said previously about Eclipse itself applies to CFBuilder when used as a plugin to Eclipse. I cannot speak to the Standalone version because as of this writing, it still doesn't support plugins very well. This will most surely be fixed by the time it is released, but I don't want to speculate on what the Standalone may or may not do.
One of CFBuilder's big draws is "Extensions". These are a way to plug in CFML code into your editor. It's hard to describe, so I'd suggest googling for "ColdFusion Builder Extensions", and you'll most likely be amazed. Adobe's Terry Ryan has created "Apptacular" for scaffolding applications from a database, and Brian Rinaldi has a series of posts on building CFBuilder extensions. These are huge and will prove themselves to be a developer's best friend after CFBuilder is released.
CFBuilder's deployment support is, in my opinion, on par with if not superior to Dreamweaver's.
CFBuilder does not require an additional plugin to do step debugging. Just hit the debug button and off you go.
CFBuilder contains true component insight, meaning that it can introspect components you write and provide ctrl-space content assist. It can be wonky, however, and does require some configuration. But please remember that as of now, CFBuilder is still in beta. My best guess is that it'll be at least a few versions until all the kinks are worked out of this feature. Still, it's a big productivity and learning booster to get content assist on your own components.
CFBuilder provides a "Servers" view for stopping/starting your CF Server. It's built on Aptana and so contains the Aptana "tail log" view, which is great for watching log files. Just like CFEclipse, it has a Snip Tree View.
The CFBuilder "vision" is led by Adobe's Adam Lehman. He's passionate about CF and is a force of nature. I have great hopes for CFBuilder because of Adam's leadership.
Why you wouldn't use it:
For one, it won't be free. Noone outside Adobe knows yet how much it will cost, however. "Extensions" and the deployment features alone may be worth the price. Time will tell.
Because it's an Adobe product, I think it's reasonable to assume that releases will come as frequently as most Adobe products, which means... not very often. While CFEclipse deploys rather frequently lately -- and makes available a "nightly" site for the brave -- CFBuilder will most likely not do such daring-do. CFEclipse can afford to make potentially unstable builds available to the public, while it is perhaps not in Adobe's best interests to do so with CFBuilder.
Finally, it's still in Beta and might not be released for some time. If you get it now and start using it, remember that. In my experience, debugging is wonky, content assist sometimes works, sometimes doesn't, and a lot of people have experience crashiness. It's free beta software... you're getting what you pay for. But know that the more you work with this beta release, and particularly if you provide feedback via the public bug database, the better off all of us will be if it provides a best of breed editor for CFML.
Personally:
At home, when I do "designer" work, I use Dreamweaver when I feel that its Templates will help me build a site as quickly as possible. For existing side projects which require maintenance coding and easy deployments, I use ColdFusion builder.
At work, where I do almost no design work, CFEclipse has been my IDE since 2006. I've begun using ColdFusion builder a lot, though currently I split my time between CFBuilder and CFEclipse. One reason is that as of this writing, CFEclipse is more stable (i.e. it doesn't crash and I don't lose work). I fully expect stability problems to be mitigated by the time CFBuilder costs money.
Both CFBuilder and CFEclipse have public bug databases. CFEclipse has a well-attended public mailing list, and if you have questions, you'll get answers quickly. I cannot yet speak to the speed with which CFBuilder questions are answered.
Finally, for "coders", it's my experience that once you invest the time in learning the tools and shortcuts, Eclipse provides superior productivity compared with designer tools like Dreamweaver. For cranking out a designed site, a designer tool like Dreamweaver confers significant advantages.
The answer to the best ColdFusion IDE isn't an answer, but a question: "What are you trying to do with ColdFusion?" The answer to that question will lead you to an IDE that suits your needs for a particular project. Different circumstances or projects may lead you to a different tool which better suits your needs.
Notepad++ with CF syntax highlighting.
For free: Eclipse with CFEclipes plugin
For cost: If you're a developer, use Coldfusion Builder, if you're a front end designer Dreamweaver edits Coldfusion pretty well. I use it quite often.
I have heavily used Dreamweaver, CFeclipse with eclipse and now Coldfusion Builder. What I found is this:
1) Dreamweaver is only good for the few times you have to do some wysiwyg wizardry. The newer versions do have SVN integration so you might be able to get away with using it. I did use it for a few years on windows.
2) CFEclipse + Eclipse - Generally the standard of what' sbeen used for a while. Runs well, once you add in the Adobe dictionary files and subclipse, you have a good environment
3) Coldfusion Builder - This is Adobe's version of CFeclipse. It's still pretty new and getting to later beta. I switched to it about 6 months ago and haven't looked back. It's got a lot of wizards, including the ability to write your own plugins in CFML that will run right inside CFbuilder. It's free right now on beta but will likely be pretty cheap like the first flex builder that came out.
My Choice: Coldfusion Builder. It doesn't mean the others aren't capable, but you'll spend the least amoutn of time getting setup and maintaining your plugins, etc.
Since I had paid for and used Dreamweaver for a lot of years (Eclipse was generally sluggish sometimes on PCs' a while back until the excess of ram + cpu today), spending to have an adobe maintained copy of eclipse is okay with me. The wizards available in CFbuilder, especially for flex are excellent.
Hope that helps, good luck and share what you ended up picking and why!
For anyone who might stumble here from Google, you should also take a look at Sublime Text coupled with the ColdFusion package.
If you are familiar with Eclipse I would recommend Eclipse with coldfusion plugin.
http://www.cfeclipse.org/
Some use Eclipse, some use ColdFusion Builder, some use emacs or TextMate or vim. I use vim.
It doesn't take much time to try out an IDE or editor. Give them all a shot and stick with the one you like most.
The best IDE is ColdFusion Builder. It allows RDS, In Line Debugging, Extensions (written in ColdFusion!), Code Generation, Refactoring, supports JavaScript, CSS and HTML and so much more. It is currently in beta and should be released in production sometime this year.
CFEclipse is a great IDE for CFML and is the right choice if you are writing CFML for the open source engines. It is free and like most open-source free products it can do almost anything Builder can do if you invest the time to install the additional plugins (like Aptana) and tweak your setup just right.
I use both. At work, we use Builder. At home, I use CFEclipse.
Welcome to the CFML community!
Notepad++. Light and easy to use.
I'll vote for jEdit. While it doesn't offer great ColdFusion support beyond syntax highlighting, and therefore probably isn't great for learning ColdFusion, its flexibility in working with other languages (which seems to happen fairly often while working on the web), powerful macros, plug-in support, proper text wrapping, and loads of other features, make it the editor to which I always end up returning after trying out the "next best thing".
CFEclipse appears to be the most popular. Adobe has a beta of ColdFusion Builder (also based on Eclipse) but when I tried it a few months ago it was still buggy.
Personally I use TextMate (OS X) a pretty bare bones text editor.
I have used textpad, for 6 years, still a solid app, provides syntax coloring/highlighting, regular expressions support. Can easily search inside any file, through tons of folders/subfolders.
Just a fast loading, easy to use, tool.
Also has macros, and macro programming...
http://www.texptad.com
I'd like to throw E TextEditor for the Windows users in here as well. Its similar to sublime but it does have its advantages. E is more or less Textmate for windows and will allow you to run the cftextmate bundles. In addition to being lightweight and extremely fast you get the huge Textmate community developing bundles, color schemes, and other community driven content.
Some of the highlights of E is that it will allow you to open a directory and treat it directory as a project. Hitting Shift-Ctrl T will allow you to browse all the files in your project in a flattened hierarchy which allows you to find files extremely fast.
I searching for and IDE that gives me a (mostly) uniform experience on Linux/Windows and C/C++ and Java. I'm somewhat comfortable with using Netbeans on Windows and I'd like to know what to expect of it on C. I heard the Visual Studio debugger is quite good on C, does this extend to Mono? Is it really more powerful than the one on Netbeans?
I've been using NetBeans for C++ development on Linux for the last month or two and love it. I'm working on an large code base 1+million lines of code. As long as your project references appropriately, I've found that NetBeans will provide "intellisense" information with hardly any issues. Now, it's not perfect, and is definitely not as good as Java, but I've not found a better alternative. NetBeans debugger, which is a front-end to gdb, works well also. Much easier, and in my experience more stable than DDD. I've not tried Mono projects using NetBeans so I can't speak to that.
This link explains how to setup a C++ project in NetBeans and may shed more light on the subject for you. This is for NetBeans 6.7 NetBeans C/C++.
Eclipse CDT is quite usable as well
you can use codeblocks it is also a well and exceptionally good for c/c++.
I don't think so, since it consumes extreme amounts of memory and can hog your CPU completely if you have a lot of projects open. It actually uses every bit of CPU it can if it feels for it, and it does so for a long time, rendering the whole application useless. This is of course completely unacceptable for a modern UI application. It also feels kind of sluggish.
Because of this I switched to Visual Studio Code for Linux. It's not a full blown IDE but I don't need that anyways. I'm not in the "flow" of it yet, but I think it has potential.
The problem of VS C++ is don't have intellisense. Netbeans C++ is a good product. But i suggest DevC++ editor, its free and come with lot of pluggins and intellisense.
I use Intellij Idea 7 for Java dev. My dev is 'limited' to all J2SE features plus light JSP, Servlets, and super light usage of JPA. No J2EE, no massive use of random frameworks, etc.
Is it worth upgrading to ver 8? "Worth it" to me means better "core functionality" in terms of speed (ESPECIALLY startup speed), memory utilization (seems like it starts having serious problems with four or more projects open), and auto bug-finding.
More frameworks supported and more languages supported (other than perhaps Haskell and C++), and more refactorings don't interest me at this time.
A while back, I installed a preview version of 8 and it seemed -exactly- the same as 7, as far as my needs were concerned.
Anyone loving the upgrade to 8, and if so, why?
Thanks
It also seems to be easier to configure a new project over top of a complex collection of existing code.
For example, something that you would naturally configure into 5 or more modules.
There is a really beautiful go to/create test wizard that is bound to ctrl-shift-T. Worth the upgrade by itself
The best way to tell is to check out the list of new features and decide for yourself. I haven't discovered any single feature so far that by itself is worth upgrading - the simplified UML view is quite nice, as is the improved Maven integration. The UI feels a bit more streamlined and faster. It seems like most of the attention has gone into non-Java features like better Flex support (which I am really thankful for as I don't like FlexBuilder but I haven't had a chance to use yet).
IntelliJ 8 has a configure plugins feature that allows you to disable plugins with dependencies. Nothing trial and error couldn't replicate, but it is nice.
Startup is only marginally slower. But indexing once opened is a lot faster than before, even unnoticeable for most projects, except after a commit to Subversion. It seems a commit to subversion triggers the indexing twice.
I am working on the Diana-EAP build - but 8 has git integration built in. The EAP has better git integration than the 8.0.1 release - it looks like that is something they are really focusing on.
Definitely not! Seems that the variables defined in our custom taglibs are no longer able to be used in the jsp (worked in 7.0.4). All red. No auto complete.
Oh, and the new settings menu is horrendous!
Some benefits of IntelliJ IDEA 8:
IDEA 8 supports Subversion 1.5 new functionality - e.g. merge tracking, which may be useful especially if your team (like ours) uses a lot of development branches and thus merging is frequent.
One detail I appreciated about IDEA 8: As you probably know, IDEA has had changelists for pretty long now, built on top of any underlying version control system - this is a really useful feature. So, now that Subversion itself supports changeslists, IDEA's changelist implementation has been changed so that it is perfectly compatible with Subversion's native changeslists. (For example, you'll be able to work with any changelists created in IDEA also when using svn command line tools directly.)
Edit: in your case, perhaps it is not worthwhile to upgrade. For me, at least, startup and file indexing seems to be somewhat slower in 8 than 7. [But for me personally the upgrade was definitely worth it, because it solved a long-standing VCS problem with IDEA 7 - it could hang "waiting for VCS sync to finish" for an hour or whatever after hitting Ctrl-K.]