
Why I Left the .NET Framework (2013) - Immortalin
http://blog.jonathanoliver.com/why-i-left-dot-net/
======
V-2
Some of this criticism was outdated already, or has gone out of date since.

WebForms (with their underlying concept of abstracting away how web really
works) were already in decline two years ago, replaced by MVC.

As a former C# developer, turned Android developer, of course I have to admit
there is some walled garden mentality among .NET devs, but I think they get
stigmatized for that way more than average. If a Rubyist never sticks nose
outside their beloved technology stack, noone makes such a big deal out of it.

Also it's nothing in compare to vitriolic anti-M$ hater mentality, often
directed at developers themselves.

Or bizarre anti .NET-bias, case in point:
[http://blog.expensify.com/2011/03/25/ceo-friday-why-we-
dont-...](http://blog.expensify.com/2011/03/25/ceo-friday-why-we-dont-hire-
net-programmers/) (I'm sure Jon Skeet was devastated).

And what's changed since 2013? Quite a lot: Roslyn... open-sourcing .NET...

~~~
vinceguidry
> If a Rubyist never sticks nose outside their beloved technology stack, noone
> makes such a big deal out of it.

To be fair, Rails is _amazing_ , the most cutting-edge web framework out
there, and it's settling into adulthood nicely. The Ruby ecosystem is so
perfectly suited to web development that one hardly needs to go elsewhere to
get what one needs. Whatever you could need is right at hand.

The .NET dev sitting across from me doesn't even use legit source control. He
has his own hacked-together solution for his own projects, but most of what he
does, he claims source control just doesn't work.

I think the main problem is that .NET tries to be all things to all devs, and
so ends up solving no problems really well. People really seem to go gaga over
C#, and to be sure the language isn't terrible like C/C++/Java, but it's
pretty damn far from being _spectacular_. Ruby isn't the greatest thing since
sliced bread either, but one can be enormously productive with it.

~~~
justathrow2k
>The .NET dev sitting across from me doesn't even use legit source control.

Well, there you have it, this guy knows a .NET dev who doesn't use legit
version control, so the whole .NET stack is a joke. QED.

~~~
V-2
But it proves my point perfectly - anti .NET "racism" at its finest :) If -
say - some Perl dev with academia background was ignorant of VCS, he'd just be
a bad developer and that's it...

------
minionslave
From the comments: "Why do people have to "leave" technologies? Why can't they
just add new technologies to their arsenals without dramatic quitting blog
posts? You don't see musicians who have just learned to play the guitar
writing "why I'm leaving the piano" posts. Go is great; Node.js is great; some
JVM languages are fine; .NET has a hell of a lot going for it too. Evaluate
your options at the start of every project and use the best tool for the job
at hand."

~~~
mcintyre1994
Amusingly, in his "Why I love Go" [0] linked from that article he discusses
using the right tool for the job:

> Instead, this about the right tool for the job. (Could you imagine
> woodworkers getting into heated arguments about whether a screwdriver or
> hammer was better?)

That would be about as insane as a woodworker writing a blog post about
'leaving the screwdriver' :)

[0] [http://blog.jonathanoliver.com/why-i-love-
go/](http://blog.jonathanoliver.com/why-i-love-go/)

~~~
Retra
You do realize that computer programs and languages are not screwdrivers and
hammers, right? We're talking about a world where screwdrivers and hammers
_both_ claim to allow you to efficiently drive nails and screw screws. It is
very possible for one to be strictly better than the other, and not even
unlikely that one is better in most common situations.

I know "the right tool for the job" is some sort of unchallengeable divine
hacker slogan, but I've never seen that slogan solve a problem. So maybe it
isn't the right tool for _this_ job.

------
aggieben
I think this post is interesting, but mostly at this point useful as a frame
of reference for all the changes that have happened in the .NET ecosystem in 2
years. For example, the server produced by the ASP.NET team (Kestrel) has now
been benchmarked at over 300K req/s, and it's using libuv under the hood as an
event-based IO engine. That's also not to mention that Mono has benefited
tremendously from the new open-source nature of the entire .NET framework, and
is a far more viable portability story for .NET than it ever has been
(although it still has its pain points). Soon enough, Microsoft will have its
own port of CoreCLR for Linux.

Also, relatedly, I think this post is also mostly about the characteristics of
the .NET _community_ and its culture, and less about technology. The
aforementioned recent changes are indicative of substantial growth and
diversification of that community, and I think likely heralds a lot more good
changes to come.

~~~
pbz
> Soon enough, Microsoft will have its own port of CoreCLR for Linux.

CoreCRL alerady runs on Linux -- it's all very much beta though.

------
Const-me
“traditional Windows devs are typically only good at Windows” — why? I
developed for Windows, Nintendo, iOS, OSX…

“NIX guys on the other hand are typically familiar with multiple operating
systems” Nope, they aren’t familiar with Windows. Just an example, I only see
*nix developers started using I/O completion ports (which is the best I/O
strategy for a Windows network servers since Windows NT 3.51) only couple of
years ago, in node.js and libuv. Before that, most Windows ports of cross-
platform servers failed miserably.

“The typical, multi-threaded paradigms in C, Java, and C#” — for C#, those
typical multi-threaded paradigm has changed in 2011-2012 with the release of
TPL, Rx, async-await.

~~~
andyana
I have to agree with the author: the Window's guy are usually the ones focused
on Window's only solutions. Like, for example, a Windows admin having not
heard of nmap. This is common.

~~~
Const-me
Сould you please estimate what share of *nix admins have heard about VBScript,
PowerShell, WMI or group policy?

~~~
andyana
I think you would find most unix admins know of those things. Powershell is
your bash, WMI is your /proc. VBScript and group policy would be things you
come across if you work with Samba.

~~~
Const-me
“Powershell is your bash” — Cmd.exe is your bash. Powershell doesn’t process
text streams, it operates on .NET CLR objects. PowerShell by itself is more
like interactive python shell. But it’s power isn’t language or interpreter,
but the amount of things exposed to that language.

“WMI is your /proc” — also ifconfig, /var/log, /etc/fstab,
/etc/network/interfaces, and a lot more, and with remote access.

“VBScript and group policy would be things you come across if you work with
Samba” — completely unrelated. VBScript is more or less your Perl, but again
with lots of things exposed to the language (besides WMI, there are ADSI, CDO,
etc).

AFAIK there’s nothing in *nix world resembling group policy.

“most unix admins know of those things” — you see? Most unix admins know
almost nothing of those things. So why do you expect a Windows admin should
know about nmap? On Windows, people usually use other tools instead of nmap,
e.g. netstat, portqry, and tcpview.

~~~
andyana
We can elaborate on those all day, but I nailed the gist of it and you know
it.

~~~
andyana
VBScript would be something a Samba admin would know of due to VBS being used
often for login scripts. Netlogon is a share you would have on your Samba
server. Group policy is distributed over SMB. Is this news to you?

~~~
Const-me
“VBScript would be something a Samba admin would know of” — a login script
doesn’t have to be a VBScript, could be CMD as well, or just an EXE. WSH is a
general-purpose scripting environment unrelated to samba. Professional Windows
system engineers use VBScript to automate their tasks, or at least they did
before Win7 took off, with the PowerShell built-in.

“Group policy is distributed over SMB” — SMB indeed takes part in the
distribution, however LDAP protocol plays key role here:
[http://blogs.msdn.com/b/canberrapfe/archive/2012/11/15/where...](http://blogs.msdn.com/b/canberrapfe/archive/2012/11/15/where-
are-site-linked-group-policy-objects-stored-and-why-should-you-care.aspx) Also
it’s less important how they distributed or linked, it’s more important what
they are — and AFAIK there’s no *nix equivalent.

~~~
andyana
You gotta be trolling me. Have fun.

~~~
Const-me
I ain’t trolling. Your problem is, you know almost nothing about Windows, but
you pretend you do.

You don’t even know there’s no VBScript in Word. The language you wrote you
Word macros in 90-s was called VBA = Visual Basic for Applications. Compared
to VBScript, it even have different syntax, and of course, they serve
different purpose: while VBS is for system engineers, they target VBA towards
office users. BTW, I coded both in 90-s.

------
dozzie
> C# is awesome. I think it's a spectacular language.

OCaml, Haskell and Lisp are spectacular. Erlang is spectacular. Tcl and Python
are spectacular. C# is an OK-language at best.

> I'm not aware of any non-Java JVM languages prior to the CLR [...]

Except JVM/Java had JPython, JRuby, and Rhino (JavaScript) earlier. Those are
interpreted, sure, but they were running inside JVM and talking to Java code
already when .NET was first published. The compilation to JVM bytecode is a
minor implementation detail.

~~~
noblethrasher
> OCaml, Haskell and Lisp are spectacular. Erlang is spectacular. Tcl and
> Python are spectacular. C# is an OK-language at best.

C# not only has built-in monad comprehensions, it can straightforwardly
simulate type classes/traits (which even F# can't do). It also has a _full
metaobject protocol_ for handling (extreme) late binding, and a good
concurrency story (though I rather prefer the Actor Model).

Really, C# only pretends to be a blue-collar language.

~~~
masklinn
> C# not only has built-in monad comprehensions

IIRC linq is just a structural transformation. Most languages can define
monadic instances, that's not the difficulty (or the value)

> it can straightforwardly simulate type classes

Without HKT?

> it can straightforwardly simulate traits

by copy/pasting extension methods?

> It also has a full metaobject protocol

you can change the inheritance tree of a C# object at runtime?

------
sadkingbilly
I've been on two interviews recently, and both saw experience in .NET as a
negative. I found myself having to down-play experience in .NET in both cases,
in order to guide the discussion toward more applicable skills for the role.
Even when you may be a polyglot programmer, interviewers tend to label you as
.NET or Microsoft. Which, has apparently become a bad thing. Unless you're
interviewing with a Fortune-100 company, in which case, .NET is still somewhat
popular.

~~~
pm90
I would think twice about joining an organization that thinks negatively of
your former experience in a different stack. Sure, they may not be relevant to
the job at hand, but good programmers will write good code in whatever stack
they have to work in.

------
camkego
Author states "Using the Disruptor (a lock-free ring buffer on the JVM), you
can easily process 20M+ events per second. On .NET using ordained "best
practices" anything more than a dozen transactions per second is considered
decent-to-good performance and at that point, you just need bigger/better/more
hardware."

WTF? This is inane.

~~~
cachemiss
Yeah, he's comparing one of the best optimized ring buffers on the JVM to
actual transactions, that's one of the worst comparisons I've ever seen. I've
shipped large scale systems on .NET and on the JVM, the issues you run into
with .NET are that windows isn't as easy to administer IMO as linux variants,
and your ecosystem isn't as strong, that's about it.

.NET doesn't have a runtime profiler that will deoptimize / recompile etc.,
which can cause slowdowns in certain use cases, it does have a better unsafe
story, and value types, and reified generics which can make things faster for
you.

~~~
jonathanoliver
OP here. I still really like the Disruptor style. You're right, it's not an
apples-to-apples comparison.

------
platz
Interesting that he didn't mention the core idea of this piece that got a fair
amount of attention: [http://www.aaronstannard.com/the-profound-weakness-of-
the-ne...](http://www.aaronstannard.com/the-profound-weakness-of-the-net-oss-
ecosystem/)

Namely, hat .NET developers don't really solve any hard problems

~~~
UK-AL
Ironically I think there a lot of distributed platforms for .net.

NServiceBus, MassTransit. Akka.net, Orleans, etc

~~~
edgyswingset
The author who write that blog post is actually one of the co-founders of
Akka.NET, which was created before Orleans was out.

------
ipozgaj
tl;dr version - it's mostly about the portability, shortcomings of Windows as
OS, and accompanying software (VS, TFS, IIS, MSSQL etc) being bloated. Zero
critics about the .NET framework itself.

~~~
jbigelow76
It's interesting to see how many of the critiques the author cited in 2013 no
longer apply to the .NET ecosystem. To name a few:

* Git is now a first class VCS for use with Visual Studio

* .NET development no longer tied to Visual Studio thanks to things like VS Code or OmniSharp with Submline

* .NET development no longer tied to Windows, dev with a Mac or Linux using .NET core

~~~
jonathanoliver
OP here. My concerns have been or are being addressed. We're still a ways off
from having things solid on Windows and Linux. All things considered, I'm
happy with Satya's leadership of Microsoft over the last few years.

~~~
wdmeldon
I only wonder how far these new attitudes will seep into the general .NET
developer culture.

------
potato
Outdated. Microsoft has clearly embraced open source, and is facilitating
cross-platform .NET development (OmniSharp, ASP.NET 5). Async is a thing. SQL
Server is not a con, switch to something else. Mono is reason to leave mono,
not .NET.

~~~
jonathanoliver
OP here. The post was written 2 years ago before async/await were a thing and
.NET only worked on Windows.

------
intrasight
The best language is the one that can get your job done and for which you are
able to hire competent developers.

~~~
chris_wot
PHP?

~~~
gregmac
Competent developers can be good in _any_ language. Bad developers are bad
_regardless of language_.

You don't hear people say things like "Oh, that guy was an amazing <language>
developer, and could build awesome, solid easy-to-read and high-performance
code, but his <other_language> code is so bad nothing short of a complete
rewrite can help".

------
DanielBMarkham
I find I agree with the author on the details of his argument yet have reached
a different conclusion.

Dude. It's not .NET -- it's the Windows/SQL Server/VS/etc toolchain. Dump the
toolchain and work on linux in Mono. Yes, it is a second-class citizen. But
even then, it's a hell of a bag of goodies for free.

I got really tired of the MS ecosystem as well. And I feel for those still
stuck in it. But why would I want to ditch the CLR, a big honking beast of
code that is being tested billions of times daily? Why give up all the
libraries created by devs all over the world?

I went with F# and mono and am really happy with it. If I need database
support, I pick up something off the shelf. Simply because I use .NET doesn't
make me a prisoner of .NET-think.

~~~
jonathanoliver
OP here. You're correct that most of the problems were related to the
toolchain and Windows.

I did a lot of work using Mono for over a year. After submitting dozens and
dozens of bug reports and pull requests to the project, I finally had to get
some work done.

------
bitwize
Non-Java JVM languages have been part of the Java ecosystem sincw the
beginning, from Pizza and Kawa on forward. Maybe .NET made more developers
comfortable with that, but I think it had more to do with that the JVM enjoys
HUGE cross-platform library support, solving the bootstrapping problem for
getting a new language out there and used.

------
cptskippy
After reading about halfway through this I scrolled to the bottom to look for
the punch line but there was none. This article comes off as the frustrations
of a developer who was forced to use Windows and didn't like it (Boo hoo). A
lot of the "issues" he had left me scratching my head and a lot of the
observations he's made seem to be very anecdotal.

> As covered previously, Windows is not a good player when it comes to
> network-based server software.

What is the definition of "network--based server software"? His "as covered
previously" article doesn't even contain the word network in it, so it's
really unclear what he's complaining about to begin with.

> One other really big problem I see with Windows is that 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.

That's an anecdotal observation at best. In my opinion most developers have
comfort zones and get lost very quickly outside of them. The difference
between a good developer and a great developer is that the great developer
doesn't back down from a challenge outside their comfort zone and are willing
to learn new things in-depth.

I know plenty of good developers who are only good in their language of choice
and have no interest in moving outside of that tool-chain. I've worked with
plenty of PHP and Ruby developers who deployed to Linux and they didn't know
their ass from a hole in the wall regardless of their OS of choice. I've also
worked with a few Linux C/C++ developers on some projects and they had a very
thin understanding of C#, often coding things from scratch that were built
into the language. Not to mention their love of nested loops. I've also worked
with some amazing OSX developers who had the same level of comfort on Linux
that I do and were about as comfortable in Windows as I was on OSX (i.e.
better than average). But none of that matters because it's all anecdotal.

> I had a Core i7 3770K 3.5GHZ desktop I built with 16 GB of RAM and a Vertex
> 4 512 GB SSD. It literally maxed out the Windows Experience Index and
> Windows + VS was still slow.

I HAVE a Core i7 Q820 1.73Ghz laptop issued by work with 20 GB of RAM and a
Seagate Momentus 320GB HDD with McAfee software based full disk encryption. It
literally has a Windows Experience Index of 5.9 and Windows + VS IS perfectly
fine.

I'm really not sure what he's done to his system, maybe he forgot to mention
that he was running Windows 7 in a VM on Linux and everything down to the disk
was virtualized and there was no hardware acceleration. I see no other reason
why his performance would be intolerable.

> Now I dev on a MacBook Pro which has less CPU horsepower than my beefy
> desktop and things are noticebly faster and the UX is infinitely better
> after a small learning curve.

Seriously? Linux is better than Windows because you use a MacBook Pro and
OSX's UI is better than Windows? Is that's what you're arguing?

It's at this point that I stopped reading and scrolled to the bottom.

------
droz
I began writing C# in 2004. I've been writing it since for business and
pleasure. Since Microsoft began adopting a more open source approach, it's
been, well, amusing to see the open source culture collide with has been
historically a closed system.

"Why isn't there a free, open package that solves hard problem X, it's 2015
after all. How preposterous!" The naivety displayed in these kinds of
statements is amusing. There are probably many solutions to hard problem X
locked away in proprietary "Microsoft Shop" code bases around the world. It's
incredibly daft to assume otherwise. Does this approach lead to a lot of
duplicated effort- yes; are there a lot of hacked together half working
solutions out there- yes; has the .NET community been ok with this- yes. As is
the culture of .NET. It's the fine art of not giving a shit because you're
going to get paid anyways.

"Oh these poor .NET bastards, they're just sooo clueless of the world around
them; they only know Windows." I'm sure this could be said of just about
anyone. All tech stacks have their stars and fry cooks. As with many things,
it's a matter of how you want to dedicate your time. Could I spend my time
focused on file system design, memory issues, and network architectures.
Absolutely! It's great that people enjoy this stuff; I personally don't. It's
boring to me same reason I don't enjoy futzing around with Linux. I don't care
about how it works; just that it does work. When I write for the .NET/C#
stack, my focus is on the business problem. How do I impact the end-user (ie
Shannon over in accounting, or little Timmy dipshit in Iowa) in a positive
way.

"VS also has this really nasty habit of creating "csproj" and "sln" files. I
hate those things." this is like bitching about make files. It's beyond silly.
Could it be improved- probably, does it need to be- no. I think make files are
a horrible way to do things, do I bitch about it- no. I understand that that
is the preferred approach of the environment. Learn what I need to do to make
it work and get on with my day. And really, these types of complaints are just
childish. You're a professional. Deal with it.

As far as IIS is concerned, we can have a ceremonial burning of the source
code one day. That product is beyond useless.

The selling point of C#/.NET isn't it's community- it's its productivity. A
company can hire a small team of developers and they can crank out a bunch of
code in short order to solve some specific problem. The code will be written
the ".NET way" not because that's what's best for performance, but because
that's what's best for development. Same thing happens in other technology
stacks. Code is written to follow a well followed pattern by its community so
that new hires and other developers can quickly suss out what's going on
without having to stop and think. It's the same song and dance of using third-
party libraries. Bit like a royale with cheese instead of a big-mac. Dress it
up different, but the same principles are at play.

Fundamentally, there's going to be some cultural exchange between the
traditional .NET crowd and the open source crowd. Both parties stand to learn
a lot from one another, and have lots of opportunities to discover overlap.
Rather than throwing in the towel and saying .NET is bullshit and used by
dullards who solve inconsequential problems is short sighted. Find a place for
.NET in your stack, look for opportunities to mix it in with your existing
open source technologies. If you can't find a spot for it, then move on to
whatever works for you. It's not rocket science.

------
WorldWideWayne
"In fact, I don't even use a mouse anymore--my hands are always on the
keyboard or trackpad and I can gesture to my computer and actually have it
respond--unlike Windows."

I use a keyboard all day with Windows. I can do every single thing that I need
to do with just the keyboard, no problem.

I also use Gnome 3 and OS X and I honestly don't think keyboard support is as
good in either of those. So I am sure that I don't know what this gentleman is
talking about.

