Aaron J. Grier wrote:
I'm dissing on the C# environment, and the fact that microsoft chose to
reinvent the IDE wheel rather than build it on something prexisting.
Instead of protecting their IDE, which I don't want to do, I'll express my hate
to the pre-existing things one could base IDEs on - say, XEmacs (the
environmental green icon flashing each time emacs lisp looks for it's waste, the
inability to /quietly/, /normally/ copy and paste, and a zillion such things in
the default setting threw me straight into the paws of vim after 2 years of
suffering) and Eclipse (which is so called since it blocks whatever you normally
observe on your machine, such as CPU, memory, pixels, and other things you may
be used to having in a computer).
it's a testament to microsoft's marketing power that programmers are
actually willing to put up with completely tossing visual studio 6 with
something much less stable and much more immature. maybe this has
changed with visual studio 2005, but if I were being pushed to, say,
replace my editor every couple years, that would really put a dent in my
productivity.
Visual Studio 6 supported development using the insane combination of C++ and
MFC. It surely was not fun, but you could do it, and your condition would be
categorized as "stable" in medical terms. With the advent of C#, they decided
they don't like supporting this shit of theirs, but they didn't explicitly say
so, counting on their developers to figure it out themselves. The ones who
refuse to realize this are likely to end up desperately wounded by the thousands
of tiny pieces of glass and excrements spread throughout what's supposed to be
the new MFC on top of the new C++ compiler.
If someone working on Windows wants to start a new project, C# is probably not a
bad idea, since they like supporting it (today). If that someone is stuck with
COM, MFC and that kind of thing, I'd suggest considering, in this order:
* if you don't want to end up at this point again, rewrite everything in
something portable which won't change under your feet too fast (Qt for GUI, etc.)
* if using a Microsoft set of tools is somehow better (more relevant people know
it, for example), rewrite everything in C#/.NET which will work in the near future
* if you can't rewrite it, try to keep using the old tools like VC++ 6
* if they break into little pieces, try shooting yourself
By the way, the editing parts of the IDE are pretty compatible with the old
version. Most poison is stuffed into the compilers, the libraries, the
languages, the OS, the component models, and their interoperability.
wrestling with development tools unnecessarily is a waste of development
time. that is a tautology but I'm amazed how much time many programmers
(myself included) spend rationalizing toolchain upgrades.
Sure. Toolchain upgrades are hateful. They should be done if there are really
big benefits and really few choice (what you use is really old and lots of
things you want to use won't work unless you upgrade and the old tools by
themselves won't work in today's environment).
On the other hand, if you start a (really) new project, you can pick the tools
you like and can afford, and new ones may (or may not) be a good choice.
I personally hate changes. When someone showed me 10 basic ways needed to stay
alive with vim, I ditched emacs and have been using vim happily ever after. The
guy who tempted me into trying the novice-hostile program, on the other hand,
has changed a dozen of environments, because he likes change. I'd say he's more
productive because of that.
