I had to check when this was written. Sadly, it's this year.
He says that .Net coders don't answer each other's questions. What's stackoverflow then?
He says that the .Net ecosystem is not as rich, and mentions nUnit, but not the other major open-source testing frameworks - xUnit and mbUnit. Then there's also MS testing, or if you like BDD, there's NSpec and SpecFlow.
I've seen seven or eight open-source .Net IoC containers (including one from Microsoft). By far the weakest of the major ones was Spring.Net, the straight-up port of the popular Java tool. If you don't like EF (Microsoft's ORM), there's NHibernate. Subsonic and others. If you don't like Webforms or asp.Net MVC, theres Fubu and OpenRasta.
Unfortunately a Resharper licence is the price of entry into a lot of IDE goodness. He has that right anyway.
The .Net shop that I work in doesn't choose tools to use in our .Net development efforts based on cost or licence. We choose what makes sense. There is really are few or none "only paid, proprietary software" development shops left. It's all mixed.
I find it quite telling. Every company I know of that blocks unauthorized websites, IRC channels and so on happens to be .NET (or other flavors of Microsoft) shops.
Last time I contracted for a hardware maker, I had to have two separate computers: one box where I had manager role, where I could compile and debug code (with Visual Studio), that sat on a network that had unrestricted access to the net, and another that could access the corporate Exchange server and the internal network. By default, all webites were locked out, but you could request access to what you needed, one site at a time, and the security folks would see what thy could do. It took me a month of signatures to get my second computer, the one with full Internet access.
And as far as getting into the framework you can disassemble down to the IL if you like which is also well documented. For most people Reflector is good enough.
Voted up because I'd like to see more people give .NET the college try. If you can put aside your biases about MSFT and start playing with the frameworks, you'll be impressed.
It's not without its faults, but a lot of the negativity expressed towards it is unwarranted.
I think in college you should broaden your mind instead of going after what you may have to learn anyway. In college, you have the luxury of time to experiment, something you rarely have later.
Try Haskell, Lisp, Forth, assembly (on bare metal - write your own kernel), Erlang and anything that's "too weird" for most "enteprisey" developers. Buy an old 8-bit computer at eBay just to get a hang of what is programming within 64K of memory. Make hardware for it. Play with non-relational databases.
Most important advice of all: play. You are not learning a job, you are becoming a craftsman (craftsperson?). If you don't enjoy it, you won't do it well.
You'll have time to learn Java, .NET and even Python and Ruby later.
I don't think you got the parent poster's meaning of "old college try".
Sure, in college, you should work with more academic and esoteric languages. I learned Lisp in college.
The point is, many people dismiss the merits of Microsoft tools and languages. One guy I worked with said, "I haven't used any Microsoft products in years" and that's supposed to make you an expert on them somehow? :)
> and that's supposed to make you an expert on them somehow?
No. But it has a good chance of making their experience broader. Microsoft is nothing but a tiny spec in the software development tools set. Using only Microsoft is not a good sign.
Absolutely, someone who uses only Microsoft technologies and tools is... impaired.
On the other hand, perfectly good things like C# (especially with LINQ and ASP.NET MVC) are being dismissed out-of-hand by otherwise reasonable people just because they came from Redmond.
It could be the best language and framework in the world, but it's not worth the vendor lock-in.
I agree, C# is a better language than Java, but that doesn't mean I'm going to use it. There's more to choosing a language than the language itself. The environment is at least as important.
Even if they do, I (and many others) still wouldn't use it then, because Microsoft has already abused their position in the past. I know I won't contribute to their success.
Microsoft has kept introducing major features in .NET every few years - generics, WCF, WWF, WPF, LINQ, EF, PE, Rx... So most of the millions .NET developers spent most of their learning time on those.
On the other hand since 1.2 the only major and widely used new feature in Java is generics. And the focus in the community has been on patterns like DI, AOP, DDD, TDD ...
IMHO .NET still has one huge advantage - developing UIs for enterprise apps. Very easy to learn drag'n'drop win/web forms + multiple control vendors. Real component oriented programming.
This year by year increase in features - what I refer to as the "TV remote effect" - is of concern. Really they ought to concentrate upon consolidating and removing unnecessary features from the language.
This year by year increase in features - what I refer to as the "better than Java effect" - is not of concern. They're not going to remove features from the language, because that would break existing code for no reason, and that would be insane. The only reason to remove a feature is if it can cause damage. Maybe Scheme should get rid of call-with-current-continuation, but I can't think of any features C# needs to get rid of. Can you?
.Net frameworks are not identical to the JVM. The general principle of the JVM is that it remains binary compatible across all versions (this limitation forced severe constraints onto the implementation of java generics, for example). In contrast there are multiple versions of the .Net runtime (CLR) that are not compatible. MS often makes breaking changes across major versions of the CLR.
AFAIK JVM byte code isn't guaranteed to be backwards compatible. They also introduced new byte codes that didn't exist in earlier versions. In that sense, there also are different versions of the JVM.
did anyone else notice the comments on the bottom where the author had never heard of stackoverflow? I think he wrote this article based on his preconceptions rather than reality.
A lot of what he says is true (developers who use Microsoft products are generally more willing to pay for software). but there are plenty of open source projects and a TON of online references - and there were even before the latest and greatest stack overflow came into existance.
I just started learning .NET and C#. My first impression is that it makes using all the Windows API really easy. So, you can get the time without fiddling with C time structs, and use DLL's without allocating memory.
Here's the main distinction: Whereas Java has underlying it more Java, .NET has underlying it 30 years of carefully-optimised Windows C/C++ code. It's basically a layer turning Java-like code into very fast Windows code.
And it's clear to me that Microsoft spent a lot of money writing this layer over Windows that makes writing Windows programs so easy. People don't give them credit for that.
.NET has underlying it 30 years of carefully-optimised Windows C/C++ code. it makes using all the Windows API really easy.
Do you tell people that "an elephant is like a tree", much?
I think you are talking about WinForms there. There's a lot more to .Net than targeting the "30 years of Windows C/C++ code" that makes up WinForms.
There's WPF on the desktop, and WPF's little brother, silverlight. The's serving web pages via ASP.Net WebForms and MVC variants, And serving data over web services. One could spend several careers using .Net without using as a wrapper for Windows' C Dlls.
I once decompiled a Windows Microsoft DLL imported function, and it clearly had a lot of optimisations such as quitting if the 1st character is 'n', etc.
I believe some places have very tightly optimized code. What I question is the risky assumption that under every .NET class you have carefully optimized code, refined for over 30 years. What did I use 30 years ago? Oh... A 6502. I had an Apple II+.
I also believe the Java stack has some very carefully optimized code too. It certainly has the performance to back up that affirmation. Besides that, it was designed to be easily portable to other OSs and architectures, a feature that's more important, IMHO, than speed under Windows.
Finally, you should only optimize for speed the code your profiler says has big impact on your performance. The rest you should optimize for readability and correctness. There is a lot of very subtle bugs we introduce when trying to optimize stuff and it's much easier to optimize correct code than to fix blazingly fast, heavily optimized buggy code.
I admit I was way off - Windows has only been around since 1985 or so, and in usable form since 1990. And Java does have some very fast code. And I agree about optimisations too. It's easy to go overboard to get more speed.
I was doing hand-optimizing of 6502 on the Apple ][+ back then. Well, a little bit, admittedly. The thing to do seemed to be a mix of BASIC and machine language. CALL-151 for the win!
Unfortunately when he said "30 years of carefully-optimised Windows C/C++ code" what he did not know at the time was that the phrase leaked through a wormhole into an alternate dimension and was then overheard just as the commanders of two massive battle fleets were making a last minute effort at diplomacy to forestall what would otherwise surely be an imminent major galactic war. More unfortunately, the sound of describing the underpinnings of .NET as being "30 years of carefully-optimized Windows C/C++ code" is almost exactly not quite entirely unlike the sound produced in the Ferhfxian language of the insult, "Your mother is very nice. And tasty." and so, unfortunately, a great galactic war broke out, that lasted for thousands and thousands of years, until nothing but two dead lifeless planets were left, and it was all clearly the fault of Microsoft, once again.
When you pay serious money for your development tools, you tend to not give stuff away for free. And this is what Berin's article is all about: culture. The culture of free vs. pay. I did AMX (the automation company, not the credit company) development, and there was pretty much zero open source solutions out there, because the culture was, "We charge for writing code."
The author is speaking to a mix of both which exists in the .NET community. Many of the really good IDE plugins like ReSharper, VisualSVN, and TestDriven.NET all cost $$$.
On the flip-side are a number of robust open source .NET components that are free like NUnit, SubSonic, NHibernate, RestSharp, and others. The most impressive is probably the Mono project, which attempts to port the entire CLR stack to POSIX platforms. IronRuby and IronPython are also impressive.
The stack is too heavy for Mono, which currently lacks a generational garbage collector ... which wouldn't be such a problem if libraries would be designed with Mono in mind (libraries designed for Mono don't have problems).
So yeah, you can run ASP.NET MVC on top of Mono, but it will leak memory, the server requiring periodic restarts.
When people say "you can run ASP.NET on top of Mono" they never have an example of a visible website / web service that does that.
Also, doing asynchronous I/O on top of Mono using the model available in System.Net.Sockets is flawed on Linux, because that paradigm is based on true async sockets available on Windows ... but on Linux it's emulated with ThreadPools.
A good and scalable server for Mono would be one using async paradigms available on Linux (like bindings to libevent or other libraries, like something that calls vmsplice/splice to send/receive data). It would also have to be throughly optimized/profiled such that it relies as much as possible on stack allocations and to be careful about heap-allocation patterns, such that it doesn't leak through memory fragmentation.
Also on speed ... using ASP.NET MVC you can currently handle 500 requests/second for a simple "hello world". This is simply unacceptable ... using Java you can easily reach 3000 r/s, and this by using a regular servlet-compliant synchronous server (by using stuff built on top of NIO, you can reach 15000 r/s). It is unacceptable because ... what's the point in using a compiled language with a smaller community, other than getting raw performance out of it?
Again, this could be solved with libraries designed for Mono. But unfortunately not too many people are interested in Mono as a web development platform.
Every piece of software you keep for yourself (or your company) has cost of maintenance attached. If it's not critical to your business and is not a competitive advantage - and the cost of keeping it is eclipsed by the usefulness of being the only one to have it - you should open it and let the world share the benefit of using and the burden of improving it.
There's nothing wrong with charging for writing code. It's when you charge people to use your code (that they will need to make modifications to to get it to work) that it becomes detrimental to the community.
On the other hand, it's less of an issue if you're charging people for something that works out of the box. That said, in my experience just about nothing works out of the box.
For commercial third party library's in the Java world people tend to charge for support. In the .NET world people charge for the code itself.
The incentives in the Java world are completely wrong. It's best to make your library as complicated as possible, because then you'll get a lot of people buying support. If you charge for the code then you make it as easy to use as possible to avoid support.
Since charging for support is a common "business model" with OSS, you're implying that the incentives are wrong with OSS in general.
Counterpoint: You know and can use the code before you pay anything. If you decide to prefer a certain library over another, this decision is based on real-world experience with that library. This decision might imply that you pay for support later on -- where support sometimes means implementing requested features.
Yes, the market forces to make the library easier to use clash with the forces to make it hard to use. You can't make it super hard to use, because then nobody will choose to use your library. You can't make it too easy either.
Fortunately the way humans are wired makes it relatively easy to get out of this trap: feature lists. Humans love long feature lists. You can add a lot of complexity without scaring people off.
> you're implying that the incentives are wrong with OSS in general
Yes, I am implying that for code that isn't developed for use by the company itself, or by non commercial programmers. This is very unfortunate, but whether you like OSS does not (or should not) change this. I have been thinking about ways of avoiding this, but so far I have not found a model. What I want is a business model where:
1. The programmers do what they love and do best: coding, not support
2. The primary activity (programming) brings money in, not some secondary activity
3. Good libraries should earn more money
4. The code is open source
A dual licensing model like Qt seems like the only way.
I think that the one thing MS can claim to have done better with .NET is the fact that you can usually update the framework and notbreak your app. I have used several java apps that would break because I updated my java runtime. I don't really worry about that with .NET
That is because there are only really three versions of the framework out there: 1.1, 2.0 & 4.0. The compiler has changed (see: var, LINQ) and libraries have been added but the CLR hasn't changed much. Take a look at how C# implements lambdas - it's all compiler magic.
To which I say that is exactly my point. It's well thought out and there are essentially only 3 runtimes to target while still having modern language features. That said- I work in a .NET shop and work with my share of MSFT snobs that don't really see a world outside of .NET. I don't want to pin my career on that- so I try to stay reasonably current on non MSFT technology. Luckily it's mostly free. :)
I was a .NET consultant since Beta 2 shipped (sometime in 2000 iirc). Before that I was doing a lot of hardcore Win32 dev, mostly doing UI related stuff (was doing antialiased, alpha-channeled interfaces back on Win95 in ASM & Pascal). Long story short, I was pretty deeply entrenched in the MSFT development camp.
But once .NET hit, I was already well into a career doing web development at the dotcom factories in NYC (razorfish, RGA, Rare Medium - plus consulting for FCB/FuelNA, McCann, other agencies). .NET quickly became the platform of choice for a variety of reasons, but looking back I think it was mostly because it was easy and you didn't have to be a rocket scientist to get results. MSFT is fantastic at documentation and the supporting ecosphere for .NET folks was pretty impressive. Gone were all the XML config files, the design pattern saturation of Java, and one of the best* IDE's available for lazy, non-challenged developers, aka Visual Studio.
And it was easy money. I was charging upwards of 250/hr consulting for Pfizer doing the most inane shit you could possibly imagine, shit you could do with two eyes closed and tripping on mescaline. But people were amazed at how quickly you got shit done, but not necessarily because you were some kind of rockstar - it was just easy.
But at some point it grew tiresome. ASP.NET is a hulking piece of shit, anyone that tells you otherwise is lying and/or too stupid to realize it. You start realizing that these other .NET developers you know are unchallenged nitwits without any sense of vision, any sense of craft. A bunch of me too dim wits who collect paychecks by copying and pasting their way to completion.
I was asked about 4 or 5 years ago to take on the CTO role at http://massify.com/. I was initially brought in to consult on getting it built. My first spec and budget was insane because I was relying on the MS crutch. I looked at their goals and what it would take to run this on .NET and the two didn't align. So I stepped back and redid the spec/budget based on OSS. The cost savings were astronomical, somewhere in the neighborhood of 900%. The only problem is that the only Un*x-like system I had ever touched were the NeXT stations from college (fo shizzle).
Considering that I'm entirely self taught (I went to Art School) and the way I had taught myself was throwing myself into the fire, I figured I could figure it out and make it work. And I did. I made a few mistakes of course, but as of today - I am not longer at Massify - they are still running with no unexpected downtime for roughly ~$500 a month.
And now that I've lived in the OSS/Unix world for the last 5 years, I will never ever ever go back to Windows or .NET (though I'm the CTO for a shop whose system was written in .NET - we are currently porting it over to OSS stack). It's so much better over on this side of things, I can't even enumerate the ways.
First of all is cost savings. As a CTO, that's your primary gig (usually). When I started Massify, hosting alone was ~6K a month. After a few months of hard work, we got it down to $500 a month by pushing it into the cloud. This includes a self-scaling application that does HD media conversion, CDN hosting and distribution, the whole nine. Not a trivial application by any stretch of the imagination.
Second of all is ease of administration. The learning curve was steep, don't get me wrong, but fuck all if I'll ever go back to Remote Desktop and the bullshit that is Win2K server admin. Life is too short. I have SSHd and PowerShell rocking now for the .NET app we are currently maintaining/porting, but it's such a sorry knock off of the real thing. Gimme bash or zsh or give me death is my new motto.
Third of all is the pace of technology. Nobody is innovating in the .NET space except for MS. Everyone else is a me too, redmond regurgitating drone army. OSS moves much faster. A problem you had a month ago was probably just solved today. And you didn't have to wait for MS to do it and you don't have to pay someone bizarre licensing fees for it.
Finally, the culture is so much better. People share, people contribute, there is a collectivism that is lacking from the .NET world where the old shareware model is the status quo.
I'm not sure how MS comes back to the fore, I think it's too late for them. The world is open now, and the closed model only flies for people without a clue. To become dominant again, they'll have to open up, truly open up. But, I think it's too late. There is better stuff, for free, out there and without an OSS model, they'll never be able to catch up.
5 years ago for .Net was a very long time ago. Back then the only games in town were C++, java or .net. The former was for the hardcore, the other two were written by programmers who had no clue what they were doing. You're just taking a memory of what it used to be like and comparing it to what you know in OSS today.
You're talking before the fairly meteoric rise in the standard of web programming over the past few years. Before blogs. When tables vs divs was an actual argument. When C++ was relevant in anything apart from high performance programming.
You're also talking about .Net 2.0, pre-LINQ, extension methods and MVC.
And reading your post makes it sound more that you have a chip on your shoulder about bad programmers more than anything else:
lazy, non-challenged developers
ASP.NET is a hulking piece of shit, anyone that tells you otherwise is lying and/or too stupid to realize it
other .NET developers you know are unchallenged nitwits without any sense of vision, any sense of craft. A bunch of me too dim wits who collect paychecks by copying and pasting their way to completion
redmond regurgitating drone army
There are lots of jobs in .Net or java. There's sweet fa for a crap programmer in OSS. Once you realise that is the reason you came across so many crap programmers, perhaps you can understand that there's nothing actually wrong with .Net, it was actually a pretty fucking big revolution. On the other hand you will still come across .Net programmers who think datatables are pretty funky, rely heavily on view state and bizarrely believe .Net controls aren't the spawn of the devil.
As for the rest of it, honestly, 'Win2K server admin', um, it's moved on man. Stop beating the straw doll. 'The world is open now', look a little more objectively at the world we actually live in. Did you even notice the iPhone come out a few years back? Or the Kindle? Or all the other closed source proprietary systems that a me too OS movement gleefully copies, badly for the most part. There's plenty of room at the table for both.
Yes MS have turned into a pretty crap company under Ballmer, but their language teams are still pretty damn good.
The reality is you've become a more experienced programmer. And somehow you're magically attributing it to OSS instead of just knowing more than when you were wet behind the ears.
Or all the other closed source proprietary systems that a me too OS movement gleefully copies, badly for the most part.
OSS and proprietary seem on opposite sides of support-systems and customer-facing systems. Proprietary > OSS for users' visual cortex, OSS > proprietary for everything supporting that top layer.
I think part of it is that OSS UI reeks of design-by-committee. Which is something Apple has gotten ridiculously correct. UI needs to be unified and have a flow to it, something which you're more likely to get from a single (highly skilled) person than from a thousand.
> I think part of it is that OSS UI reeks of design-by-committee.
I hate reading this. It shows little experience with with open source programs, and ignorance of how open source programs work.
There are hardly any OSS projects with thousands of people- in fact, the only one I can think of is the Linux kernel. Most GUIs in the open source world are worked on by one or two people. Firefox is a good example. Ben Goodger and (one?) other person did essentially all the UI work.
Now, it's true that there are a lot of open source programs with terrible user interfaces. Some of this is because of the strong connection between *nix and OSS, and the primitive toolkits available 15 years ago. Some of this is because it's written without an end user focus. Sometimes the authors don't care. Some of it just sucks.
It's true that Apple has had a lot of success by paying a lot of attention to UI issues. But they're not only different from the majority of OSS software, they're different from the majority of proprietary software. Have you ever tried to explain to someone how to use Opera, or Internet Explorer? Word? Security products like Symantec? The world is filled with baffling crap, it has nothing to do with the licensing scheme.
In short, I am bothered by your generalization because it I believe it to be untrue, and worse, unexamined.
Worked on by one or two people, but criticized and improved (and suggested, influentially) by many. Committee. The point isn't how many people write code for the UI, the point is how many people influence (or control) the direction of the UI.
Just look at Ubuntu's interface preferences. Committee. Everyone wants an option, so they're all there. Perfect for alienating everyone who doesn't want all the options. I.e., 99% of the world. Look at <OSS program X> and poke around (especially the popular ones - try Open Office). You'll find bajillions of settings which prevent average people from going deeper and improving their experience.
edit: granted, this is changing in a few areas. Rails, for instance, is convention over configuration - and look at how successful it's been. Mobile apps have been revolutionized by Apple's apps, and developers all over are rushing to mimic it. People are starting to learn, but it's a long way to the top, and the vast majority of the improvements seem to be originating from companies, not OSS groups.
The Gnome project has a reputation and a long history of removing preferences that people want. The 'Ubuntu interface preferences' are largely Gnome preferences, and taken on and individual basis, are generally quite reasonable. The only 'mess' I know of is the fact that the preferences are displayed in a giant dropdown menu, instead of in a control applet interface, like OS X, Windows, and SuSe do. Gnome actually has a control applet that should take the place of that dropdown, but Ubuntu chooses not to use it.
OpenOffice.org is a disaster whose problems go far deeper than the UI.
Also, rails is changing things by preferring convention over configuration? What year is this, 2005?
In the end, here is my complaint: You are taking what is essentially the best case scenario, proprietary or not, and saying that it means software with a copyright license is more usable than software with a copyleft license. Stop doing that, it does the general discourse about software a disservice.
Best case scenario... OK, how many apps are in the iPhone app store? 1/4 million I think I saw somewhere? How many of those are open source? A lot of those sell more copies than most desktop apps would dream of. You can put open source apps on the store, and it could impact a ton of people. Why isn't it happening? Android apps, from what I've seen, have a similar comparison - while many of the successful open source apps are unique in some functionality, the vast majority of the polished design seems to be coming from small companies. And Android is far more appealing to most programmers / geeks who value open source. What's the disconnect coming from, if not lack of supply?
I've yet to see more than low-double-digits of beautifully designed open source programs, and the majority of those were made entirely by one person, often open-sourced because they didn't think they could get enough money to make monetizing it worthwhile. I've been watching for years (though I could be watching in the wrong area). Meanwhile, the rest of the world has been utterly rocketing towards more focus on design, and has a long history of success.
Want more evidence? Look at games. Millions upon millions of players, probably approaching billions of copies sold / downloaded, very few of which are open source games. There's an entire industry oriented around UI/UX and design... and where's the open source influence? Bad Civilization / Quake clones? A lot of the unique designs I've seen have been done by individuals without open sourcing the code, for whatever reason.
And yes, OOo is frightening on many levels. It's a worst case scenario, and I recognize it... but I see it echoed frequently in other OSS projects.
I have not said OSS cannot produce good UIs. I have said there seems to be a trend, and at least I have seen far less. And also take into account that this is not done by enumerating all programs ever produced; this is weighted by success, especially with the design-oriented consumer culture lately.
I don't know, even a cursory glance at the Ubuntu homepage, complete with shiny screenshots (theoretically chosen to showcase the best design elements), shows there's still a ridiculous distance to go before it'd be anything I'd consider "well designed". Further investigation shows similar inconsistencies across nearly every screenshot of included applications.
Better by far, certainly. The Ubuntu crowd has made significant strides in the past few years. But just look at the "Ubuntu One Music Store" image and tell me you don't see glaring inconsistencies in padding, form outlines, and control styles. Then look at other applications and notice which buttons are shaded and when, and resizable edge styles, and why does the shade get that dark near the bottom without a font highlight to counter the harder-to-read lower contrast?
Are you comparing ubuntu running in vmware to native win7/osx? Then yes, you might come to this conclusion.
Try comparing native/native or virtualized/virtualized. The vmware and virtualbox drivers lack many functions that are used in native-running ubuntu or windows, for that matter.
I hate trolls like you. A lot of us work really hard on making it the best damn platform ever, and it is, and then some quack who doesn't know anything says "it's just like Windows 95" which shows that they didn't even bother to try it out, or take the tour on ubuntu.com or even watch a recent video of the latest release on youtube. And that just sucks the fun out of life.
Please, actually take a look at it before saying something ridiculous.
I'm basing that one first hand experience, but as vetinari correctly guessed, I do run it in VMware. I have no way right now to test if, as he says, that makes a huge difference. But using a VM is how most people will test out operating systems and the best way to get first hand experience without a huge commitment.
Calling users trolls who don't know anything doesn't make me want to give you any credit. Vetinari made me consider that I might be missing out on the best the platform has to offer but you just made me want to uninstall it.
> 5 years ago for .Net was a very long time ago. Back then the only games in town were C++, java or .net.
Wow! I was building sites with Zope by 2002. There were far better alternatives than C++, Java and .NET far earlier than 5 years ago. I did lots and lots of Perl since 1996 and some PHP thrown in around 2000. Only used C++ and Java when nothing else would do (mostly because of clients that had too much of the wrong Kool-Aid).
No there really is a big difference in the culture, ecosystem and average programmer between the FOSS/Unix world and the Microsoft world. Individuals always vary sure. Exceptions to the rule, sure. But there is a very real difference between those two worlds. I'd say almost every programmer who has been around long enough, and exposed to both camps, realizes this. Do a survey of say the top 100 famous "elite" programmers in our industry and I bet the overwhelming majority would agree with this characterization. The evidence is out there.
And yes, Microsoft has been trying to get more and more Unixy over the years, and more and more Appley, and I'll bet they continue doing that in the future. Good for them.
It lacks support for something as simple as automatically inserting the method declarations for interfaces when you had to implement them, let alone promotion of variable declaration to fields. And there is essentially no way to uninline a method. Eclipse has _all_ these things.
And this is still a problem for the 2010 ultimate edition.
The smallish company I work for is in the early stages of transitioning to a new development platform as all their existing systems are antiquated. The company doesn't have any particular dependance on Microsoft technology, and from my perspective it's a great opportunity to embrace a contemporary open source platform.
Sadly the management seems to be considering that all new development should be in .Net and centralised with TFS. I can't rightly understand why anyone would want to tie themselves to this costly, closed platform when they can essentially choose anything.
Sadly the management seems to be considering that all new development should be in .Net and centralised with TFS.
I've seen .Net code stored in TFS, svn, perforce, Mercurial and git. If your management aren't using the source control system, why are they deciding? Just use the one that suits you.
I've done a small amount of coding in Java and am mostly a .NET guy, so I've seen a bit of both worlds.
It's an interesting take on .NET he has. I find that answers and sharing is as prominent in the .NET community as the Java community -- perhaps not as many F/OSS projects. Dunnno.
As far as setting up NUnit, takes about 5 minutes. Sure, it'd be better if there was a whizbang plugin for the IDE, but if you wanted you could make one easily enough and distribute. It's not convenient, but it never seemed like a huge deal. I've used NUnit, XUnit, and the MS tools. If I remember correctly, seems like there is an open-source pluggable test running tool. Never have played around with it.
And if you need help? Google is your friend. There are so many .NET people out there blogging and sharing code that you can just about ask Google any problem you might have. Hell, I've copied the error right from the IDE and pasted it in the search box -- works almost every time.
I like both communities, although I have become less of a fan of MS over the years. Lately I'm leaning towards coding in F# on mono for new projects, but I haven't set up the stack yet.
He does have a point, there is a difference in the cultures. But both communities are very accessible and easy to work with, at least from my experience.
I think the best analogy he made was the 70s/80s. It isn't that one is necessarily better than the other, but they are different. It takes some time to assimilate from one to the other.
As a language C# is ok, and there's not all that much difference to Java. If you use the Mono compiler and MonoDevelop IDE, which has integration with version control and NUnit, then things aren't too bad and you don't need to deal with a culture where every trivial utility is ransomware.
If you think C# is not much different than Java then you are either not running up against the limitations of Java much, not using C#'s features fully/properly, or both.
I met boatloads of programmers and by now I have some that I would designated as Real.
My friend Johnathan calls the others "career programmers". Those are the people that you end up baby-handling, qualifying your statements and padding your speech with descriptive wiki paragraphs lest you lose them to a fancy day-dream.
I am OK with passing judgement like that. I was more concerned about confusion with another meaning of the term Real Programmer:
"A particular sub-variety of hacker: one possessed of a flippant attitude toward complexity that is arrogant even when justified by experience. The archetypal Real Programmer likes to program on the bare metal and is very good at same, remembers the binary opcodes for every machine he has ever programmed, thinks that HLLs are sissy, and uses a debugger to edit his code because full-screen editors are for wimps. Real Programmers aren't satisfied with code that hasn't been tuned into a state of tenseness just short of rupture. Real Programmers never use comments or write documentation: “If it was hard to write”, says the Real Programmer, “it should be hard to understand.” Real Programmers can make machines do things that were never in their spec sheets; in fact, they are seldom really happy unless doing so. A Real Programmer's code can awe with its fiendish brilliance, even as its crockishness appalls. Real Programmers live on junk food and coffee, hang line-printer art on their walls, and terrify the crap out of other programmers — because someday, somebody else might have to try to understand their code in order to change it. Their successors generally consider it a Good Thing that there aren't many Real Programmers around any more. For a famous (and somewhat more positive) portrait of a Real Programmer, see The Story of Mel' in Appendix A. The term itself was popularized by a letter to the editor in the July 1983 Datamation titled Real Programmers Don't Use Pascal by Ed Post, still circulating on Usenet and Internet in on-line form." (http://www.catb.org/jargon/html/R/Real-Programmer.html)
He says that .Net coders don't answer each other's questions. What's stackoverflow then?
He says that the .Net ecosystem is not as rich, and mentions nUnit, but not the other major open-source testing frameworks - xUnit and mbUnit. Then there's also MS testing, or if you like BDD, there's NSpec and SpecFlow.
I've seen seven or eight open-source .Net IoC containers (including one from Microsoft). By far the weakest of the major ones was Spring.Net, the straight-up port of the popular Java tool. If you don't like EF (Microsoft's ORM), there's NHibernate. Subsonic and others. If you don't like Webforms or asp.Net MVC, theres Fubu and OpenRasta.
Unfortunately a Resharper licence is the price of entry into a lot of IDE goodness. He has that right anyway.
The .Net shop that I work in doesn't choose tools to use in our .Net development efforts based on cost or licence. We choose what makes sense. There is really are few or none "only paid, proprietary software" development shops left. It's all mixed.