Best case scenario, is he has been using the wrong tools to solve the problems he works on. But can't admin his own fault.
If anything, what I'm working on now would be downright impossibly complex and infuriating if written in Python (his example of a language and ecosystem).
To me VS.NET is incredible. The .NET framework is incredible. And documentation and information is readily available. But more importantly, the problems I'm solving can't be more easily solved using another stack.
And every time I blame one of the above, a few days later I realize that the real issue was just a stupid mistake I was making myself...
As an example, just the other day I was using a BackgroundWorker (new thread) to do some work outside the UI thread. I needed to do 3 or 4 tasks and decided to re-use the BackgroundWorker for each task (instead of using a new one each time).
Of course problems started showing up. For a while, I was convinced that VS.NET was debugging on the wrong thread, and that there was an issue with re-using BackgroundWorkers in NET. I mean I'm a good programmer, it can't be possibly my fault!
Basically, I forgot to unsubscribe to the BackgroundWorker events. Which caused the previous DoWork attached anonymous functions to run multiple times.
.NET is the way Windows applications are built. VS.NET has no rival on this platform. And this stack is not any weaker because people such as the author leave us. Referencing a few negative blog posts does not prove .NET is dying and that "developers are leaving for greener pastures", which by ALL METRICS is completely not true. If the author wants to think that Python and whatever other choice of IDE will now solve his pain... Then let him eat his cake.
C# is an incredible language and VS w/ R# is a pleasure to work with. I have been working in this stack for over 6 years, so it is fair to say I have enough experience to know what I am talking about with regards to being a .NET developer.
That said, .NET, as a development platform, is a couple of diamonds covered by tons of shit and surrounded by people trying to convince everyone else their shovel has all the goodies. Microsoft's shovel comes up empty more often than not and each year sees fewer people sifting through it all to help guide those without the time or taste for it. The biggest killer of .NET is that the majority of the community seems content to keep taking spoonfuls from the MS shovel lying to themselves about it's content.
What I see is a random blogger makes generalized statements based on lack of experience.
> so it is fair to say I have enough experience to know what I am talking about with regards to being a .NET developer.
Your experience counts, just not mine! And you also know what you're talking about!
> That said, .NET, as a development platform, is a couple of diamonds covered by tons of shit and surrounded by people trying to convince everyone else their shovel has all the goodies.
You seem to have a lot of anger.
Thanks for trying .NET.
Have a nice day.
P.S., more than likely the blog author used VS.NET in a "visual" capacity (drag-and-drop component building).
Thanks for almost RTFA
Have a nice day yourself ;-)
Can you expand on that a little - what are the particular characteristics of the project that make it better suited for Windows than for a web stack of some sort?
If he says that Ruby fits him better I can just conclude that he trades the execution speed for ease of the development, which can be a reasonable trade-off. I'd still like to hear him talking in a year if he actually worked on really comparable problems in .NET and in Ruby.
In reality, I very rarely have performance problems. I have heard Ruby got much faster with the 1.9 release.
Still it's approx. 20-times (see the link before, it is for Ruby 1.9) trade-off between development convenience and the hardware involved.
Server performance is only very rarely tied to CPU performance. There are a whole lot of factors other than that that impact performance.
The previous post does not say this. He is saying that for the particular problems he is facing (likely very Windows-centric), he doesn't think any other stack would be "better". Other stacks could still be equal (but if he knows .NET, there isn't any gain for undergoing the learning curve) and they might work better for other problems.
Its a sweeping statement to say the least.
I know the VS IDE and such often prevent you doing dumb things/shooting yourself in the foot and its great!
But are you saying that in the entire development universe there is no solution adequate to any serious problem that didn't come from the MS stack? You'll have never done anything like massively parallel computing or big/complex data sets then. Or AI development.
Air Traffic Control system in .Net, for example? Nah.
.Net is a just a general-purpose tool for writing certain kinds of software. That's all. And it is telling that none of Microsoft's core products (the ones that earn lots of cash) are even remotely going to ever be converted to .Net or managed code.
No. It's an exact statement based on the particular problem I'm solving.
> I know the VS IDE and such often prevent you doing dumb things/shooting yourself in the foot and its great!
I have no idea what you're talking about unless you think that VS.NET is "visual drag-and-drop programming". I've never used it as such.
> .Net is a just a general-purpose tool for writing certain kinds of software. That's all.
.NET is a higher abstraction of the win32 api with many many additional features. And that's an understatement.
And that "kinds of software" is more or less the entire Windows desktop market.
In the last couple of years C# has gotten better than ever. LINQ, Lambdas & Generics combined with the IDE's autocomplete and refactorings have made the language really nice for power devs.
The next release will include a Compiler as a Service which could be a game changer if it's embraced by the community and if it's not borked by Microsoft.
A good rule of thumb for .Net is that anything from Microsoft which is built around a tool should be avoided like the plague. For example Entity Framework and WPF are horrible tool-bound monsters. They don't play well with version control, don't play well with clean coding (POCOs) and almost feel designed to sell other tools (SQL Server / Expression Blend).
Entity Framework is especially bad. It combines terrible performance, terrible scaling (it has terrible support for large schemas) and until recently didn't even support "code first" development.
Thankfully, like other dinosaurs that kind of thing is going the way of VB6.
To add a bit of context: I have a pretty broad background - been coding for 21 years (started at 10) and have experience implementing something significant in: C64 (BASIC/6510asm), Pascal/Delphi, VB, Java, PHP/HTML/JS, TSQL/SQL, C# and ActionScript/Flex. I've dabbled with Ruby and the beautiful Python.
I abandoned dynamically typed languages for serious projects (those expected to work for > 5 years) because of the poor refactoring support and the dominance of style over substance in the community. I work in the Enterprise, and there software maintenance quickly dominates the cost of projects making the big two static languages a better choice.
I still, of course, turn to dynamic language when they're the best solution to the problem. For example for situations where speed of development dominates returns (think opportunity cost) or where a language is deeply embedded in a specific community (Python and NLP).
After a while, I was sick of debugging memory and having to rely on "libraries" just to do anything useful with strings, and it was such a relief to discover Perl. Talk about power! I was suddenly creating little utility programs for everything. It occurred to me that I could have been writing these utilities in C all along but I never did because the time to write and debug them was more than the time they would have saved. What a joy to discover Perl (which then led into learning the Unix command line and its utilities.)
But after a while, I noticed how often I still had to look up the "clever" syntax of Perl. There were so many other ways to do things that I couldn't read other people's Perl without a reference book beside me and, heaven help me, sometimes I couldn't even read my own. That had never happened in C, But I wanted to create commercial GUI apps. Perl's answer? Use Tk? Yeah, right.
So, I switched to C++ for GUI apps, and what a treat to have that kind of power compared to Perl. But then I rediscovered memory debugging, what it's like to not have a string datatype, and I learned that the usefulness of OOP was offset by all the ridiculous little gotchas that meant you always had irreproducible bugs that you hadn't yet discovered.
What a relief when Java came out. Almost all the power of C++, plus built-in strings, arrays, even Unicode, but without most of the hidden gotchas. I could concentrate on the demands of the problem instead of the demands of C++. Like lots of programmers, I found Java much more fun than C++.
But of course there were things I missed--structs, enums, regular expressions, GUI apps that looked native--and every time I complained to Sun reps in a meeting, they would simply explain to me that they knew more about programming languages than I did, and they knew that I didn't really need these things. They held that position ("No, trust us, you don't really want that") for years.
But the Microsoft reps were always EXTREMELY interested in anything we wanted from Java but that Sun wouldn't give us. "What do you wish Java had and how would you use it?" They took lots of notes. Superb marketing.
When C# was released, it was with great relief that I finally got the language, native GUI app builder, and other things I'd been longing for in Java for so long.
Building GUI apps with C# is still a joy, but I'm always frustrated at being limited to Windows. I use Macs and Linux boxes, too, and Mono has never quite been what I had hoped for. I need to do a lot of web programming, cross-platform number crunching, and all sorts of things. And having to (repeatedly) buy all of those Microsoft tools and be a "registered developer" and all that nonsense, phooey!
Thank goodness, I found Python. Free, available on every platform, great built-ins AND great libraries.... Like Perl, but with a syntax I remember without looking things up. I can read other people's code without a reference.
But I wish it had the flexibility and macros of Lisp, the power I've found in functional programming, the easy GUI creator of C#, the speed of C... and a pony.
I understand the OP's feeling of relief at leaving annoyances behind. Believe me, I do. Every system I've used has had problems I'm glad to rid of and features I still miss. But that's what you get when you change a relationship, move to a new house, sell your car, get a new job. And, with programming languages, you can go back when you need to.
It's often good to move on, but it doesn't mean what you left behind was bad. Sometimes you just need different problems.
Unfortunately associating dynamic languages like ruby, python and javascipt with some narrative of hacker agility and contrasting against a clumsy slow-moving 'enterprise' culture is confounding the issues. This is not to say that there aren't plenty of vendors/consultants selling FUD and over-hyped and over-complicated 'solutions' in 'enterprise' but it's a non-technical issue.
Next, remember not having to upcast and downcast objects considerably simplifies the code, simplifying the tests you need to write. Less code means less places a bug can hide.
And, finally, understand that, while not passing compilation proves your program is wrong, passing it doesn't make it any closer to correct.
Trust me. I've seen enough "enterprise" codebases in my life. They aren't that special.
Assumption #1: 100k+ loc codebase in X == 10k+ loc in Y (somehow... magic)
Assumption #2: Assumption #1 is the primary reason not many huge codebases in Y
Assumption #3: Static type implies upcast/downcast objects (despite the presence of generics...) == simplifies code == simplifies tests.
Fact: Less code == less places a bug can hide
Fact: BTW! we all are using tried-and-tested libraries to cut down code to be written
Fact: FindBugs (or static code analysis) does actually find bugs to eliminate most technical bugs and leave you with business logic (and quite possibly race condition bugs).
Argument: Compiler isn't special, see, I just show you it doesn't proved your code to be correct, there's the logic bug in your Business Logic. (Except that happens as well in dynamic language, AND on top of that you gotta work a little bit extra since you ain't got no compiler).
I think this has become your typical nerd holy war between static vs dynamic with no end.
Here's my biggest problem with Ruby or Python community: your libraries tend to have short-lived (i.e.: orphaned).
When I looked at Java community, they're quite stable and rock solid since 2004-2005 (Apache Commons, Maven, Ant, FindBugs, Eclipse, EclEmma, Spring Framework family, JUnit, Hibernate). Newer libraries tend to have good internal codebases (GWT, Google Guava, Mockito). Most APIs are stable and solid.
The stupid ones tend to get kicked out of the crowd (i.e.: Struts, JSF)
This is what I'm looking for. I can focus on writing code that matters, instead of refactoring my code once every 4 months because things changed and I have to keep up.
Have you ever worked with any significantly complex (as in "does a lot of stuff") in Ruby, Python or Smalltalk? Do you sincerely think you could express that same level of functionality with C, C++, C# or Java?
> Assumption #3: Static type implies upcast/downcast objects (despite the presence of generics...) == simplifies code == simplifies tests.
Generics are nice until you have to implement something that accepts them. I gave up once.
> Fact: BTW! we all are using tried-and-tested libraries to cut down code to be written
And language features that do just that (see Assumption #1)
> ... static code analysis) does actually find bugs
Actually, they are one step above syntax errors.
> Except that happens as well in dynamic language
No. Not really. Of course, I may pass a list to something that expects a file but, provided I embraced the idea of duck typing, that would probably work just fine. And yield correct results.
And avoid implementing a similar function that receives a string instead of a file.
> AND on top of that you gotta work a little bit extra since you ain't got no compiler
Most errors a compiler catches are traditionally caught in tests with dynamic languages. But having compilers doesn't allow one to skip writing proper tests with statically typed languages. In fact, considering you'll have to deal with more situations, you'll have to write more tests to go with your less concise code.
> I think this has become your typical nerd holy war between static vs dynamic with no end.
I think statically typed languages have their place. I have written tons of C and Java (and a bit of C#). I just admit my ST code was not significantly better than my DT code and was considerably more complicated, with more functions, classes, interfaces, configurations, indirections, and much more verbose. The 10x loc difference is very real. In the end they were all, ST and DT, correct.
> Here's my biggest problem with Ruby or Python community: your libraries tend to have short-lived (i.e.: orphaned).
I'm nos as familiar with Ruby (the language mentioned in the article) but I can tell you Rails (the framework mentioned) is very solid and very well maintained. Compatibility can be broken from time to time, mostly for good reasons. And you don't need to rush to update your code - you can be perfectly happy using older libraries. I can tell you, however, Python libraries are remarkably stable. The impending move to Python 3 is the only significant example of code breakage, but, again, it's for great reasons.
> they're quite stable and rock solid since 2004-2005 (Apache Commons, Maven, Ant, FindBugs, Eclipse, EclEmma, Spring Framework family, JUnit, Hibernate).
A couple of them gained significant functionality in the past couple years. If you want to use the new functionality, you'll have to refactor your code, often extensively.
> I can focus on writing code that matters,
Ditto here. I just write less code (in less time) for the same amount of "matters"
> instead of refactoring my code once every 4 months because things changed and I have to keep up.
With the extra time you get by writing less code in less time, you certainly have the time to refactor. With good tests, you have the certainty the refactoring was successful. Besides, nothing is compelling you to switch to incompatible versions every 4 months (I don't even think that's possible unless you are doing so deliberately). What is the problem here?
I use Rails for CRUD app and I use Spring MVC too.
I used Python a lot a few years ago from writing tools (testing, scripting, automation), to small web-apps.
Saying that 100k can be cut to 10k (or 1k) is like pulling number out of thin air, that's what I find... "magical". It's like some CEO of a startup giving a deadline to the developer to write Hadoop in 4 hours; pulling the number out of thin air.
Compiler => helped syntax errors and types (95%, 5% consist of reflection hackery that might bite).
Static code analysis => One level up from syntax errors, focused on common pitfalls and bug patterns
One step, two step, three step, doesn't matter, it helps, that's the bottom line.
What I refer to "except that happens as well in dynamic language" is to the business logics, the app logics, not syntax and whatnot, you _got it wrong_. We all got business logics bugs that can't be caught by anything other than testing the app themselves (QA, automation, whatever).
So we agree that dynamic languages requires you to write more testing code because there's no compiler? Gotcha.
I never say anywhere that using a static language requires NO testing.
What I found is that a bunch of old-timers who wrote Java back in 98-2003 and didn't use more modern Java frameworks and tools but already jumped the band-wagon to Rails or Node.js keep singing the same tune.
When I use Rails, then Spring MVC + Spring Data, I noticed that the amount of business logics that I have to write is more or less the same. 10x is again out of thin-air. I admit writing code in Java requires more typing albeit Eclipse helps a lot (and please don't bring the old argument of "But You need an IDE!", who cares what I need as long as it helps me to do my job).
Picking one example to refute the epidemic that occurs in the ecosystem is probably not a strong argument (Rails is well maintained, I give you that, although it takes Rails up to version 3.x to realize that they need to cool down and stabilize but I give you that, but that doesn't mean the other plugins and libraries are held the same level of quality and commitment with Rails).
No, we don't. I never said that. Since there is less code structured in simpler ways, there can be less tests (there are less code paths). Since the tests themselves are written more concisely, the tests themselves are smaller. The syntax errors will be caught in the tests because most dynamic languages actually compile the code. They just do it as needed.
Again, the 10x number is not out of thin air - we keep a lot of Java applications here and, more than once, we rewrote them in dynamic languages. We saw better than 10x ratios, although with the more recent, nicer Java code is more like 5x.
> Picking one example to refute the epidemic that occurs in the ecosystem is probably not a strong argument
I am not very familiar with the Rails ecosystem, but if most of the libraries someone picks tend to be abandoned, maybe the problem isn't in the libraries, but in the selection process.
Wouldn't it just be nice if you could get away with just the code you wrote?
Static typing is not a pre requisite for quality code. Quality developers is. If you have your codebase maintained properly, maintenance is easy and cheap.
(Hint: don't argue with me at this point, it's just random geeks meaningless debate. Really. I mean it. Y'all don't have a good proof that dynamic typing implies better developers or static typing implies bad developers and I'm a bit tired to hear "Good developers, not tools" that kind of crap when most Python/Ruby developers are just as average as Java developers).
I never said (nor implied) that. I said dynamic typing leads to more concise and readable code. Most of the time, you'll be reading the code, so, it makes sense to optimize for readability.
> most Python/Ruby developers are just as average as Java developers
Wouldn't it then make sense to give them better tools? I don't use Python because I'm better than my colleagues who prefer Java - I use it because I want to get the job done and keep it done with less effort.
I used to buy the whole dynamic language argument (heck I even lead local Python user group) but not any more these days.
To me, Ruby is less readable than Python. To me, when reading a large code base, Java is more readable than Python. To me LISP is weird (even though I kind of like it).
Now you said "it makes sense to optimize for readability" the problem with this statement is that less code != readable code (and I don't mean to jam everything in one line a'la Perl). I find that I need to read, re-read, think, and re-think a few times just to understand what the Ruby crowds refer to short, concise, and elegant code.
Whereas in Java, albeit more terse, I can just read within seconds to know the intention of the code.
So it all depends. Hence me not buying the dynamic vs static debate.
Never said that. When writing code I never go for the least possible number of symbols (if I did, I'd write traditional APL). Still, more concise code is often closer to what you want done than the details of how you'll get it done. While I find Ruby's syntax a bit confusing at times (and that's why I prefer Python) I cannot deny idiomatic Ruby is very close to intention than to implementation (to a fault).
Within large companies those types of codebases are normal. The upfront development cost of applications is significantly less than the long term maintenance cost - especially once you've factored in the cost of hardware over the time period, and having to keep institutional knowledge of the applications amongst development teams, sys admin teams and network teams.
That's why I am saying that most of these claims people bandy around about enterprise computing are nonsense.
All I can say is that YMMV since this debate typically goes to no end.
If we have a super-hacker on our team that can fix any problems ranging from C to Assembly to Linux Kernel to everything under the sun, we'd take the risk of using cutting-edge technology such as Node.JS to do SOAP/WS-*. Otherwise, it's all Java/.NET plus outsourcing the risk to Microsoft/IBM/Oracle support when shit hits the fan.
Certain things don't apply to internet companies by the way. They can write a SOAP library, put it on Github and blog about it how much they save the money but Enterprise project has deadlines and impatient customers.
When appropriate : language/framework choice depends on more than just technical factors...
Things like the Microsoft "professional engineer" who advises you at your invitation, and then sends e-mails behind your back to executives to inform them of his concern about the "business risks" of non-Microsoft technology choices.
That's really weird. Who finances these commissars? I mean, I've seen this sort of thing take place, but only when a two-letter consultancy was gunning to take over some director's entire department. What's in it for the commissar?
Often such folks have little in the way of open source contributions, commercial products, or shipped code that they can point to. But they've probably spoken at a number of events promoting "The Microsoft Way" and have likely been awarded a Microsoft MVP award as a result of those efforts.
In general, they get by simply by advocating the Microsoft toolchain, and moving on from consulting engagement to engagement just before they're exposed. Or they focus their consulting services on large corporate IT where even their meddling makes little difference in the grand slow scheme of things.
This is how you get referrals. Like it or not, it's business.
That phenomenon transcends the typical consulting firm loyalty and is more of a culture around Microsoft products.
Sometimes it's just hard to 'switch over' like the author as done. I've done plenty with Java and PHP too but there's nothing there that excites me really. So now I'm dabbling with Python to see if there are any sparks there. Have I made a good choice? I guess we'll see.
I do find it interesting that you don't seem to hear people say things like "I'm done with Ruby, switching to Python". People make a bigger deal of leaving .Net and Java as if it's something you'll never go back to.
F# is a mighty fine language but introducing that into an established shop just isn't going to happen. It's personally my favorite language but there is a very steep learning curve coming from C#. For my projects I use Windows & Linux, C#, Python, JS (client), and F# all over the place. I keep the programs small with a service orientation so it's easy to switch languages.
My take is the problems usually aren't framework/tech related. It's about people and process. Diving into a new framework really isn't about the tech, it's about learning the tech, and thereby giving your brain some much needed stimulation.
No, it's usually more along the lines of, "Ruby is beautiful (but I’m moving to Python)" (http://news.ycombinator.com/item?id=3179370 :)
If your career were a blog post, languages are more like a tag than a title.
Contrast "I Solve Problems" with "I Only Solve Problems with PHP."
After all, if I'm making a web site there really isn't a choice to make between Python, C#, Ruby, etc.- they're all going to do the job with almost identical ability. Doing it in a different language for the hell of it is definitely a fun learning experience, but if I have a client on the other side I'd rather get it done quickly.
The OP is basically saying "I'm super comfortable & productive with the MS stack. It's been fun and good. Now I get to focus on something else. The change will be good for me."
Nothing wrong with that.
The problem with your assertion is it assumes that all languages, tools, frameworks and environments are equal to the task.
I am a really good problem solver (at least in my opinion) I just don't want to make the implementation of those solutions harder on myself than it has to be.
I do think it's important to hire on talent, but I think the other extreme of a super generic "computer-based problem solver" is very unrealistic. Not every company can afford the delay of bootstrapping someone into having expertise with the technologies the company uses.
tl;dr; good for you man.
That said, whenever using something other than C# I miss LINQ. It's awesome.
On a similar note. I've followed your Playtomic blog a bit and it helped me make the jump to MongoDB for our gamification platform. (We still use SqlServer for lots of things though) Here's to trying new types of kool-aid! :)
Unfortunately there's no reSharper for JS but eh... I feel like it's not as necessary with JS as its a fundamentally simpler language than C#.
None of which is to say other languages might not be better. But being better has never been enough, on its own. If it were, C++ might never have gotten a start. Language popularity depends a lot on history. But boredom/dissatisfaction with a dominant language can help give a new language a chance.
I knew C# well at the time, maybe not the best out of the languages I know, but well enough to hit the ground running. And I knew with MVC3, I would be running in no time. Visual Studio is an awesome environment IF you have a fast PC. I have a fast PC. LINQ, and LINQ to SQL, is incredibly powerful. I can drastically alter my SQL DB, and have my ORM code auto-generated immediately.
Out of the box, .Net takes care of a lot of the detail. I can optimise this detail later if I need to (I hope).
With the aim of this code being maintainable, and having hated maintaining a large python code-base before, I wanted to use a statically typed language.
Importantly, I knew .Net was going to be scalable when I needed it be (stackoverflow.com as an example).
How is it going?
Very well. But I've not launched yet. I have no regrets, and think C# is an amazing language to work with.
I would generally consider myself language agnostic, so whilst the decision was hard, I was confident it wouldn't matter too much in the end. Hopefully that will remain the case, but you never know what's around the corner...!
Perfect summary and exactly how I feel about .NET.
However, according to the TIOBE Index , C# was actually second in growth in 2011, just behind Objective C. Not sure how reliable that is, but thought it was an interesting (and unexpected) trend.
In reality, .NET is actually a very interesting platform. LINQ is actually really cool and C# is largely a better language than Java. If this isn't enough, you can always use F# which is a very nice functional, statically typed language based on OCaml. On top of this, MSR produces interesting research in programming languages, which can easily be subsumed by their product languages. There is actually a healthy exchange of ideas between Haskell and the .NET languages, for example, even going both ways. (Haskell recently got some features from LINQ, for example.)
Here is a random video I found earlier where SPJ talks both about this in particular and the exchange of ideas between Haskell and .NET in general: http://www.youtube.com/watch?v=iSmkqocn0oQ
As the OP notes, It seems as though the whole philosophy of .NET centres on catering to the novice, but even as the novice evolves into the “advanced beginner” they inevitably find they want and need more.
Your typical novice developer is going to have a hell of a time trying to understand any non-trivial C# projects these days with all the function features that have been added - especially with things like PLINQ and TPL.
The utility for experienced developers has increased over the years, it's accessibly to inexperienced developers has, however, decreased.
Is there any indicator(other than a few HN posts) that .NET (or # of seasoned devs in .NET) is actually in decline?
The reason you see blogs like this that some in HN reflexively vote up anything that is anti-.NET or anti-MS.
Around a 50% use Macs and a significant percentage use Ruby, Node et al. Since people tend to vote up things that make them feel good, 'OMG .NET IS TEH SUX' posts tend to get on top.
Well some people have the opposite experience and also have written posts as to why they are moving to .NET.
On this note though, I should probably mention I didn't reference those posts to prove there is a deluge of people leaving .NET (in fact I highly doubt that there is), but for context and to demonstrate just how cliche and unoriginal mine was. ;-).
So, honestly one of the main reasons I got out of .NET was because it seemed like it wasn't as cool as I thought it was anymore.
Another reason, although this is probably a secondary rationalization, is that open source isn't really that big in .NET, and open source seemed important (and cool).
Which isn't to say that there aren't lots of rational reasons to get out of Microsoft development, but I just think that we should acknowledge that people don't usually do things for rational reasons. They mostly do what other people seem to think they should do.
Microsoft even redistributes jquery. The culture (at least in the web side of .net) has really changed in the last few years.
Which brings me to your last sentence. Any software built with .NET will not run over the web? Where are you getting that from? I've been programming .NET for 8 years now, and I've only programmed stuff that runs over the web.
A lot of the "web" stuff is XBAP or whatever which is basically desktop packaged to go in IE.
Sure there is plenty of ASP.NET development going on, and that is over the web.
But come on, you can't say that most .NET software is not closed source. Sure, some of it is being 'opened up', but for the most part, ASP.NET and C# libraries and components are not open source. Especially when you compare the ratios to other platforms.
Which is probably why I said nothing even close to that.
I can only really talk about the web related tech. Huge parts of ASP.NET are open source.
Then you have projects like F# which are open source.
Nuget package manager is open source (formed out of two community open source projects).
The Dynamic Language Runtime is open source.
IronRuby and IronPython are both open source.
MEF is open source.
The Orchard CMS is open source and control has actually been given completely over to the community.
Silverlight controls was open source.
However, you can take a look at the big .NET open source projects, or just the AltDotNet community for the counterpoint.
>Especially when you compare the ratios to other platforms.
That is a meaningless metric
>So, honestly one of the main reasons I got out of .NET was because it seemed like it wasn't as cool as I thought it was anymore.
How in the world can C# not be considered cool? It's statically typed and reflective. It's got generics (reified) and delegates. Those things led directly to anonymous types, anonymous functions (lambdas, if you wish), co & contra variance, and type inference. Those things led to expressions which enabled Linq. Then you throw in dynamics. The next version will have the compiler as a service and the 'await' keyword which vastly improves multi-core and event drive programming.
Yeah, there are other languages out there that are doing some cool things. I don't see how anyone could think C# isn't cool, though. BTW, while microsoft is still working on their C# 5 compiler, Mono (the open source .net implementation) has already completed theirs and it is available today. They had compiler as a service before microsoft even announced it.
There were plenty of these in heady times of '06 and the Ruby rush. Except with Java.
I'm sure at some point there were some for Cobol and Fortran and C and C++.
That aside, going from Rails to .NET MVC has been a lesson in patience. While I am glad to have skipped Webforms, there is still something about .NET MVC that weighs on new ideas.
It's just easier to get up and running with a Rails stack and get your idea out there.
But that's just me, maybe for you it's Python, or C or Assembly. Whatever it is you work best in that's what you use.
Posts like this can help a community identify weak points though so I'm always glad to see them.
1) Not runnable properly on Linux (I always have trouble with mono - maybe its just me)
2) Compilation and app restart time etc are annoying when wanting to develop rapidly
LINQ and the syntax of the language, VS etc are all awsome though.
Overall, you can do a lot worse.
1) Consulting/Contracting gigs
2) Mono for cross-platform GUI development
If you're actually using drag-and-drop you probably already lost.
Worse yet, sometimes you get the feeling that building expertise in all these tools is limiting because it has little commonality outside the windows bubble. Working on improving IIS performance won't help you much in a wider world were apache and nginx expertise is more useful, for example.
I find it monstrously overblown and while its proponents/fans call it elegant I think its a horrible inelegant mess. Great if all you do is Windows, no doubt.
Plus I don't trust Microsoft on Mono (which at one time I thought was a neat idea) and I don't trust them not to dump their existing .Net devs like they did with VB6 sometime down the line and without warning as soon as they and their marketing department decide the next shiny-shiny programming paradigm has arrived. There are plenty of rumours about this and I frankly don't discount any of them as being too far-fetched.
The FUD on this issue has been tirelessly debunked. Microsoft would have to contravene its own covenants and agreements in order to do this.
There are reasons to dislike Mono. This is not a legitimate one.