
Why I Left the .NET Framework - scottc
http://blog.jonathanoliver.com/why-i-left-dot-net
======
scottc
It needs to be mentioned, if not for comments here then at least the comments
on his own blog, that the author was not someone who simply dabbled in .NET
and is trying to bash it for the sake of bashing something. The author,
Johnathan Oliver (no, not that one), is an absolute authority on distributed
architecture and created what became one of the biggest open-source projects
in .NET
([https://github.com/NEventStore/NEventStore](https://github.com/NEventStore/NEventStore)
\- originally joliver/eventstore).

His work had a significant impact on my adoption of CQRS and Event Sourcing,
patterns that are becoming very popular in Java, Scala, .NET, and to my
surprise, Node. I've been happily programming in python for the last year and
happy to see CQRS is starting to get more recognition in the community. I'm
going to do what I can to help build its momentum, but it certainly doesn't
have the same adoption compared to the .NET community.

So, when someone who has done so much work in the framework starts to question
it, I will certainly give their opinion some thought instead of firing a
retort:

> _It 's OK to rant but at least get your facts straight. The rest of your
> rant looks quite foolish as well. For example, firing up a Windows VM is
> rather fast if you try it in Azure._

------
com2kid
Some really good criticisms, but I do wonder how long ago this developer left
.NET.

.NET is now heavily async based. WPF may have started it years ago, but async
has been a keyword in the language for quite awhile! (I haven't used a proper
lock in ages. Event queues are where it is at! Or pick your favorite paradigm,
heck the framework comes with thread pools built in that it'll juggle for
you!)

In regards to .csproj and .sln files, they serve the same purpose as make
files. .csproj files (and .*proj files in general) are incredibly powerful,
you do not even need to use Visual Studio with them. They interact with
MSBuild to do some insanely extensible things.

That said, merging .sln files is horrible, the bloody file format has an
element that is a count of project element nodes in that same solution file,
if two people try to check in a new project to a solution at the same time,
the project count field gets corrupted and life gets seriously un-fun. :( The
SLN file has a number of other issues as well, ugh! But .csproj files are
pretty nifty, no worse than any other makefile replacement.

As for Visual Studio, I run it just fine on my Ultrabook! Huge project, it
works well. Not perfect, but good enough. VS2013 fixed some very blatent
threading bugs that VS2012 had in its UI (oops!) and things are generally
snappier now.

Oh and VS support for git has been around for awhile. :) TFS also has really
good git support, it has been improving with every version and it is now at a
really good place.

All in all though, some very good points of criticism! No programming language
ecosystem is perfect! (Disclaimer: I m mostly use .NET for client apps, I
haven't done server .NET stuff since 2.0!)

~~~
zaphar
I recently had to spend a lot of time with csproj files. They look and behave
rather a lot like Ant/Maven. This is _not_ a point in their favor.

Ant/Maven was loved and then subsequently hated by a lot of java developers.
XML is an extremely verbose syntax to have to deal with.

But the real killer is one of lockin. Yes you can use msbuild to do things
with them but the syntax is really designed not for a developer to read/edit
them but for an IDE to serialize state to. Just because there is a command
line runner doesn't mean the format is developer friendly. As long as you stay
in VS you won't really notice. As soon as you leave though its no longer
comfortable. csproj files are one thing I wish .Net had taken a different path
from java in.

~~~
Gmo
FYI, next version will have a JSON-based project file (whether this is better
or not is left as an exercise to the reader).

~~~
yaur
JSON vs. XML is largely irrelevant IMO. What is needed is something with as
little extra crap as possible so that it is possible for a developer and/or
diff tool figure out what is going on with the file.

~~~
MichaelGG
The only real relevant part is that this means no comments. So if you DO
decide to do something neat in your build files, you can't note anything about
it. Or easily remove pieces for testing.

But it's JSON which is so hip instead of XML which is so bloated. /s

~~~
dkuntz2
You could use YAML, which is also kinda hip, but still allows comments...

------
wvenable
I agree with the author on one point in particular: Choose the right
technology for the task. The author doesn't state what his task is but he does
drop a few hints that does indicate that .NET/Windows is the wrong technology
for his task.

I think the authors view of Unix guys is a bit misplaced. I guess I could be a
Unix guy -- I work with many different operating systems, programming
languages, tools, etc. But in addition to all that, I also more recently have
worked in Windows with C# and SQL server. One doesn't have to choose one side
or the other -- you can choose the best tool for the task and have that
include .NET if appropriate.

A lot of the "The Bad" is true of any platform; not specifically that list but
in that every platform has pros and cons. If you choose Java, you'll have a
different list. If you choose Ruby, you'll have another list. Depending on
your task, you might be bitten pretty badly by whatever is on the bad list.
Conversely, you might save a lot of time and headache from what is on a
platform's Good list. And .NET is extremely efficient for some tasks.

It's actually really hard to know multiple operating systems, windows
managers, desktop managers, file systems, package managers, etc. It's really a
waste of brain space but a necessary evil. You can still only be an expert in
a subset and muddle your way through the rest. Once you've learned a
technology and everything about it then the next time you need to do a job
you're likely to pick that technology even if it's not objectively the best
choice for the task. So Java begets Java, Ruby begets Ruby and Windows begets
Windows.

~~~
com2kid
> It's actually really hard to know multiple operating systems, windows
> managers, desktop managers, file systems, package managers, etc. It's really
> a waste of brain space but a necessary evil. You can still only be an expert
> in a subset and muddle your way through the rest.

This is incredibly true! I'd argue that even on a given platform, that one
only ends up knowing a portion of it!

Heck a part of it is just stuff learned through osmosis. If I'm on Windows I
know I can use tools from Sysinternals[0], such as Process Monitor, to save
myself hours of time. Put me on *nix and I do not know how to do equivalent
system level traces. But I've met many highly experienced cross platform
developers who also don't know about Process Monitor, oops!

These platforms have decades of history behind them, a specialist in just one
will always know more than a specialist in multiple!

[0][http://technet.microsoft.com/en-
US/sysinternals](http://technet.microsoft.com/en-US/sysinternals)

------
double051
> Not having a debugger is actually a liberating experience because it forces
> you to code in a different way.

Not having a debugger is like living in the stone age. Personally, the the
ability to inspect application state at runtime is non-negotiable.

~~~
pjmlp
Fully agree. Some developers like to live in green phosphor vt100 days.

~~~
bnolsen
reliance on debuggers is a wierd strange concept. Debuggers are utterly
incapable in multithreaded environments. Just write damn unit tests and
simulations!

~~~
bunderbunder
Depends on the debugger, really. One thing the Visual Studio team's been doing
lately that I appreciate is working on improving their multithreaded debugging
story. Nice visualizations for keeping track of parallel call stacks and
whatnot. The actual step debugger itself still leaves much to be desired - the
UI doesn't give you a lot of help with keeping track of when a context switch
happens, for example - but even there it's not utterly incapable.

------
Mithaldu
> traditional Windows devs are typically only good at Windows and get lost
> very quickly outside of their comfort zones, _which is not true for Linux
> devs_

Strongly disagree. I've watched scores of Linux-only developers try to do
things on windows machines, stumble over small things, and then proceed to
blame windows instead of realizing they simply lack experience.

~~~
reitanqild
Long time user of both nix and Windows here:

At least around here it seems anyone can be a Windows dev/admin while becoming
a *nix admin often takes some dedication.

And to this day the amount of busywork that Windows admins and devs find
acceptable still amuses me and not in a good way.

~~~
yardie
Are you sure about that? Is it that since Windows compromises 90% of desktop
its reasonable to assume that a lot of people have put in 1000s of hours of
using, developing, and administering it.

As a counterexample. My Linux servers, when presented with 4 NICs and multiple
VLANs, doesn't know what to do with them. I had to edit the iptable. Something
that I still haven't needed to do to any of our Windows server.

Different strokes for different folks.

~~~
reitanqild
Late reply, but yes I am reasonably sure.

A big part of one of my previous jobs was setting up Windows and Linux servers
and linux workstations. The severs invariably had 4 nics.

I never, ever had to adjust iptables on any if them. Setting them up is mostly
a breeze except for application specific stuff ($$$ stuff, not open source).

I don't know what distro and hardware you used though.

------
jerryhuang100
"Computing is SO much bigger than just Windows." "In other words, Windows
begets Windows."

That's so true! I always roll my eyes when I hear someone says "everything
could be done under the MS dome with this and that... blah blah". Yeah, surely
it will work, but that does not means there is no better, cheaper (free!) and
more advanced solution in the Tech universe.

~~~
_random_
The reverse is true as well, unfortunately. Especially now that Microsoft is
getting more and more open-source.

------
romanovcode
I wonder how long did the author was using .NET since "bad" points were very
weak.

Also, it seems that author isn't really interested in what's happening and
what MS already done to improve .NET. Like integrating Git with MS, async,
open-sourcing C# source code, moving away from IIS to OWIN, K runtime, SqlDb
as file.

And also, if you don't like that Visual Studio is heavy you are free to use
Vim with custom run parameters that will compile your code. However part of
why C# is so good actually _is_ Visual Studio.

As for "Windows devs are typically only good at Windows and get lost very
quickly outside of their comfort zones". This is just plain wrong. It depends
on person. You are not your IDE, you are not your programming language, you
are not your OS.

~~~
sklivvz1971
"Windows devs are typically only good at Windows and get lost very quickly
outside of their comfort zones"

this is actually an oxymoron. Assuming we are talking about a one-trick pony,
yeah, I can see how that is possible, but it's clearly a straw-man argument.

The problem is the mindset that all .NET developers are .NET developers only.
This is completely false -- all good developers I know are comfortable on a
number of platforms.

------
unethical_ban
> Why do we develop this way? Why aren't we considering the behavior of the
> application more than how it's stored? All of my projects now utilize a
> JSON-based key/value store.

What a self-centered statement. "MY projects don't need ACID or relational
enforcement. Therefore, SQL is useless."

~~~
platz
Yeah, I was particularly amused by OP's statement here.

~~~
jonathanoliver
As the original poster, I have found that relational databases have become our
favorite hammer. The point of my post however is that things like the modern
NoSQL movement did _not_ originate in Redmond. Open source drove NoSQL to the
forefront. If it were up to Oracle and Microsoft, we'd be using RDBMS forever.

~~~
platz
point about origination granted, though for some folks NoSql has become a bit
of a hammer itself [http://use-the-index-luke.com/blog/2013-04/whats-left-of-
nos...](http://use-the-index-luke.com/blog/2013-04/whats-left-of-nosql)
[https://news.ycombinator.com/item?id=6712703](https://news.ycombinator.com/item?id=6712703)
. Of course, all hammers are bad, SQL or NoSQL - use the right tool for the
job.

------
pjmlp
I am technology agnostic developer, a mercenary jumping across technology
stacks, from project to project, according to customer wishes.

Actually most of the Linux guys I know, can only manage a specific
distribution.

They aren't even aware how commercial UNIXes work or how POSIX is not as
standard as they think it is.

The fact is, that it is just impossible to know everything across multiple
systems.

------
NicoJuicy
.Net developer here.

I think VS is really awesome and a + for .Net . The support for Mono and cross
platform has grown and Microsoft has shown interests by partnering with the
team behind Mono..

IIS is getting decaprecated (= The OWIN project).

LocalDB doesn't require you to create a new database and you really have a
json file as database . You can just use it, it's called Biggy and it's on
GitHub (
[https://github.com/robconery/biggy](https://github.com/robconery/biggy) ). (a
file based document store). - i used it and it works. - It's actually more
then a file based db, but check it out if you're interested.

Git support is build-in (already a long time) and TFS seemed to work for me (
i use Visual Studio Online).

Using Windows, well. I think this is "currently" a no-brainer. But Mono will
be more important, so it should become usable on Linux also... (normally).
Btw. I use Linux tools on my Windows machine all the time, stuff like
Cygwin,ImageMagick, Go, Ruby are installed by default on my development pc....
It doesn't mean i can't work in Linux (i also have a Pi which requires me to
work in it). Currently, i just prefer Windows

~~~
hudo
> IIS is getting decaprecated (= The OWIN project)

Thats not even remotely true. How does Helios works then, which is also owin
component?

~~~
NicoJuicy
Perhaps decaprecated is a strong word, using IIS becomes optional thanks to
OWIN would be better.

OWIN replaces the hosting part of IIS, so while you will always be able to run
Asp.Net websites on IIS, IIS isn't a requirement anymore. (OWIN = Open Web
Interface for .NET)

See the following link for a more thorough answer.

[http://stackoverflow.com/questions/21308585/when-should-i-
us...](http://stackoverflow.com/questions/21308585/when-should-i-use-owin-
katana)

Or
[http://www.dotnetcurry.com/showarticle.aspx?ID=915](http://www.dotnetcurry.com/showarticle.aspx?ID=915)

Project Katana is a collection of projects for supporting OWIN
([http://owin.org](http://owin.org)) with various Microsoft components. So
yes, that obviously uses IIS. But IIS can be replaced by Apache or NGINX in
the near future. Katana could be used as an example to implement the same
thing for those webservers.

------
jeroen
"Why do we develop this way?"

I think that's the central question in this post. And for me, "because you
have to in .NET" is not the answer.

I have no problems not using TFS, not creating database-centric applications,
not using ReSharper.

------
Maarten88
I agree with most of the critisisms, but Microsoft is also seeing those
problems and is actively fixing them in ASP.NET vNext[1]:

\- It's really crossplatform and open

\- It does away with the IIS / System.Web dependency

\- It has clean json based project files that can reference project
dependencies locally and also on nuget and github

\- It unifies the ASP.NET MVC and Web API frameworks and other good things
like SignalR

Which only leaves the traditional mindset of .NET developers (SQL Server and
Entity framework as the default data technology) as problems. In the right
environment those remaining problems can be worked around.

[1] [http://www.asp.net/vnext/overview/aspnet-vnext/getting-
start...](http://www.asp.net/vnext/overview/aspnet-vnext/getting-started-with-
aspnet-vnext-and-visual-studio)

~~~
jonathanoliver
How many of these ideas would have come from within Microsoft had in not beed
for the ALT.NET movement and .NET developers looking outside themselves to
other communities?

~~~
Maarten88
Probably none. Does it matter? The point is that they seem to have lost the
NIH mentality, which is a Good Thing.

------
SideburnsOfDoom
> I consider .NET to be an ecosystem including all tools, projects, platforms,
> organizations, and groups of developers.

Well, that explains the otherwise baffling statement "I left .Net because ...
git is so much better than TFS"

That is an opinion that I also hold, but isn't relevant.

If the conclusion is that "but .Net comes with a mindset of using all and only
the MS tools" then yeah, avoid narrow-minded people. Again, is that relevant?

~~~
MartinCron
Yeah, I don't see this problem. Maybe I'm just an outlier, but when I was a
.NET developer, I would use non-MS tools all the time. Git _is_ better than
TFS, just as nUnit is better than MSTest. TeamCity is better than TFS. Visual
Studio with ReSharper is better than Visual Studio without.

Good technologists will use a heterogeneous toolkit no matter what ecosystem
they're working in.

~~~
jonathanoliver
The trouble is that "the ordained path" is MS tooling all the way. I suppose
there's a lot of pressure on MS to provide a prescribed method and they're
satisfying a market demand, but when I worked in .NET I had to make very
deliberate choices about avoiding MS tooling and keeping it pinned back into a
corner of my project. If left unchecked, it would try to dominate by default.

~~~
SideburnsOfDoom
> The trouble is that "the ordained path" is MS tooling all the way

Every .Net shop that I've walked into, "the ordained path", speaking about the
coding culture, was nUnit, TeamCity, Resharper, svn (later git) etc. Maybe you
worked at the wrong places.

My anecdote doesn't trump your anecdote, but the reverse is also true.

------
shams93
The problem is that while c# is useful for large programs when it comes to
doing small stuff like validating and connecting data sources Node or Python
are superior tools, but the engineer is shackled, management wants to see
every tool written in c# even if c# is ill suited for the task and its
possible to use the standard .Net build tools (Visual Studio) to build and
test Node scripts for Windows servers.

When I want to run small tasks I want a scripting language. I don't need a
full blown type system, I'm importing from strings, what I need is a Nodejs
ten liner, not having to build out a DAL just to run what in the Linux world
is going to be a shell or python sys admin script.

~~~
_random_
That is not a problem of C# or even Microsoft. The problem is that
"management". Use Python and tell them it runs under .NET as well (which is
true - IronPython).

------
edtechdev
For what it's worth, .NET had those same issues 10 years ago when I left it
(for java, then in 2008/9 for javascript/html5). From an educational software
perspective, the lack of an equivalent to java applets (I know, they suck, but
back then there wasn't a better alternative), and a lack of cross-platform
browser support was a problem. And without Microsoft support or assurances,
the Mono project, while they did incredible work, divided the Linux world
because of a fear of Microsoft's patent lawyers.

------
chrislomax
While I agree with some of these points the biggest one for me is client
adoption.

All clients assume everything is run in Linux. I don't even know why this
mindset is so popular.

When we develop something and the client wants to host it I can guarantee
(more or less) that the platform is Linux and they want to know why the
software we have written doesn't work on Linux.

I know there is Mono but I always use IIS to run our software as that's what I
am used to and that is the platform is is _meant_ to work on.

I do love .NET, I've used it since it was launched. I do want to have a change
though. I just don't know what language to dip into next.

I'll never leave .NET though as it's where I really started programming (after
VBA...). I've just discovered Umbraco too which I've just fallen in love with.

Recommendations on languages I can try would be appreciated. I don't like this
minefield we are in at the minute, I never know what is going to stick around
and what is a fad.

~~~
pjmlp
> All clients assume everything is run in Linux. I don't even know why this
> mindset is so popular.

Might be on your part of the globe. On my little world, we have enough Windows
only clients to keep us busy.

~~~
chrislomax
We are based in the UK. I don't know if it's the clients and the type of work
we are filling but we seem to be migrating a lot of people from Wordpress so
typically they expect everything to still run on Linux.

Our clients are normally ones who have come from a small background and are
growing quite rapid, this customer is almost certainly on some type of Linux
offering.

It's probably a mix of the clients we target and the geographical location.

~~~
pjmlp
On my case, Germany with lots of Fortune 500 clients.

~~~
chrislomax
What size of projects are they?

We do a lot of integration projects with our clients, ie integrating with CRMs
/ ERPs and the timescales on these projects is usually about 10/12 weeks. I
enjoy this project turnaround as it means I'm never stagnant on the same
project for long and I get to experience new things.

I imagine the projects for a Fortune 500 is 1 or 2 years long with thousands
of man hours?

EDIT: Clarified a question

~~~
pjmlp
> I imagine the projects for a Fortune 500 is 1 or 2 years long with thousands
> of man hours?

Yes. Also multiple consulting companies working on the same project.

------
DenisM
It reads like his primary complaint is being forced to use "one true way", and
the entire article and his decision are some sort of rebellion against this
monstrous oppression, which he never describes in any kind of detail for us to
understand what it is. I've been ising .NET for several years now, and the
only complaint I can relate to is VS being a fat pig.

Many of his complaints about not being able to use other databases, lack of
non-locking paradigm (async/await, parallel LINQ), are simply ignorant. And
then he talks about windows devs being close-minded...

~~~
jonathanoliver
vim is a breath of fresh air compared to VS, which you've mentioned is a
resource hog.

A lot of the oppression comes from the mindset in various organizations that
"we must use Microsoft" (because it's safe, because they provide support, etc.
etc.) and thus looking outside is actively discouraged at an organizational
level. While I can't say that Microsoft directly encourages this thinking, in
the past they've certainly not discouraged it.

I would have loved to use async/await when they existed, but they didn't at
the time. AND I needed it to run on Mono which didn't support those language
capabilities yet. Things are improving dramatically, but I've moved on to
greener pastures.

------
Locke1689
Good article. A lot of the criticisms are ones that I often hit as well. I
would probably dispute the asynchrony/performance one, though. C# async is
very efficient -- a lot more efficient than many other eventing frameworks in
many other languages. In addition, I don't really think that locks are
specifically put ahead of lock-free things like InterlockedExchange when
dealing with multithreaded code -- it's just that writing lock-free
datastructures is so damn complicated (seriously, read the literature, it's
really hard to get right), that for the everyday programmer a lock is the way
to go. Moreover, there's not really a connection between async/eventing and
locking; they're somewhat orthogonal. In large applications I would probably
see a healthy dose of both. Async doesn't help with CPU-bound computation and
threads aren't really the best way to deal with concurrent IO-bound
computation.

Otherwise, I strongly agree with the points about Mono. Speaking personally, I
would love if more of the .NET platform were extended for use on Linux, as I
think the Windows CLR GC is still pretty far ahead of the Mono implementation.

------
driverdan
Serious question: If you're building web products from scratch and can choose
your environment why would you use .NET (other than "because I know it")?

I've personally never used it because I'm opposed to closed-source single
platform languages / frameworks and would like to understand the mindset of
those who use it.

~~~
DenisM
1\. c# is a great language - LINQ and type inference make it as succint as
python (or even more when I use extensions methods and generics!), static type
system gives a lot of safety eliminating huge classes of bugs, decent
performance compared to other succint languages like Python or ruby. Really
hits the spot for me, and I would hate to go to a dynamically typed language
now.

2\. VS is a great IDE if you give it enough RAM.

3\. LINQ2SQL makes for quite pleasurable, succint and type-safe database
manipulation. Bulk updates suck though, but that's an ORM for you. SQL is also
a good database, and when time is right I can make use of remote database
mirroring, instantly boosting my fault-tolerance. I could use Postgres as
well, but SQL tips the scales with LINQ2SQL.

4\. Reasonably popular, compared to web dev in other succint statically typed
languages say, Haskell. So I can find answers on stack overflow.

5\. Nuget. Sometimes I need a commercial package, and I can often times just
get it from Nuget, play with it, and then punch in serial number after paying
to remove watermarks etc. It's nice to have those packages for when I need
them, to be able to buy my way out of problems.

6\. Backward compatibility. I heard that ruby was breaking it more than once
and python did it once. .NET seems to be less prone to this.

And I really see no downsides to it. Windows is only 20% more expensive on
AWS, and hosting is literally the last on my list of expenses. Performance is
good enough for me - given my business model I will be able to afford a small
data center before my single Windows server gets too small for my workload. VS
is slow, but buying extra RAM is a small price to pay to get it up to speed.

~~~
jonathanoliver
On AWS booting Windows can easily take 10-15 minutes. On the same type of EC2
instance, it takes 30 seconds. This makes auto scaling quickly very difficult
because you have to scale up in anticipation of demand rather than as it
occurs.

One other problem is that Windows by itself easily takes 1+ GB of RAM whereas
Linux can easily run 64MB-128MB. So while Windows may only be 20% more
expensive for similar hardware (which I don't object to either), I can run
cheaper hardware and have more of it available to the application instead of
the OS. Our metrics show the savings to be about 60% less expensive when
counting hardware and licensing costs.

~~~
DenisM
The boot time is annoyance, and resource hogging is unfortunate, but I can
easily buy my way out of those problems by buying bigger machines and doing it
in advance. My time is more valuable, I think, and server costs are negligible
next to payroll. There are business models where hardware costs dominate like,
I don't know, video processing or something, but most startups are not in that
boat - they need to iterate on UX as fast as possible.

------
whileonebegin
I think there is migration away from .NET underway, as Windows loses market
share to other OSes. Desktop apps are becoming more rare. Web apps are being
written in open-source platforms. A lot of the companies still using .NET are
large fortune 500 ones, maintaining existing systems. Remember Cobol? I'm
almost at the point where I consider .NET legacy. Perhaps, not yet, but maybe
in 5 years. Does this mean the well is dry for .NET developers? Not at all.
Large companies will pay small fortunes to find people to maintain their
legacy systems. Either way, I think it's important for developers to become
proficient in multiple programming languages.

~~~
UK-AL
People said that about java ages ago. Never happened.

------
ecspike
The multi-lang JVM was a thing for as long as the CLR was. Rhino and JRuby are
older or almost as old as C# itself.

------
icantthinkofone
When I first got started in web development, my brother-in-law managed a large
Microsoft shop and got me started with all the software I needed to get going
for a huge project I managed to wrangle using .NET when it was at version
1.5(?). We worked on that for something like six months until, one day, all of
a sudden everything was version 2.0(?) and it all fell apart!

We quickly called my brother-in-law in and he couldn't figure what was going
wrong either. After a few weeks, we had to throw in the towel and, on his
suggestion, switched to Linux and then FreeBSD. Three months later, everything
was humming along and we're still doing everything with FreeBSD.

Later, I don't recall the details, but there was some major change between
versions that was what screwed us up. I know some Microsoft people will know
what I'm talking in that .NET version 1.5 to 2.5 range but it hit us hard.

~~~
overgard
There wasn't a 1.5, so you're probably thinking 1.1 or 2.0. As far as I know
it's been pretty good with backwards compatibility though. I used to do a lot
of.net coding, and the only time I've seen compatibility issues upgrading was
with beta versions (and even then, I only saw a small handful).

~~~
jonathanoliver
One really big advantage I saw of running .NET was that the upgrade path from
1.0 -> 1.1 -> 2.0 -> 3.0/3.5 ->4.0, etc., was quite painless. Other than
having to purchase a new copy of VS each upgrade, the tech side was really
easy. This is unlike the Python 2.x to 3 migration which continues to hurt.

