This article is a fairly valueless press release for Dice, but be that as it may: there are no shortages for developers, there are only shortages for developers at the wages employers are willing to pay.
Folks that like to program, usually don't like to write back office apps.
I kinda like my job right now but for a million bucks I'd kinda like your Sharepoint installation, too.
Developers with a good head on their shoulders can get 6 figures easy doing SharePoint... but who in God's name would want to?
Then the hiring manager bitched to me that all of the programmers they hired quit when they found out the job actually involved Sharepoint!
It's always funny when you hear someone complain that "everyone I've worked with in field X is an asshole" or "All the clients I have are assholes", etc. Pretty soon it's likely that you, not your clients, are the asshole.
There is something about building things outside the box instead of being part of an assembly line at corporate shops. The lack of politics and endless meetings is a bonus too. It's not always about the money.
It's still hard to get an Enterprise job as a Ruby developer.
Hence the stereotype.
I think he was saying that the typical Enterprise jobs are uncool, not that .Net is necessarily so.
I'd take 6 figures of SP and develop WebParts (and will sell them).
It's a very good niche business. Just like what Wordpress used to be (or Drupal).
I see so many companies that want something for nothing. They want the automation and savings from the systems that developers are building, they're just not willing to pay for it. But then ask them if they'd rather go back to the manual business process they were doing before (that doesn't require paying developer salaries) and they look at you like you're crazy.
Programmers are interesting animals - the good ones work for fun. As long as their bills are getting paid and work is interesting, they stay. Give them a brain-dead job, like anything Sharepoint-related, and they leave.
I disgaree. They do work on interesting stuff, but getting bills paid isn't sufficient. There's no shortage of interesting work. If you can't find an interesting job at pay you find compelling then there's a problem.
I'm not expecting "fuck you" money, but something that pays enough to compel me to be in a car for 2-3 hours per day commuting, or something interesting enough to compel me to move states.
We probably have different numbers for "compelling" pay.
LOL. Only the idiots. The others find places where they get to do stuff they love and where they get paid well.
"Why the shortage? ....NET developers earn around $83,000 per year, but Java developers typically make more than $91,000."
Java, and it's ecosystem, are a little more difficult to use and master than C#, and IMO, warrant the extra average pay.
Having said that, I agree that Java ecosystem is more difficult to learn.
Many students during my college time prefer .NET because VS.NET Express makes a lot of things easier compare to Eclipse, Java, Ant, classpath, etc (forget Maven).
Also, let's be honest: the Java ecosystem is a mess in a lot of ways. One of the biggest pluses to the .NET world is that things tend to Just Work a lot more than in the Java world. Not that this is a huge deal (I work in Java, and handle it fine), but considerably more knowledge of the entire Java stack is often necessary than on .NET.
There are probably more books teaching how to write better code in Java than in C#. Even if the number of books in C# that taught better ways to code is approaching the Java counterpart, they are more likely to be newer books and not necessary preached by Microsoft.
As much as people don't like (or abusing) Spring and Dependency Injection concept, more Java projects are using it (with probably some amount of unit-testing) as opposed to C#.
When you look at Continuous Integration landscape, most of them came from Java.
Oh, and Scala naturally lends itself to writing maintainable and bug-free code.
This does not match my experience in the slightest. MSDN is leaps and bounds better than the Java documentation and the available resources at places like Stack Overflow tend, in my experience, to be of higher quality and quantity. In this I find that C#'s lack of favor as a pedagogical language works in the C# developer's favor: there's much more signal to much less noise.
> I've also found that you can't understand the entire stack in .NET because that information is often just not available.
This is simply not true. There is very, very little information that is not available about .NET (largely derived from either reading the specs or inspecting the IL) and essentially nothing unavailable about the .NET libraries thanks to Rotor (for legally safe inspection of certain libraries) and Reflector (which poisons you for Mono contribution, but is a fairly accepted practice).
> When they do, it's nice to be able to peel the abstractions away.
You can, trivially. It is an indictment of the largely ASP.NET-focused developers mentioned previously that they do not, but it is not a difficult task.
> Oh, and Scala naturally lends itself to writing maintainable and bug-free code.
After some confusion from this statement I entertained, if unwillingly, the thought that you are serious. Scala is no Perl with regard to its distaste for readable code, but it lends itself to ambiguous or stupid syntax (the inanity about "using what you like" for parens versus braces comes to mind as a minor quibble, the flinging of underscores throughout "idiomatic" code being a much greater one). To complicate matters, Scala's IDE support (even in IDEA, the best of a sorry lot) is horrifyingly bad. To what Scala lends itself, I have not yet been able to ascertain, but "maintainable" has surely not been an adjective I'd use. Partial credit for "bug-free" due to its tendency to encourage immutability, for which I am very thankful, but...only partial. I still have to read the byte-vomit.
The best compliment that I can pay to Scala is that it is better than Java--damning with very, very faint praise. I'm praying that Ceylon or Kotlin comes along and deals with this insanity in an adequate manner.
I am not however, inexperienced with Scala or with programming languages in general. I was very serious about Scala. There is nothing ambiguous or hard-to-understand about Scala's syntax. If a couple of underscores or inferred parenthesis throw you off then I seriously doubt your ability to read source code effectively.
I mean, really. Interchangeability of "()" and "{}" bothers you? Making them interchangeable, along with currying, lets you invoke higher order functions in a way that is much more natural looking than what you can do in C#. The Scala code often looks identical to Ruby's blocks, which, as a second witness, most people also find to be a far more pleasant syntax than the equivalent Python code..
Can you really not, when you see "call(_,_)", parse it in your head as its more verbose C#-like equivalent, "(a,b) => call(a,b)"? If you can read the C# version, there is no reason you can't just as easily read the Scala one.
Is it so hard for you to see that "list filter pred sum" is equivalent to list.filter(pred).sum()? Scala is actually simplifying and unifying the language with this rule. Whereas most languages handle arithmetic operators specially, Scala can treat 1 + 2 + 3 literally as 1.+(2).+(3), which means that + is just a normal method!. In this sense, Scala is simpler and easier to grok than almost any other mainstream language!
And, Scala's IDE support, which is supposed to be fairly good at this point, has no bearing on the topic of conversation. Finally, There is nothing exciting to hope for in Ceylon or Kotlin compared to Scala. It looks like, in terms of language advocacy, we are direct enemies!
Edit: There are of course exceptions to this, but I have seen it too many times to not see believe it is the norm.
I have to take exception to that -- or at least the specific phrasing.
It's certainly true that most MS-platform guys don't grok other platforms. But I strongly disagree that they cannot do so, given a brief period to learn.
My experience is these people typically transition over later in their careers.