I previously pointed out that .NET questions on Stack Overflow seem to be degrading to nothing more than beginners asking about how to plug together Microsoft's widgets to produce a desired effect. That tide seems to be subsiding, though it is still clearly present. I guess it's just the nature of the beast these days. The market is flooded with entry-level developers (many of whom are no longer considered entry-level because of their experience, whether or not they've actually learned from that experience) who use frameworks and tools and, ultimately, pluggable widgets. I see Microsoft as the king of these widgets, hence my generalization.
But I was thinking today about the whole picture and wondering why I specifically don't like this. Basically, I was helping a few people on Stack Overflow with some ASP .NET controls and had to put in some serious effort not to just rant about how they're going about the whole thing all wrong and that they shouldn't be afraid to write some code themselves instead of using Microsoft's controls. (I particularly cringe whenever I see remnants from .NET 2.0 web controls when Microsoft went control-crazy and hooked up some provider frameworks to make web development as plug-and-play as possible. People still use that stuff. A lot. And it really bothers me.)
It occurred to me what the root of my concern really is. It's not entry-level developers, it's not frameworks and tools, it's not even me being some stodgy old know-it-all because in my day we used to program in bare text editors and used terminals and get off my lawn! It's because these widgets address the wrong side of the equation.
Writing software is easy.
Supporting software is hard.
It's that simple, really. (And reminds me of one of my favorite quotes... "Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it." --Brian Kernighan)
Microsoft creates clever widgets which a novice can, with minimal training, plug together to produce a desired result. This makes the step of writing software easier, but at the cost of supporting the software. And that doesn't make the entire process any easier. In fact, when you look at the whole picture of the software life cycle, it ends up being more costly in the long run. Small changes to requirements or small additions to business logic that exist just outside the scope of the pluggable widgets require significant effort to implement. Custom code, on the other hand, isn't difficult to change at all (if written well).
We're really reminded of this on an almost daily basis when developing in .NET. Think of a .NET stack trace. At the top is where the exception ended up (caught somewhere useful, I hope), and as you descend the trace it goes through your code so you can see where it was thrown and the path it took down the stack.
Many times, however, by the time you get to the bottom of the trace you are in Microsoft's code. This isn't really a bad thing, after all it is all running on top of Microsoft's libraries. So this is bound to happen. And the more experience we have on the subject the more we can identify what's wrong by looking at Microsoft's part of the trace as well. But the boundary is still clear. Once you cross over from custom code to System.* then you officially enter the black box. There are some things you can do, but it's just not the same as code you can actually step through.
How do you step through a DataGrid entirely defined in HTML controls and bound to a data source also defined in HTML controls? You didn't actually write any code. Do you even know what it's doing? Maybe you do, maybe you don't. Maybe the next guy who has to support it does, maybe he doesn't. That's a problem. But when something breaks, what do you do? Your stack trace begins with code you didn't write. For an experienced developer this may not present a huge problem, albeit an annoying one, but for that novice who was hired because he demonstrated an ability to plug widgets together it could be a serious stopping point.
I'm not saying that we shouldn't use tools that are available to us. But we need to know what those tools are doing. You can't make a career out of "I press a button and this happens, so as long as people want this to happen they can pay me to press this button." Don't let Microsoft do the thinking for you. Writing the software is the easy part.