Novices and Sheep and Morts, Oh My!

Ayende wrote a post in response to a post by Peter Laudati.  Read the originals, both good stuff.

I'm going to paraphrase them in places to make a few points, so definitely read the originals.

There are (at least) a couple of different issues going on here.

Peter's post was a response to a general 'idea' that Microsoft caters to lower-skilled developers vs. 'alpha geeks' and generally accepts this notion, saying in a response to Sam Gentile's comment:

"My point with the post is that I acknowledge that Microsoft’s tools cater to novices.  But novices make up a much greater percentage of the user base.  In defense of Microsoft, I think it’s to be expected that the tools cater to those folks. "

In the original, he added this point:

"We'd all like to think of ourselves as 'alpha-geeks', but at the end of the day the reality is that the majority of folks in the world are not.  Those so-called 'alphas' need to get over themselves."

When talking about the types of tools (designers, wizards, etc.) that he says help support the novices, he said:

"When I see developer tools coming out of Microsoft that support this group, I get excited because it makes my former job as a 'shepherd' easier."

In Ayende's post, he objects to a number of things.  The use of the term 'shepherd' particularly bothers him:

"I have no way to express just how bothered I am by this statement. Shepherd? Developers are not sheep! Maybe a further look is needed, one that goes beyond the sheering pens."

And his contempt for things such as designers, wizards, etc. is also clearly stated:

"to get to the point where you hand dumbed-down tools is showing acute contempt for the developers in question, and I find it insulting."

Okay, so proper quotation out of the way, what about it?


Do 'Alphas' need to get over themselves?

In the aforementioned response to Sam Gentile, Peter admits:

"My suggestion that ‘alphas’ need to get over themselves may have been a bit over the top. :)"

Now, I think Peter is just being polite here.  I think it is absolutely the case that there is a significant subset (vaguely, 'subset' meaning not all, 'significant' meaning more than 2) of the Alpha-Geek community in .NET development that needs to get over themselves.  In a certain respect.

As I've noted in various places in comments to posts (including mine to Ayende's), this subset seems to be unable to espouse best practices in code development without either implicitly or explicitly denigrating or condescending the general Microsoft developer community.  'Mort' is a common term.  It can (in theory) be used as a purely descriptive term, but more often than not, it is used as a purely derogatory term, essentially semantically equivalent to mean 'moron.'

Regardless of whether the term 'Mort' is used, the attitude is evinced by many people in many ways.  'Morts' are dumb programmers who don't understand better programming practices, don't care about them, and couldn't implement them if you explained it to them.

As I'll explain later below, this is simply false.

Moreover, it is, for lack of a better phrase, 'bad marketing' to keep displaying this attitude.  It serves nothing and makes it that much harder to spread the practice of better programming practices when you insult the people you theoretically want to lead to the promised land.  I don't know if I ever qualified as being a 'Mort.'  I programmed in Basic as a teenager (goto 1000, damn, I need more lines, goto 10000) but didn't start 'professional' programming until .NET 1.0.  My programming was probably sub-Mortish to be honest.  It wasn't good, whatever it was.

And I'm fine with that.  I did a lot of RTFM, reading the writings of better programmers, etc.  Jeremy Miller says this means by definition I'm not a Mort.  Okay.  Whatever.  I'm trying to get better each day to make my services better for my clients, so whether I do or do not qualify as being 'Mort' or 'Alt.NET' or anything isn't relevant to me.

But the fact of the matter, and what I perceive Peter's main point to be, is that the vast majority of programmers aren't great.  This is so obvious a point as to be unarguable, but then the question arises: what purpose is there in insulting the vast Microsoft community base?  I don't see it.


Are Designers, Wizards, etc. inherently Bad?

The answer to this is unequivocally 'No.'  The reasons for this answer are a bit more complicated.

It is difficult to explain why, but I will start with a post by Jay Kimball.  What this has to do with designers, etc. might not be immediately clear, so bear with me.

Assuming I read it correctly, one of the points Jay was making in questioning the need to use MVC/MVP in building web sites.  He made a comment (paraphrasing) that MVC/MVP was simply not necessary for web sites that didn't have high traffic.  The 'high traffic' bit got a lot of comments, and he got a lot of heat (and condescension in the blogosphere) but in my opinion missed the point.

So, I'll rephrase it.  Is MVC/MVP necessary when doing web site development?

Of course not.  In fact, I would make the stronger statement that it is *wrong* to use MVC/MVP when doing web site development, unless it is a good thing.

I use MVP.  I love it.  I use it all the time (I use it with WebForms, and Ayende has stated that you can't do MVC/MVP with WebForms.  I think this is acceptable hyperbole.  Obviously, you can use MVP/MVC with WebForms, and so what I think he means is that you can't use it to its best ability with WebForms and that you need to use something else, and he would recommend Monorail.   I don't like Monorail because I don't like ROR in general, but that's a personal philosophical thing beyond the scope of this post.  And to be fair, I think Ayende would say that you can better WebForms without using Monorail, that just happens to be what he uses).  But it is simply not the case that you need to use MVC/MVP to develop web applications.

From a purely business perspective, what you need to do is create applications that fulfill the needs of the business users.  Full stop.  Whether the code is 'pure' from some perspective is *completely* irrelevant.

If I understand Ayende's points on this, it is that you don't know whether an application will need to be 'extended' in the future.  But I would posit that this is clearly not true.  A *large* number of applications have a clear set of requirements, and they won't be extended in the future.  You need to handle the requirements that the business users require right now.

And it is *unarguable* that it is easier to use, say, the ObjectDataSource, to accomplish this than to do MVP/MPC.  There is *no* argument against this.  None. 

And the same holds true for almost any application that uses a wizard or designer, be it web based or WinForm based.  It is unarguably easier to use a wizard or designer to design the vast majority of applications that are used by businesses around the world. 

Proving this, of course, is next to impossible.  But I would posit the following:

a) the vast number of applications that are used by businesses to support their efforts to make money do not require advanced programming techniques.

b) the code that is produced by using designers, wizards, etc. is sufficient to support those applications.

c) the code that is produced by using designers, wizards, etc. is more easily maintained by people who aren't alpha-geeks.

d) if you have someone like Ayende on your development staff, the code that is produced by using designers, wizards, etc. will never be anywhere near what your Ayende-type developer can produce.  So if you have one of those, fuck the designer.



Peter was right.  Since he's more polite, he stepped back from his 'get over themselves' comment, but his original comment was correct.

Using the 'dumbed-down' designer/wizard tools is almost always a good business decision.

In a perfect world, the designer/wizard tools could match the level/skill of someone like Ayende.

If you have skill, you can roll your own designer/wizard tools to match the level/skill of someone like Ayende in at least 75% of cases, and that's pretty good.

posted on Wednesday, June 13, 2007 10:01 PM Print
# re: Novices and Sheep and Morts, Oh My!
6/16/2007 5:16 PM
I'm having issues with the entire concept surrounding the "Alpha geek" and "Mort".
# re: Novices and Sheep and Morts, Oh My!
6/16/2007 5:17 PM
Forgot the trackback:
# Do we track and see the consequences?
6/26/2007 3:30 AM
I agree that the so called "alpha geeks" would probably benefit from a humbler attitude.

At the same time, I react to the tone in this post; it is reminiscent of so many developers and is best summed as your "whatever" response to encouragement by peers (Jeremy in this case). In short, many devs need to realize that they are devs. Deal with it. Realize that when you say "whatever" to your own skillset, maybe you should be critical of yourself: Maybe that is not a solely good thing? It feels like distancing oneself from what you do.

I feel the same way you do in many ways, I am not a computer science major but an information science major. I am an applications programmer, I solve simple text shuffling problems. But I still feel professional pride, and I think it is important. But, many devs don't and they do their work, but other devs have to clean up after them.

Basically, I get upset with one thing: Devs that don't think about the consequences of what they do (obviously not you). Alot of devs hack and slash code. These inconsiderate devs are the ones that don't "care" about what they do. Someone else does. That someone else sits in the corner, cleaning up the bugs. That is ok. That someone else has to come in late at night or for weekends over and over again to fix critical production stops. That might be ok, but in many cases (when these devs get families) it is not. The immature state of our field makes it ok, since that is how it has always been. I firmly believe that we need to work on this alot.

In a tiny, tiny set of cases it is true that the software is throwaway. In most cases where we think it is so, it is not. And in many such cases, devs do not consider the consequences of what they do. No one complains, no one is critical...

So I agree with (a) and I don't care if you use a wizard (b) (but I'll be pissed of if pairing with you, because you are wasting the teams time by not putting in effort) as long as the code you write won't waste large amounts of the teams time to understand when it needs to be debugged, added to, etc.

I disagree with (c), I don't think there is any correlation. Rather, I have seen both junior and senior devs get stuck for days (and weeks) trying to get autogenerated code to work as it is "supposed" to. The expense is large. The devs that put the code there have gone off home to drink beer and watch reruns.

Sure, a reader might say "booo-hooo, why don't the devs that have to work late just get another job? Jeez, and stop whining." That would be a macho/John Wayne viewpoint. But I am not interested in a gunslinger/wild west/John Wayne society, I think the problem is systemic: Our field is immature and our methods lacking:

There is an interesting dynamic between tools that support bad practices, I believe we could initiate change from both ways; these tools keep the bad practices in place.

Hmm, sorry for the long and rambling post!
# re: Novices and Sheep and Morts, Oh My!
6/26/2007 8:04 PM
No need to apologize. Ramble away.

I think you read a bit too much into my 'whatever' comment (as a sign of my own rambling it took me about a minute to find it...LOL). I don't know if Jeremy was trying to be encouraging or just making a point of fact, but what I meant by it was simply that I don't really care, in general, whether I count as a Mort or not, in the sense that I think those personas have come to do more harm than good in the debate.

I try to improve my skills because I want to and because it gives my clients (I hope) business advantage. As I've stated repeatedly, my ego is pretty healthy, so I certainly don't mind if people who are well known give positive feedback (I've enjoyed the interaction with Ayende, for instance). But it doesn't validate me as a person, if you know what I mean.

I don't know if you read my John Matthews post. I think there is a lot more 'throwaway' code than you might think.

But to give a different example: I worked in the Market Data group of a large financial firm. I would estimate that 75% of the code that was written was written once, and then that was it. The only time maintenance was required was if a vendor changed a file format. My own project was such a thing. It went into production and changed twice in a year, and actual coding was never more than a day or so.

Now, I also wrote some client applications, and those required added features and more maintenance, but it was pretty minor. I was using typed DataSets and TableAdapters and I put a thin business layer in front of it, and when I needed to pass it off to another developer, it was easy to maintain. Never needed to look at the autogenerated code at all.

And I think a large amount of code is like that. But there's no way to easily turn anecdotal experience into hard evidence.

Thanks for the feedback. Always appreciated.
# re: Novices and Sheep and Morts, Oh My!
6/27/2007 5:47 PM
Like I hinted, I am not the smartest of devs. Some think I am fast but I am really slow between the ears. I can't deal with old code, I just don't remember.

So for me to consider code throwaway, it would have to be completed in 1-3 days and then be bugfree.

If it takes weeks, I will forget details and need to reread stuff. Worse, if it has bugs I will have to reread and understand it even more (since we don't have tests in cowboy coding land).

But it seems most devs are even more stupider than me! They forget their own pain and do the same mistakes over and over and over. When a dev comes up to me and says, "let's just churn it out, this is simple stuff", he does so because he has "forgotten" (denial) the pain he felt last month when he tried the same stunt. John Wayne coders, phew.

Thanks for your thoughtful reply.
Comments have been closed on this topic.