How to learn to like Visual Studio and heavy-duty IDEs

Question

I've had some exposure to Visual Studio, but not a great deal, as well as Eclipse, and haven't gotten much out of the experience. What I tend to want out of an editor is line numbers, syntax highlighting, and if possible, a list of functions/subroutines. To me, Visual Studio is overkill.

Particularly, I don't like the concept of drag-and-drop coding and auto-generated content. I'm not saying it's bad, but that personally it pushes me away.

What would you suggest in order to get into the right mindset to work with these kind of tools, and what can show off the benefits of the potential for increased productivity as opposed to a feeling like I'm fighting with the GUI?

Answer 1

Use notepad++

I like Visual Studio though :). I don't believe it is overkill but that is because I use most of the features.

Answer 2

Learn to love the visual debugger, and the refactoring support.

VS isn't that great when compared to other IDEs out there when it comes to refactoring, but you can buy addons (like Resharper) that IMO give some worth to the overhead.

I am with you in that I would rather have a good editor and shell tools over an IDE if I can get away with it, but after working with big IDEs for awhile now professionally, I have to admit I miss those two things sometimes when doing stuff on my own.

Also, do your best to stay away from the "Code with your mouse" features as much as you can. They are really terrible, and only aimed at people or projects where quality isn't important.

Answer 3

Visual Studio and Eclipse are great IDE's because of customization. You should never feel like you need to drag and drop in either of these, even if someone is forcing you too. You should be able to setup your workspace the way you need it and never think about such things again. These tools are designed to make coding easier for you, not to code for you.

They are there to help keep your files/folders/projects organized and readable. As a bonus there are many more tools they contain which you will fluently guide you to not breaking your head while coding. Such as debugging, profiling, searching, refactoring, and many more.

I spend about 95-100% of my time writing code and navigating through files using these IDEs. If I ever need to drag and drop, for example lets say generating HTML I will use Dreamweaver or Microsoft's Expression toolset.

For dull operations such as changing spelling or fixing small text based files, it is ok to jump into Notepad/Notepad++.

Like you it took me a while to get used to the IDEs, but now I don't know how I can live without them (in a good way :D ).

Answer 4

There are a lot of features that help you:

• the debugger - one of the best + it is integrated in the IDE
• GUI for project properties. Why edit that file manually when you can have a nice interface?
• integration with TFS, SqlServer, etc
• IntelliSense
• regions that can be collapsed
• navigate to definition
• multi file project support, solution support\
• support for interface design. It's not really nice to design an interface from code :p
• refactoring support
• etc.

Why do you want to do a lot of things manually when can be automated?

Answer 5

I have never gotten used to GUI IDEs. At a previous job which used Visual Studio, I promptly installed cygwin and gvim, and only used VS as a dumb compiler. vi forever!

(Now I'm back to a unix environment so I do all my work in screen sessions and vim using putty. Windows is only good for running a browser and ssh terminal anyway.) :D

Answer 6

Find the options you find disagreeable and turn them off. I used to be annoyed with VS, but after learning which utilities I liked and which I didn't things picked up considerably. And now it's become my tool of choice for most things. Things will get better with use.

Answer 7

I'm an avid Eclipse user (for Java), and I admit, it is very heavy.

You're not going to like all the features - though you can turn many of them off, at least in Eclipse.

I like automatic refactoring and I like auto completion (or content assist). But I also drive an automatic transmission. Sometimes I miss stick-shift, but most of the time I'm just trying to pound my way through something and it saves me time and effort. In the same way, sometimes I like picking my own methods, but I enjoy having Eclipse figure it out often.

To me the integrated debugger is the best feature of all these IDEs. I also like having tight SVN integration (or CVS/VSS/etc). I was not impressed by offerings outside the IDE.

I think in many cases, you have to find the one plugin that changes your life. To me it is things like the Java element search (better than grepping), and a plugin that I have written. For many people, something like Mylyn is perfect (it supposedly finds the most relevant files all the time). You can't really get something like it without an IDE, so you make the choice whether to use one or not.

In the end, the goal is to be productive and enjoy what you do. Deciding that you must or must not use a tool is more of a religion argument than something productive. Most people swear by Word, and I use LaTeX for everything. To each his own.

Answer 8

all of last answers +

• Code analysis
• Class digram

Answer 9

Like most tools, you get out of them what you put in. Modern IDEs are complex and complex tools take time to learn. Drag and Drop and Auto-Generated code aren't horribly usefull - in my opinion - but there are many features that can do wonders for efficiency.

The modern IDE isn't just about writing and compiling code anymore. The tools are designed to support the entire development life cycle from design to code to change control to testing ... and on ... and on ... and on.

At the end of the day, the best tool is one that you are confortable with and that you know how to use. If you don't want to or need to use the features that and big-ol-IDE offers, then the IDE isn't much use. If you do want to or need to use them, then the big IDE is a wonderful thing.

Like everything, there are tradeoffs - the modern IDE tends to be a resouce hog and they take longer to learn, but in exchange, you can get some great tools. Most new IDEs offer some flavor of the following ...

• Solution explorer - easly work and navigate across multiple projects efficiently
• integrated source control - don't have to work with external source control IDE
• debugger/watches - no need to add silly tracers directly into the code to monitor state; just step through the code
• code refactoring - rename variables and find all references to the renamed variables and change them as well ... or pull out whole chunks of code and encapsulate them into a private method
• debug/assertion output - interfaces for displaying assertion results
• integrated modeling/UML - view visual models of your code and keep them tightly integrated with your code so that the model is always consistent with changes made to the source code.
• intellisense and auto-complete - saves a lot of key strokes (though some would argue it also promotes laziness, but ... well ... code responsibly)
• macros - for performing repetitive tasks
• compile errors - presented in an easy to read manner
• code analysis tools - policy checking, cylomatic code complexity, call depth, coupling analysis - good stuff
• multi-file/project find/replace - because sometimes you just have search for things are change them ... a lot of them.
• rich editing - having an IDE that can cleanly format and color code your code ... and do it well, can be fabulous