If you asked me 6 months ago I would say the features that confused me the most:
- Covariance / Contravariance
- Implicit Parameters
- Implicit Conversions
- and also mentioned here, Structural typing.
However now that i've spent time with the language, seen these in action and used them myself I see the reason why they exist and embrace them. I can see why this would be a common complaint against Scala and can be a barrier for a lot, but I think the language is worth investing time in learning, at least for me.
Well done! This is definitely something I will come back to repeatedly. It's very complete, but at the same time not overbearing. The scaladoc feature is awesome, I wish my IDE could do this so well. Can you give a run down of the stack and how it all comes together?
The author, Manny Howard, was on the Colbert Report tonight. This guy was incredibly deadpan, one of the more enjoyable Colbert guests that I can remember.
I started programming as a young man on Visual Studio programming in VB and C++. There came a day years ago where I had to work with a text editor and a terminal on an AIX system and was surprised at how little I knew in terms of compiling, building, and programming in general (how is a class structured again? What packages/headers do I need to reference? What directories do my files have to be in? Why isn't my code running?). I think it's important that those who code exclusively in IDEs step back every now and then and understand how these 'auto-magic' functions IDEs provide work. I've now spent years using IDEs in addition to my own custom environment (I switch back and forth between vi, gedit, and textmate (when i'm on a mac) and make extensive use of sed/awk and other CLI commands to do custom activities that IDEs certainly cannot provide).
IDEs bring a lot to the table, but I can't help but agree with you in that it can be a horrible experience, especially to those who are accustomed to having complete control over everything in their environment. I think it's great for getting things done efficiently, but developing exclusively with them can bring a close-minded view of how things work.
I don't know if these are techniques rather then hotkeys, but I actively use the following (Note: I'm not really a big fan of IDEs, but use them professionally to conform to my work environment and Eclipse, while somewhat bloated, is very pleasant and gets better with every milestone).
Debugging:
Learn the hotkeys for stepping in (F5) over (F6) out (F7) and continuing (F8), I get super frustrated watching people click on the icons. Really helped the transition from debugging with the likes of gdb.
Conditional Breakpoints are a revelation.
Remote Debugging is great (I've been able to debug remote java processes, Lotus Notes (yuck) instances, Eclipse workbenches (for plugin development), Remote Perl Server Code (with E-P-I-C and Padwalker)... Eclipse's debugger interface is amazing.
Text Editing w/ Java and CDT:
CTRL+W : close active editor
CTRL + Space : Autocomplete (mentioned earlier)
CTRL + SHIFT + O : Organize Imports (Finds classes that should be imported, removes excessive imports, etc...probably one of the most justifiable reasons to use an IDE for Java development)
ALT + SHIFT + J: Add Javadoc in context
CTRL + SHIFT + G : Does a search on the highlighted text's context (i.e.) a method name to show where it is used.
F3 : Navigates to selected context (Method, class, variable, etc.)
CTRL+SHIFT+T : Presents Dialog for searching through Types (works in most perspectives), i.e.: Searching for a particular java class.
F4: Show the Type Hierarchy (subclass/superclass information)
Import & Export wizards are your friend (Creating java jars, exporting projects to archived zips).
Eclipse can be used to track history (kind of like your own personal lazy SCM). If you make a mistake you can right click on a file and perform "Replace With > Local History..." (this may need to be enabled in preferences). You can also Compare to history well.
Tasks : The 'Mylyn' plugin is great for GTD and Task management. I was a bit apprehensive at first, but it's pretty incredible, especially if you are a nut about keeping organized. You can create tasks, and assign your current work to it, and it will track and remember context (what classes you used) as you work on that task. Mylyn also interfaces with Bug Trackers like Bugzilla and JIRA.
- Covariance / Contravariance - Implicit Parameters - Implicit Conversions - and also mentioned here, Structural typing.
However now that i've spent time with the language, seen these in action and used them myself I see the reason why they exist and embrace them. I can see why this would be a common complaint against Scala and can be a barrier for a lot, but I think the language is worth investing time in learning, at least for me.