ALT.NET Recap: Front and center, let’s talk constructively about Mort

Posted by Jeremy Miller on October 10, 2007

There’s much, much more to follow from this past weekend.  This just happened to be the section I managed to get done first.  Please don’t get the impression that all we did is sit around and bash Mort, because that’s very far from the truth.  Most of the time was spent trying to learn how to build software better and more efficiently.  We did spend a couple sessions on how to make the community as a whole better, and this reflects a piece of those discussions.


I’d like to take this time to remind everyone that the term “Mort” was coined by Microsoft itself and not by me.  I first heard the term four years ago from a recently converted Java developer sneering at the barbarian hordes of VB6 developers doing .Net — which, after removing a veneer of OO fundamentals, was basically me.  His complaint, and one that I unfortunately still agree with, was that .Net developers put more emphasis on knowing technical details and API’s instead of learning programming and design principles.  In his and my value system, the fundamentals like separation of concerns are more important.


Yes, I know that some of the elitists among us have been know to bash Mort from time to time and I’d be a wealthy man if I had a quarter for every time I’ve propagated or witnessed Mort-bashing.  At ALT.NET, I would have been able to get a soft drink from the proceeds, but Starbucks would have been out of reach.  Anytime you talk about spreading the usage of Agile techniques in the .Net community or raising the awareness of OOP principles someone inevitably raises the concern that “Mort won’t get it” or “Mort doesn’t care” or even “Mort shouldn’t have to care about any of that, Mort should get to go home at 5 and play softball.”  Does it have to be that way though?  More importantly, is any of that really true?  Can we be a little more optimistic about other developers? 


Before I go any farther, I’m going to paraphrase Microsoft’s original persona definition.  Mort is a developer who only learns just what he needs to complete his project, on the project.  The positive spin is that Mort is a perfectly pragmatic fellow that’s only focused on adding business value as opposed to a pinhead that’s too wrapped up with internal trees to see the forest.  The pejorative usage is simply a bad developer or a 501 developer that just doesn’t care.  You, myself, ALT.NET, INETA, and the entire blogosphere can’t do much about a lack of motivation, but we can all do something about providing more opportunities for learning and exposure to other ideas outside of the MSDN canon.


Why does it even matter if a developer is content to be a Mort?  I think that one of the reasons that our profession is lacking in skill across the board is how easy it is to write code.  The only ingredients you absolutely need is a compiler and basic “if/then” or “do/while/foreach” constructs and your set.  Just pump in energy, late nights, and pizza and you’ve got some code that’ll do what you need it to — as long as you don’t try to reuse it or modify it later or heavens forbid, change your mind about what it’s supposed to do.  We’ve generated a great deal of lore well beyond simple programming constructs to foster better productivity and create sustainable codebase’s.  To make software development finally be a truly respected profession, we need to start internalizing the lessons we’ve already learned.


Back to the question about whether or not Mort can get the stuff we’re talking about like separation of concerns and TDD.  The typical Mort has managed to acquire a working knowledge of DataSet’s, data binding, and the WebForms event lifecycle, the things that comprise what I call the “MSDN way.”  These topics aren’t all trivial, and the WebForms lifecycle machinery is outright complicated.  Mort has learned these tools quite successfully because:



  1. He’s probably a smart fellow anyway, or he would have been weeded out.  Or made into a manager.

  2. He’s learned the things that have been put in front of him.  He isn’t necessarily out there looking for new or different things and might not have even heard of TDD or IoC tools or mock objects.  The topics listed above are the things that a typical .Net developer is likely to come into contact with in the course of his career in an average shop.

After the conference I had an interesting exchange (over a plate of Chicka Chicka Boom Boom enchiladas at Chuy’s) about whether or not there are, or could be, Morts in the Ruby on Rails community.  We decided pretty quickly that it was a moot point in a way.  There probably are 501 developers doing Rails, but anybody doing Rails is automatically exposed to what I would call better software practices.  Separation of concerns, unit testing, and automated build scripts are all baked into Rails.  A Mort working in a Rails shop who only learns what he needs for a project just has to open his or her eyes to take in many of the things that Mort in .Net can easily miss out on.  I’d rather that more and more of our .Net community invest in their knowledge and look around outside of .Net a bit more, but we can do more to give the average Mort a chance to learn by exposing him or her to solid software development principles.


We’ve got a golden opportunity to make the exact same thing happen in the .Net community with the advent of ScottGu and co’s new MVC framework.  I’m sure the usual suspects will jump in front with conference talks about the new technology that focus on the libraries, but let’s make sure that at least some of the articles and presentations about the ASP.NET MVC framework discuss the underlying principles and the advantages of those principles.


 


Just for fun, here’s some Mort related quotes from this weekend:



“Mort is just an Elvis-in-training”


“I’m the Mort-iest Mort, Mort, Mort…”


“…long live American .Net Idol, where everyone gets a chance to be Elvis…”  You’ve got to picture the speaker waving a hot wing with sauce running down his chin to get the full effect.


And one last time, ScottGu needling Bellware:  “Scott, it’s Morts like you…”

About Jeremy Miller

Jeremy is the Chief Software Architect at Dovetail Software, the coolest ISV in Austin. Jeremy began his IT career writing "Shadow IT" applications to automate his engineering documentation, then wandered into software development because it looked like more fun. Jeremy is the author of the open source StructureMap tool for Dependency Injection with .Net, StoryTeller for supercharged acceptance testing in .Net, and one of the principal developers behind FubuMVC. Jeremy's thoughts on all things software can be found at The Shade Tree Developer at http://codebetter.com/jeremymiller.
This entry was posted in altnetconf, Featured. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • SteveG

    I clearly said I was playing devil’s advocate, and I took the term Mort to mean EXACTLY how you used as someone who is good at using datasets. I assume this Mort knows how to create a datalayer using the DAAB filling datasets and binding them to a UI as you suggest.

    The tools are provided in VS to make this rather easy to implement and use xml, etc…

    I see large enterprise corporations using the above system. Using datasets as DTO, etc..

    What I described as ‘devil’s advocate’ was to suggest that this is what I’m told when I visit Microsoft shops – LOL I’m just echo’ing what I hear to get your reaction to it :)

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    @SteveG,

    Did you read this post, or just skip to the comment section to get mad about me using the term “Mort?”

    I used, or tried to use, the original Microsoft definition. Mort is the guy who only learns on the job and hence only knows what he’s been exposed to on the job. That’s why the average “Mort” only knows datasets, data binding, and procedural coding. If you actually read this post you’ll see that I never make a direct connection between Mort and a bad coder.

    “However, your calling Mort someone that is utilizing these technologies in an architecture outlined by Fowler”

    That’s a spurious plea to a higher power on your part. Fowler presented all of the various options for organizing data access and domain logic in an enterprise application. All those things you listed for Mort are things that Fowler said were suitable for smaller apps but didn’t work as well in larger, more complex problem domains. Very close to what I said in the post.

  • http://blogger.forgottenskies.com SteveG

    I’m going to play devil’s advocate:

    I think Fowler has written about the Table Gateway, Page Controller, the use of typed datasets, etc… he doesn’t treat it like it’s a ‘Mort’…

    However, your calling Mort someone that is utilizing these technologies in an architecture outlined by Fowler.

    Are you saying Fowler is wrong? Go read his Enterprise patterns book and tell me: is the current ‘Mort’ approach ‘wrong’, or does it not fit into a different Domain model approach that is anti-datasets, and pro-front controller?

    I’m a fan of Monorail, TDD, DDD, etc… but I’m also aware, because I’ve built solutions in my past using the above architecture and it worked out quite well.

    Technologies like MS MVP and Monorail make it easier to implement front controller type architectures, but that isn’t saying a page controller architecture is ‘wrong’, don’t you think?

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    Actually Barry, we got a little dosage of guilt trip from the MSDN magazine guys to start submitting more articles to the magazine. I’ve already sent in some abstracts and others from the ALT.NET event are doing the same.

    As for the “being presented as something new yet again with alt.net ”

    Try this: http://codebetter.com/blogs/jeremy.miller/archive/2007/10/11/alt-net-isn-t-completely-baked-and-there-s-nothing-new-here.aspx

  • http://idunno.org barryd

    I feel sorry for MSDN really; there’s already people blaiming them in the comments above for the “MSDN way”. They’re not the only guilty party. Right now I’m doing a part time degree (I was bored, newly divorced, I needed to do something with my time *grin*). They only offer java as part of the degree. Unit testing is given a small nod, but nothing on TDD, patterns, secure design.

    What amuses me is that all this is being presented as something new yet again with alt.net (which really sounds like a BDSM dating site to me). It’s just a representation of the code monkey argument (which I waffled about a while back; http://idunno.org/archive/2007/07/03/i-am-but-a-code-monkey.aspx ). There’s a massive amount of snobbery involved and that helps no-one. It’s the same with barcamps, a lot of “This is open source, and not from Microsoft so it *must* be better”, with no actual reasoning behind it. That doesn’t help anyone.

    (Interestingly the next London barcamp is running at the same time as the community lead developer day held at Microsoft. A big part of me wonders if that was done on purpose by the hosts)

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    “The only way the ‘solution’ is to come from ‘us’ is for Mort to not tell management and just implement to these practices anyway.”

    That’s roughly how a lot of the early Agile implementations got started

  • Mr Vain

    @Jeremy,

    No the ‘solution’ has to come from the Architect, a common malady in large companies. Unfortunately Agile methods are very threatening to the so called ‘Enterprise Architect’, who is the main roadblock to these practices taking hold. What role do Enterprise Architects and have in Agile methods? Do you seriously expect the Architect to put away his fancy PowerPoint presentations, and god forbid…actually write some code?

    I guess my point is bashing Mort is useless and counter-productive. I believe Mort truly wants to use best practices, but there is no way that the Architect will allow this to happen. You see the Architect and Mort are just two sides to the same problem. The only way the ‘solution’ is to come from ‘us’ is for Mort to not tell management and just implement to these practices anyway.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    @Mr. Vain,

    On an unhelpful note, the stuff you’re talking about is why I’ve never liked working in or for big companies. Small companies aren’t immune, but I’ve found them better on the software quality side.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    @Mr. Vain,

    Oh there’s definitely some blame to cast on manager types, but the *solution* has to be from us. We can’t control management, but we can control ourselves.

    1.) We’ve got to make real economic arguments to management on the costs of doing things well versus doing things poorly. I don’t even think it’s entirely a short term vs long term argument. My experience is that even from a greenfield, poor quality work generally slows down development speed within a few months.

    2.) We’ve got to deliver to the business first and foremost. Our credibility improves as our results improve.

    3.) I actually think we can deliver good enough software without taking any longer simply by ratcheting up the skill level. Simple practice and repetition should make the “better” practices more natural to follow

  • Mr Vain

    Instead of placing the blame on Mort for crap software, maybe you should realise that Mort is merely a product of a business environment which wants software as quickly as possible. Businesses generally only recognise short term business value and are not willing to invest upfront in practices such as DDD, TDD, which pay off in the long term.

    I could be classified as a ‘Mort’ and work for a large organisation. I’ve tried to explain the benefits of separation of concerns and TDD but I am ignored either because they do not see the long term benefit, or it’s not a politically expedient decision for someone to make. Software best practises will probably never take hold in large companies because they are not politically ‘visible’ enough for someone to stake their reputation on.

  • http://www.e-Crescendo.com jdn

    @Jeremy

    “we can always do better.”

    Agreed.

    “BTW, I can think of a lot of ways to get carried away with StructureMap and create a horrifying mess. All the worst codebase’s are the product of far more ambition and cleverness than experience and wisdom.”

    Bingo, better put than I could have expressed. And this is where I think a lot of work is needed to be done. If Alt.NET is *just* about making developers better developers, that’s a nice goal, in and of itself, but unless it is tied to increasing ROI (I just used ‘ROI’ in a sentence…my apologies) in a way that is ‘palpable’ (for lack of a better word) to an LOB, then any LOB would be *wise* to look at all this stuff with a skeptical eye.

    Per NDA type stuff, can’t give the examples I would like to necessarily, but have you ever entered an organization where someone tried to introduce (at least) unit testing and maybe TDD, but done it in a significantly sub-optimal way? In a way, it’s almost better to not introduce ‘best practices’ when they are implemented poorly, because it doesn’t deliver what it claims to deliver, and then the message gets killed with the messenger. If you know what I mean.

    To answer Fowler’s “why is this stuff considered alternative” (might not have that exactly right) question, it won’t be when the ‘MSDN way’ includes it. I don’t mean this *at all* to denigrate you or Bellware or Ayende or any of the other gurus out there, but people like Guthrie and Hanselman and Haack are going to deliver this, or it probably won’t be delivered, at least not extensively.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    @jdn,

    There’s foul code everywhere providing lots of business value, but we can always do better. Heck, I know of a certain high flying computer manufacturer that runs their factoring on COBOL with lots of little VB apps that screen scrape the green screen terminals. That’s value, but they could be doing a whole lot better. There’s the opportunity cost thing too. What if you really can write a maintainable app in the same time that you can slop something together with data aware controls?

    BTW, I can think of a lot of ways to get carried away with StructureMap and create a horrifying mess. All the worst codebase’s are the product of far more ambition and cleverness than experience and wisdom.

    @Bob, well put.

  • sergiopereira

    Instant classic. Looking forward to your impressions on the various sessions.

  • http://www.chadmyers.com/Blog cmyers

    Bob:

    You’re right about the 5PM. I try to leave around 5PM, but I don’t consider myself a 501 developer. I think it means that you leave work completely at work and don’t try to better yourself. For example, the stereotypical ’501 developer’ probably doesn’t attend code camps or *NUG meetings or read professional magazines and certainly doesn’t read blogs.

    He may scan CodeProject for a specific solution to something. He may even trip into Ayende’s post on Rhino Mocks and shrug his shoulders and go back to looking for how to deserialize a multi-level dataset from this XML blob he got from the ‘integration team’ down the hall.

  • http://bobondevelopment.com Bob Grommes

    I think it’s a fallacy that best practices are in any way related to whether or not you typically go home at 5 PM. Effective developers using best practices should be pulling *fewer* all-nighters, not more, or I’d question their actual effectiveness. Just because you turn the damned computer off once in awhile doesn’t mean you aren’t competent or that you don’t care. It just means that you’ve got a life.

    Whoever or whatever Mort is, I don’t think we should imply that his level of dedication had anything to do with the hours he keeps, the amount of Jolt he drinks, etc. What I think we decry is probably a lack of curiosity, not a lack of diligence or caring. Incurious people don’t find better ways, and tend to work harder rather than smarter. That’s the true rap. And it’s not even necessarily a rap: how did Mort get that way? Maybe he’s been beaten down by one death march after another.

    I believe that most most Morts will come around when the Officially Blessed tools and “guidance” are in front of them. They are not thought leaders, but they are in the main not stupid. Or at least not any stupider than we pay them to be.

  • http://www.blogcoward.com jdn

    @cmeyers: he’s done that on any number of occasions. And if anyone wants to know if Scott contributes to the community, just go ask him, he will tell you. Nice to get outside confirmation. Alt.NET needs more than Ayende creating screencasts/webcasts by the way.

    Have you ever walked into an organization and thought to yourself “How in the is this company able to make billions of dollars running on this code?” It’s stunning on so many levels.

    But after the 3rd or 4th time, you begin to realize, the LOB that is generating those billions of dollars isn’t necessarily going to care that their code base doesn’t use StructureMap (random example). And they have no reason to care unless they are given a good reason to.

    The ‘MSDN way’, for all the countless reasons it can be criticizes, has helped generate god knows how much money for businesses. The fact that better programming techniques exist, as a practical matter, is going to remain irrelevant in the absense of something more that referencing the GOF.

    And to be clear, I’m all for these better programming techniques. The ones I understand anyway. Wish to high heaven I could use them better. Baby steps.

  • http://blog.rdn-consulting.com/ Bob

    I’m all for new technologies and methodologies that improve the functionality and quality of software. Even if I don’t have a chance to use many or them in my day-to-day work, tracking blogs like this provides me with insights that make me a better developer anyway.

    The use of terms like Mort and ‘501 developer’ is huge mistake though. Think Imus. Not only are stereotypes like that offensive to people like me, but it makes anybody that uses them sound like an idiot. I know that’s pretty harsh. Even though I can intellectualize (and even agree with most) everything you say, as an outside observer that’s how I come away feeling. I bet I’m not the only one either.

    If the alt.net community is really interested in bringing improved software practices to the masses, it should really consider better public relations.

  • http://www.chadmyers.com/Blog cmyers

    @jdn: Scott didn’t say that ‘at the drop of a hat’, it was buried in a long conversation where Scott was lamenting how much time people are spending discussing logo colors and mission statements instead of getting out there and giving talks and spreading the good word. He off-handedly mentioned that organizing conferences and doing TDD talks is a good thing.

    LOB, most likely, doesn’t know that there’s anything better than a 501 developer. In fact, they’re probably frustrated with 501 developers and want the late-night cigarette smoking green-screen eunuch hackers portrayed in the movies.

    This is why managers try to keep male developers away from women, to keep them focused and undistracted.

  • Brendan Tompkins

    “What genius at CodeBetter decided that making a textbox this small was a good idea?!?”

    That would be me. I thought, let’s try small, you know to conserve. If they complain, I’ll give them more. Not much more, but a bit.

  • http://www.e-Crescendo.com jdn

    @Jeremy
    Ah damn, that is disappointing. I still have the post to give me warm fuzzies though.

    @cmeyers
    I wouldn’t agree at all that Scott seems like a horrible person. I find him remarkably inspirational. That he likes to make a point at the drop of a hat about how much he contributes to the community is a little sad, so glad to hear someone else make the point.

    Vaguely on-topic, does anyone else hear the Swedish chef singing “Mort! Mort! Mort!” in his headd whenever this topic is discussed, or is it just me?

    Slightly less vaguely on-topic, LOB values Mort/501 developers and their MSDN ways which is why there are so many of them. Unless/until that value proposition is effectively challenged, not much is going to happen there. Ironically, the MVC framework will probably do that.

    But that’s the topic for a longer blog post.

  • http://www.chadmyers.com/Blog cmyers

    @Troy : No disagreement. You catch more bees with honey and some of Scott’s posts are caustic and the rest are usually above my head.

    But what he may lack in blog courtesy, he makes up for in ass-busting, travel, many presentations, and coaching. He’s better in person, trust me.

  • SteveJ

    MMM….chuys…liquid crack….drool

    Can’t go wrong with deluxe chicken either

  • http://blog.troytuttle.com Troy Tuttle

    cmyers: I’m not talking about how the ALT.NET community got to this point. And my comments are not directed at anyone personally. The topic of Jeremy’s post is how to get this stuff out to the Morts. I look around the ALT.NET blogs and I see examples of good leadership (this post), and examples of poor leadership. An in-your-face approach is not going to encourage the average Mort to investigate these approaches on their own (your experience aside). People have to come to the conclusions themselves.

    Also keep in mind, there is a cultural difference between ALT.NET and the average Mort. That cultural divide won’t be spanned by caustic and rude blog posts. However well-intentioned, that approach will be mostly misunderstood and rejected by the developer masses.

  • http://david-anderson.blogspot.com/ David Anderson

    Nice one, Jeremy. I think that will ultimately be the great contribution of ALT.NET: acting as a vocal and helpful community that aims to increase everyone’s skill, Morts and all.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    @foobar,

    Reading the post, there’s absolutely nothing that says any platform is a solution. Everything in the post *is* talking about raising the level of the people writing the code. It’s obvious that you don’t care for it, but RoR *is* valuable for study because it is built on better design principles. Sure, it won’t help if RoR developers don’t pay any attention to the better practices.

    BTW, if you don’t like RoR, it’s also pretty likely you won’t like the new MVC framework in ASP.Net either.

    Off topic: I’ve always wondered how many clowns like you are running around making inflammatory remarks behind the foobar moniker? Is it just you, or is there a bunch of you? Kinda like the Dread Pirate Roberts?

    Hate to disappoint jdn, but a “foobar” was Bellware & I’s original inspiration for the term BlogCoward.

    “What genius at CodeBetter decided that making a textbox this small was a good idea?!?”

    - take it up with Telligent, and put it in the queue somewhere after getting the caching to keep up.

  • http://www.chadmyers.com/Blog cmyers

    @foobar: While Rails has its problem, there is something about its simplicity, and the culture around it (i.e. test-first, modularity, etc) that produces higher quality results than the current over-complicated typed-dataset from sprocs into GridViews in post-back viewstate WebForms in ASP.NET.

    Rails definitely doesn’t solve many problems, especially for large, highly-scalable enterprise apps, but the pattern it uses for web interaction could be applied to large apps.

    I don’t believe anyone claimed that non-Morts are capable of producing bug-free code. But I think that if you practice TDD religiously, that you will produce substantially bug-reduced code.

    About the Textbox… it’s no small amount of irony that the engine CodeBetter runs on is Community Server which was written, to the greatest extent possible, using the methods and practices frequently poo-poo’d on this site (i.e. lots of data sets, stored procedures for EVERYTHING including simple CRUD, few unit tests, feature-explosion, etc)

  • foobar

    Since when did a half-baked, nigh useless platform like RoR suddenly become the gold standard?

    The problems that RoR “solves” constitute maybe 10% of my work. Sorry, but making trivial CRUD forms isn’t really all that useful to me or my business.

    The issues you bring up (proper OO design, automated builds, etc) are not problems solved by a platform. They are problems solved by people.

    And I still haven’t seen a piece of software written by the non-Morts that was any less buggy or cumbersome than something written by the Morts (case in point: FogBugz. What a piece of junk).

    And how about making this bloody textbox wider? What genius at CodeBetter decided that making a textbox this small was a good idea?!?

  • http://haacked.com/ Haacked

    Your point on RoR is right on! And I think ScottGu addresses that in his presentation when he says, “We want to make it hard to do the wrong thing” (or something like that).

    That’s the great thing about Ruby on Rails, it has a laser focus on good principles and practices. In fact, you kind of have to go out of your way to do some of the wrong things, though by god, it is definitely possible to write crappy code in Ruby.

    I wrote about this in a post a while ago http://haacked.com/archive/2004/05/27/DifficultiesOfLanguageDesign.aspx when I said that developers follow the path of least resistance. The job of language and framework designers is to make that path lead developers to write good maintainable software.

  • http://www.chadmyers.com/Blog cmyers

    Troy: Scott Bellware may be abrasive in some of his postings, but he has done a lot of good things for the community and, interestingly enough, elevated the discussion. He made a point in the Yahoo group about ALT.NET that he’s been out there busting his hump and doing near-free TDD sessions. He’s speaking at DevTeach and numerous other conferences.

    Unfortunately, most of what most of us see is just his blog and he seems like a horrible person. His in your face style may be offensive to some, but don’t diss his contributions.

    I was quick earlier to pile on him for some of his posts, but thinking back, the ALT.NET conference might not have happened without his late nights and hard work and that would’ve been a shame because I, personally, got a LOT out of the conference and it was good to meet all these people.

    I know I owe a lot to Scott. I probably wouldn’t have started using NHibernate (well, at least as early as I did) or Spring.NET if not for Scott and Jeremy and a few others. They’ve helped bring me from a Mort(1) to a Mort(2) and now a Mort(3).

  • Brad Mead

    Thank you.

  • http://blog.troytuttle.com Troy Tuttle

    Nice post. Your statement: “He’s learned the things that have been put in front of him” is the most telling. I don’t think alternative ways of software development are going to make it to the masses unless MS encourages it. That’s why the new MVC framework is so important. It remains to be seen exactly how far MS will go, but the MVC framework is probably the most significant developer-oriented event to happen at MS since .NET was released.

    No matter how many bloggers work the issues, MS is the only institution that can really spread it wide. That’s why it is so important that ALT.NET has more Jeremy Millers (constructive) and fewer Scott Bellwares (caustic). The community isn’t lacking in good ideas. The community is lacking good leadership. When ALT.NET has good leadership, and MS responds to that leadership, then you’ll see the Morts pay attention.

    Otherwise, the Morts are going to fire up their latest RAD tool, and go to work while the ALT.NET blogasphere goes on ranting mostly to themselves.

  • http://blogs.solidhouse.com/david.woods Dave Woods

    Yes there was a lot of mort bashing there and I think this post put things in a really good perspective that “mort is not the enemy” but just another factor in development.

  • http://graysmatter.codivation.com Justice~!

    I am quite fond of the term “Joe Developer”, actually.

  • http://www.chadmyers.com/Blog cmyers

    The problem is, I think the term ‘Mort’ encompasses several different sub-types of Morts. I think when people get angry at the abuse of the term ‘Mort’, they’re thinking of a different sub-type of Mort.

    Rather than posting a long comment on it, I made a blog post (see! I’m trying to blog more!)
    http://www.chadmyers.com/Blog/archive/2007/10/10/its-morts-like-me.aspx

  • Mike

    Can we come up with a new term from us Morts who are waking up from the MSDN way?

    I know a lot of developers who would be classified as Morts (myself included) that would really like to break away from the MSDN way. It’s not a lack of effort, desire or intelligence that keeps us tethered but MS and/or their current employer makes it difficult to break free.

    (I’m really trying to stay away from a Matrix comparison here)

  • Alexis Kennedy

    I have a VB background (though I happen to code in C# right now), no CS degree and I’m not what you’d call passionate about esoteric technical details. I came up the MSDN way. I make no bones about being a Mort. Still, I turned up to the ALT.NET conference. I bristled at a few of the snidier comments about Mort but overwhelmingly, the atmosphere was a friendly and positive one, and I came away with a lot of good stuff.

    You nailed it here:

    “He’s learned the things that have been put in front of him.”

    I did, and so did the vast majority of the developers I’ve worked with. Some of the ‘ALT.NET’ tools and practices I’ve come across are savagely recondite or will need too much investment for me to bother with. But very many – TDD, CI, basic good architectural sense, not using VSS – are (a) straightforward enough for your average developer (including me) to pick up quickly, and (b) give an immediate and sometimes startling return on investment.

    There’s a lot of low-hanging fruit that just happens to grow off the MSDN yellow brick road. Just find a way to point it out to the rest of us and we’ll go for it.

  • http://blog.sneal.net Sneal

    I believe most programmers want to do things a better way, but just don’t know how. Despite how obvious it is to people like you, to most programmers I run into – their clueless about TDD, IoC, NHibernate, SOC, etc. etc. Maybe this is because they’ve been taught there is only one true Microsoft. Maybe these people are just rules based. For this reason I’m super excited about the new ASP.NET MVC framework – people will have to accept MVC as mainstream.

    What’s really frustrating to me is when I run into people who don’t really care about being a better programmer, i.e. writing maintainable code. They’ll only care how fast they can churn something out via cut and paste inheritance.