Why I Left the .NET Framework (2013)
blog.jonathanoliver.com
blog.jonathanoliver.com
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-... (I'm sure Jon Skeet was devastated).
And what's changed since 2013? Quite a lot: Roslyn... open-sourcing .NET...
Yes, exactly right.
> to vitriolic anti-M$ hater mentality
Right on - this isn't what OP was demonstrating, I think, but general reactions to Microsoft technologies are pretty bizarre. Use it or don't, but I don't get all the hate.
What part of .NET is unreliable?
Anyway, Microsoft has always been relevant and dangerous. Now that they are starting to release cool products they could definitely be a problem. Apple self-regulates because their products are expensive. Microsoft on the other hand, was never afraid of taking it all.
http://www.computerworld.com/article/2893514/an-incredibly-s...
At this point, MS hate is rather pointless, but the closest analogue is today's Apple hate (and to a lesser extent, Oracle/Java hate, and today's small but growing Amazon cloud hate).
Microsoft was the king of the hill in the 90's through early 2000's, squashed small companies everywhere when they released competing products, threatening to sue IT shops (by NDA, no less!) that used Linux for questionable patent infringement, and the economics of the software biz led to many fine platforms (OS/2, Mac System 7+) getting second-class citizen status.
Today, the equivalent is Apple squashing certain web standards by ignoring them, Amazon squashing competition by building a competing version on AWS, large employers only wanting Java or .NET experience, while Oracle successfully sues Google over Java copyrights, etc. These are all manifestations of the authoritarian tech paradigms and the herd mentality which enables them, both of which many people really dislike. It unfortunately devolves into identity politics quickly ("I can't believe you use that platform" / "I can't believe you program in that language") instead of objectively looking at the good/bad sides of the dominant player.
On the other hand, riding the bandwagon side can reap many benefits.
These days with mobile and cloud dominance it seems there is enough of a customer base for a few solid ecosystems rather than a single one.
Who else should it be directed at ? the janitor ? If you have a problem with something, direct it toward its creator.
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.
We use GIT, BDD, TDD NServiceBus. Distributed load balanced services, that you can deploy independently. Micro services would be the buzzword for it. CQRS, ServiceStack, MVC, CI, Peer Code reviews
We've never had any downtime, our code is clean, we support tons of users and don't really need lots of servers to support it.
Not everybody is the same.
So only .NET devs are bad? Got it.
Should a new dev learn C++? I'd say they'd be better off with Go or Rust depending on what they're trying to do. Do we really want to be stuck with old, terrible languages forever? Imagine if we had to do web dev in Pascal.
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.
Now, I work on an open source stack, and Rails is suited to only one project out of the multiple web services and applications I deal with. Rails does it's job well, but it isn't suited for everything.
What else do you use, and, if you don't mind elaborating, why did you pick those instead of Rails? My understanding is the more technologies you introduce, the more complex your infrastructure gets, so you're better off picking one web stack, one back-end, etc.
For the micro-services, Sinatra does the job very well, there is no need for all of the components that Rails provides; we like the flexibility.
Our front end developers have complete ownership of the two front-end apps, and they rolled with NodeJS because it allowed them to take advantage of their JavaScript skills.
The Rails app is an internal consumption app. It doesn't need to be fancy or have a need to scale. Rails and Bootstrap keep it simple stupid.
The meat of our stack is actually on the big data technologies we deal with, RedShift and Hive. We could honestly re-write any of the micro-services in .NET or any other stack for that matter, and still keep our infrastructure mostly the same.
Except speed, a really nice IDE and good Windows support.
> The Ruby ecosystem is so perfectly suited to web development that one hardly needs to go elsewhere to get what one needs... > I think the main problem is that .NET tries to be all things to all devs...
So Ruby is all things to web devs, but it's a bad thing that .NET has the same goal for Windows-centric devs? That doesn't make any sense.
> C#...it's pretty damn far from being spectacular.
OK, why? Your response is full of opinion but you don't really back it up with any reasoning - so why should any value your words?
Web dev doesn't need any of these things. If you need them, then what you are doing isn't web dev, it's something else.
> it's a bad thing that .NET has the same goal for Windows-centric devs?
What is "Windows-centric" development? That doesn't even make sense. Web dev is a fairly specific domain with a standards-based protocol stack that's been iterated reliably on for 30 some-odd years. The sources of variability, the browsers themselves, are well-documented now and even when the variations weren't, you could earn a pretty good living specializing in them.
Microsoft seems to throw their devs under the bus with every new release.
Dynamic typing adds an entire layer of depth to the things you can do with tooling, over and on top of what you can do with reflection. If I don't know what's going on in a web app, I can load it up in a developer console, get right to where it's going wrong, and start inspecting everything I can see, even looking up the source code of the methods, whether in my app or in the framework, right in the REPL.
You mention LINQ, that makes C# dev bearable by cutting down on the syntax you need to do basic functional programming. I wouldn't call it "enormously productive".
And LINQ isn't an isolated example. There's an asynchronous solution for asynchronous programming built in the language (async/await since C# 5.0).
There's reactive programming - RxJava is most popular these days, and most major languages have their RX thing now, but it was in the .NET world where Reactive Extensions saw the daylight for the first time.
Or MVVM (10 years later, Google began introducing it to Android, though it's not production-ready yet).
Well it doesn't help that there's no such thing as a "ruby technology stack" let alone one under a single all-encompassing directorship. Even Rails isn't a single stack, it's just one piece of the system with plenty of bits around which don't fall under rails (OS, application server, datastore, caches, client-side anything without considering the development tools themselves), and rails is only one of the tools for its levels (not to mention the current rails is the result of community mergers).
While it's great, in theory, to have broad skills in many different languages and technologies, it is difficult to be an expert in any of of them without working with them for a significant amount of time.
When I start a new project I'm looking to leverage my expertise in my areas of focus rather than trying to find the perfect technology fit. Without significant knowledge in all options, I may not even be qualified to provide a reasonable evaluation.
1. A whole team must use a given stack, so it's more akin to trying to get your whole band to switch to amplified so you don't drown them out with your electric guitar.
2. For continuously supported and developed projects, you're in it for the long haul, and rewrites can become a daunting enough task to actually kill a company, so that first choice of software stack for a little project can start to look pretty significant. Who knows which quick and dirty little web app will end up bloating to a million lines of code and running a company for the next twenty years? I guess the music metaphor for this part is forming a punk band and realizing years later you wanted to play Bach, and trying to get your guitarist to switch to violin, etc.
Edit: my fun C# anecdote of the morning is I just got to deal with how new TFS branches can end up quietly running your Main branch code due to cruft in your Windows user folder. Thanks, Microsoft! http://stackoverflow.com/questions/15818364/vs-2012-launchin...
> 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' :)
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.
I do wonder though if teams with a choice pick C# or is the use of C# dictated just because the enterprise is bought into the MS ecosystem?
I bet most probably leave C# just because they leave the company that is bought in, not because they no longer like it. You code where the money is.
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.
CoreCRL alerady runs on Linux -- it's all very much beta though.
“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.
No one cares about a Windows port of a cross-platform server because most will just deploy to a Linux or BSD server instance anyway...
People only really care about Windows GUI apps...
“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.
“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... Also it’s less important how they distributed or linked, it’s more important what they are — and AFAIK there’s no *nix equivalent.
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.
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.
Well, a major one that comes to mind (and may change as things progress) is application portability. The open CLR project hasn't gotten far enough yet to truly be cross-platform capable.
It's also smaller in weight and baggage, some argue faster to prototype/develop-in, community driven (no decade of a single company's inner departments fighting over features and behaviors), it wasn't born out of NIH syndrome, etc...
In a lot of ways, it is a lot more attractive than C# will ever be.
Ease of prototyping is a general advantage of scripting, dynamically typed languages, so this is apples and oranges really. Or like insisting that Yamaha is superior to Mercedes, of all car manufacturers, because motorbike is more useful in heavy traffic :)
Statically typed languages bring other advantages to the table, they shine is bigger projects.
As for NIH syndrome, once again this is "ancestral sin" at best, not a downside of the language as such.
Still, it wasn't exactly that way. Microsoft didn't try to tout a brand new language at first, they attempted to improve on Java with J++, but they got sued by Sun and this pushed MS to announce C#.
This being said, C# wasn't a corporate rebranding, it's offered substantial improvements over Java, and to this day Java is either playing catch-up (eg. Streams vs. LINQ, abysmal DateTime API only replaced with something more reasonable in java 8), or just remains inferior (type erasure vs. reified generics, checked exceptions etc.)
I don't really code in Python, but at first glance it is missing some goodness you can get in C#, for instance the support for functional programming (or elements thereof) - I'm thinking about lambda support limited to single expressions.
Python indeed supports some functional paradigms:
- functions are first-class citizens
- list and dict comprehensions, generators
- map, filter, reduce, etc. for data pipelining (though these specific idioms are/were contentious [1])
- lambda for anonymous functions, though it indeed has limitations compared to other languages
- other useful functionality in stdlib such as the functools, itertools, and operators modules
- some built in immutable data types, such as str (strings), bytes (byte-strings), tuples, frozensets
You can read more here: https://docs.python.org/3/howto/functional.html
While not the JVM, using a virtual processor setup as a target for portability was a really old concept by the time Java or the .NET CLR came along.
Newer approaches add new concepts or take advantage of new technologies, but it's never revolutionary.
I don't agree. In my view, Lisp is spectacular for its unified meta-programming capabilities, and C# is spectacular for its expressiveness (and rapid improvements, which really has more to do with the C# team than the language per se, I suppose). The rest are what they are, better than others at some things, but not spectacular.
It's pretty impressive, despite not being widely known.
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.
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?
WTF? This is inane.
.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.
Disrupter is a completely different way of working compared to the standard java way.
If you use standard Java style and compare that .net style then it would be the same.
Namely, hat .NET developers don't really solve any hard problems
NServiceBus, MassTransit. Akka.net, Orleans, etc
But I am almost tempted to add github users to that list too. Recently I see a lot of young guys who seem to have forgotten that you can write algorithms yourself and instead they will spend hours and days looking for something on github.
And that's why I left the .NET Framework because it kept reasserting itself and wanting to be more than it was: an implementation detail.
* 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
.NET core hasn't seen an official release and there's still quite a bit of work to be done. Even with that, the overwhelming majority of .NET libraries don't work on OS X or Linux and it's going to take a significant amount of time to port just a small fraction of them.
.NET core might turn out to be a great cross platform solution but it's nowhere near that right now.
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".
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.
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.
> 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.
"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.
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.