Sponsored By Aspose - File Format APIs for .NET

Aspose are the market leader of .NET APIs for file business formats – natively work with DOCX, XLSX, PPT, PDF, MSG, MPP, images formats and many more!

Do the right thing. Assuming you know what that is.

I have kind of a love/hate thing going for Roy Osherove’s blog. The "hate" part comes because he always challenges my perspective when I least expect it. Some of his posts seem like they are baiting people and it is easy to discount them as biased based on his position with TypeMock.

But given what I think I know about him, I read these "inflammatory" posts with a different view. That is, as someone who is challenging the view of my personal echo chamber. I read tons of posts extolling the virtues of mock objects and Rhino Mocks. So it hurts my little brain to see someone I respect saying it’s okay to keep your current "creative" design and still be able to test it.iStock_000000185043Small

It starts, "Yeah, whatever. Like I’d ever do that." Then I start mulling it over and grumble to myself, "well, I guess that would have made sense in this past situation", then "actually, that makes sense for quite a few scenarios." Eventually, the train of though leads to my lying on my bed sobbing on the phone with my old employer to apologize for the colourful analogies I made to describe his project when I was unceremoniously let go for rocking the boat too much. Which is an interesting thing to account for when drawing up the timesheet for my current contract.

Anyway, this Roy-love isn’t the real reason for this post but hopefully, you’re used to the hillbilly’s verbose lead-ins.

Roy’s most recent post is another example of one that seemed bound from the beginning to give me a headache just from the title alone. But luckily, it touches on a subject I’ve thought about before, particularly when dealing with the fledgling Bahamian software industry.

I won’t paraphrase because chances are, you’ve read it already but the question it tickled in my mind was, "Are the best practices I’ve adopted over the last two years practical?"

I’ve mentioned this a little before from the perspective of a small application for my family who can’t afford a senior developer should I take up shark-baiting in the near future. And it’s going to be hard to talk about this without sounding elitist so I’ll call up the good will of my 98 previous posts at CodeBetter and hope y’all assume the best.

I took JP’s Nothing But .NET course over a year ago and had an absolute blast. But quite a lot of people struggled with it. Since then, I’ve made a more concerted effort to learn more about things like mocking, dependency injection, the SOLID principles, etc, etc, and so on and so forth. It hasn’t always been easy but it’s been tremendously rewarding. Learning all of it has made development fun again. Plus it’s allowed me to connect with a ton of other people both as mentor and learner. And as a mentor, I’ve seen my share of people struggle with it. Even before I started, I saw a lot of people fight to understand things like AJAX calls, NAnt scripts, even CSS.

By all accounts, these are reasonably bright people. They want to do a good job and are receptive to new ideas. But quite frankly, some of these things are hard. Let no one forget that learning how to properly use mock objects is *not* an easy task and until you "get" them, they will seem like unnecessary overhead. I resisted TDD for many a moon. Even today, it’s still not quite second nature. That’s mostly because I’m stuck in Livelink-land these days which contains code that would make Michael Feathers shake his head in defeat.

imgWhen I entertain these thoughts, it’s usually a battle between "should we cool our heels a bit until we hit the tipping point" and "should we keep going full tilt until the message starts getting across". As Roy mentions in his point, the learning curve is high. Do we keep pushing the learning so that more people get over it or do we lower the learning curve until most people get it, then raise it a little?

I’d like to think we can do the first. The second seems like giving up. And worse, if we start to "dumb things down" in actual projects, it will be that much harder to actually lower the learning curve because no one will be pushing the boundaries. No Fluent NHibernate, no MvcContrib (or even ASP.NET MVC), no StructureMap. We’ve all seen what teaching to the lowest common denominator has done for the North American education system.

Yes, we can put the onus on programmers to "do a better job" but let’s face it, these people have lives. My dad is a land surveyor and my mom was a registered nurse. By all accounts, they were/are very good at their jobs and I remember very few instances of them taking their work home with them or advancing their learning outside of their work. With software development, it is almost expected that if you want to get better, you need to do it on your own time. And when you’re done, you face going in to work to find that the rest of your team hasn’t done their part and thus, are not amenable to the changes you want to make.

So how far can we reasonably push people? The work needs to actually get done and it seems a good chunk of programmers still don’t put any special effort into making code maintainable over the long term. Do we need to change the message? Or the medium? Are user groups and code camps doing their part or simply enforcing the status quo? Is alt.net making a difference or fragmenting the industry? Or simply being ignored?

Will be interested in hearing people’s comments on this as I actually have an over-arching reason for this line of questioning.

Lord Tunderin’ Jayzus, what a friggen essay this turned out to be. Now I gotta go dig up a couple of halfway-relevant images to balance out this tome. Serves me right for thinkin’.

Kyle the Introspective

This entry was posted in Community, Conscientious Coding. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • http://colinjack.blogspot.com Colin Jack

    “My experience with BahaNET shows that there is a whole world of people that simply don’t read blogs, for example. Maybe it’s apathy, maybe it’s because the terminology and sheer numbers of opinions are overwhelming, maybe it’s because they don’t see the need because they’re getting along fine.”

    I agree, I’m not at all sure how you’d reach them and even if you do I’m not sure they’d respect your opinion.

  • Kyle Baley

    These comments are great and do address an ongoing problem insomuch as software development is hard. But I’m referring more to the people that *aren’t* learning about O/RMs and dependency injection and TDD. Is it practical to talk about Inversion of Control if people’s eyes glaze over before you get to the containers?

    Scott brought up (in paradoxically heady language, I might add) the tendency toward terminology which allows an awesome shorthand to those who either know it or have the curiosity to learn it. I’d wager that these are the minority. Ryan, Joey, and Chris (and me) are already at an advantage because they’re bothering to ask questions and seek out the answers.

    My experience with BahaNET shows that there is a whole world of people that simply don’t read blogs, for example. Maybe it’s apathy, maybe it’s because the terminology and sheer numbers of opinions are overwhelming, maybe it’s because they don’t see the need because they’re getting along fine.

    Or maybe it’s just because the first three letters in the country’s name is Bah!

  • http://www.techfocus2.com Ryan Kelley


    I think a lot of us developers learn in a lot of the same ways, for me it is very similar to you, a good book, some discussion forums on the internet, etc.. and mostly, write some code and make it work.

    I think the biggest problem I see is there really isn’t a roadmap that says start here and end there. Granted this type of thing is hard to develop as often as things change. But it would be nice to know for example. If you want to learn about Dependency Injection you should first read up / learn about X, Y, and Z.

  • http://colinjack.blogspot.com Colin Jack

    @joey @ryan @chris
    So my question for you would be what format would you think would be useful for future information?

    For me to learn something I like to have a book and a discussion forum to bounce questions/ideas off but I’m not sure if this is the way everyone tackles it.

    Sometimes I think that we need to do more of what Fowler does, take a topic and provide more about advantages and disadvantages as often I feel like I only understand a technique once I understand weaknesses and alternatives.

    “Focus on one area and become really good at it, then move to the next step. If you start jumping between stages, you will only confuse yourself and not learn the core.”

    Couldn’t agree more, this is exactly the way I learn.

    Great post and comments from Scott are as always interesting and thought provoking.

    “That is, as someone who is challenging the view of my personal echo chamber. I read tons of posts extolling the virtues of mock objects and Rhino Mocks. So it hurts my little brain to see someone I respect saying it’s okay to keep your current “creative” design and still be able to test it.”

    On this particular topic, best way to know whether you think Roy is right is to try TM.

    Personally I’ve used TM and RM for about 2 years and I have to say that if TM was free I’d use it all the time..

    Flexibility in your designs is great, I love IoC/DI but sometimes you’re just introducing interface-implementation pairs by rote (especially when the implementations are nice small SRP classes) and that’s when I think it seems worthless to people.

    Always using IoC/DI/mocking is fine too, we just need to keep open minded which is something that as a group ALT.NET seems to find very hard (though I totally understand why, because mixed messages are exploited by people who just don’t value design at all),

    ” Even before I started, I saw a lot of people fight to understand things like AJAX calls, NAnt scripts, even CSS.”

    My eyes boggled reading this, CSS is the most complex voodoo in the world of software. Gives me the heebie jeebies :)

  • http://weblogs.asp.net/jvano joey

    +1 for post
    +10 for comments

    It is difficult when you are staring at the mountain of becoming a better developer as Chris mentioned. There is _soo_ much information about in the blogosphere, internet, books, etc. You have to filter soo much noise and who knows what that person may come out with. Their perception of those materials could be skewed.

    I personally took baby steps: OOP, Design Patterns, Mocking, DI, TDD, build scripts. Focus on one area and become really good at it, then move to the next step. If you start jumping between stages, you will only confuse yourself and not learn the core.

  • Kyle Baley

    Chris and Ryan,

    Yeah, that’s another side-effect. Everyone has an opinion and it’s hard to determine whose is “right”, whatever that may be. And even then, reading blogs probably makes matters worse. It’s hard to teach in the span of a few lines of text aimed at the masses. Props to Jeremy Miller’s Build Your Own Cab and Karl Seguin’s Foundations of Programming series for being exceptions.

    I’m realizing that in order to truly reach/teach people, you need to be a little more drastic in your approach. More on that later.

  • http://www.techfocus2.com Ryan Kelley

    i whole heartedly agree with what Chris said above. I have been developing software for several years and I really do “get” OO principles and most design patterns, but TDD, Agile, lean, ORM, etc… are new concepts and it is overwhelming when you feel like you are out of the loop and there are so many developers it seems (via blogs and internet) that are “experts” on all of these topics.

  • Kyle Baley

    Oh, I’ve realized that long ago. I admit freely that a healthy part of why I do what I do community-wise is because of the rush. And that I spend too much time worrying about how my peers will react rather than someone who might actually benefit. It’s kind of disheartening in a way and I can justify it to a small degree by claiming that the rush comes from connecting with an audience but there’s always the nagging feeling that I’m doing things for my benefit more than theirs.

    Of course, there’s benefits to that nagging feeling but I’ll get to those before the year is up. You also talk, in your own (thankfully) inimitable way, about the failure of alt.net. I agree with your arguments but the optimist in me prefers a different conclusion.

    I think you’re right that the group is pre-disposed to the topics. But doesn’t have to be a bad thing. The discussions still need to happen, yesno? Without discussions on NHibernate and fluent interfaces, we don’t get Fluent NHibernate. Without IoC and MVC conversations, there is no MvcContrib. Whether or not, you think these are valuable projects, I still like that they exist at all.

    That still leaves us with a problem of how to talk to people that just want to get a job done the best way they can. Ultimately, what would be nice is more alt.net – real-world translators.

  • Chris

    As someone who is just starting “to get it” when it comes to better programming, the difficulty is the amount of material to learn.

    Before, it was enough to have the code in the code behind, compile, test and deploy. Going from in-line SQL to using stored procedures was a big thing. But we all know the huge headaches this amateur approach to development can lead to.

    So, I started my journey to become a better developer. The only problem… I quickly found there was SOOO much to learn. From learning to use OO principles, to design patterns, to IoC, ORM (currently NHIbernate), unit testing, mocking, CI, build scripts, the list goes on and on. Needless to say, this is a lot of information for a developer to become comfortable with, much less become really good at it. I was quickly overwhelmed and didn’t really know where to start.

    I do a lot of my learning after the wife and kid have gone to sleep. I read a lot of blogs, a lot of books, I practice what I learn. It takes a lot of time. But I do it because I want to be a better developer, because I care about the applications I write. I do it because I want to make my job easier in the future instead of harder.

  • http://scottic.us Scott Bellware

    The learning curve a few influential factors, including: the topic, the student, and the teaching. It’s not a fixed line. Change one of the factors and the curve changes. It’s still a curve, but the variation doesn’t have to be egregious.

    ALT.NET is largely ineffective as a countermeasure because it’s a community of people who either already know the topics, or who are predisposed to the topics. The curve is flatter for alt.net folks because the “student” factor flattens the curve.

    ALT.NET is largely ineffective as a countermeasure as well because its people, being mostly naturals to the subject matter, haven’t stopped to do usability analysis on the materials it offers to the community. ALT.NET is doing what programmers everywhere do: it’s creating poor user experiences (in this case, in learning) by not getting out of its own context to get some perspective on how any teaching is being absorbed (or not absorbed).

    The conversation with Roy is an excellent example of not getting the message across and creating insoluble user experiences. ALT.NET folks continue to talk about testability and SOLID without expressing why these optimizations are inherently worthwhile, and Roy is rightly refuting ALT.NET claims that testability and SOLID are inherently better.

    We’re so focused on communicating the lexicon that we can barely communicate essential meaning, and without communicating essential meaning, no amount of compelling terminology is going to carry the message.

    There are simply people in the world that don’t care about terminology. We have yet to accept this at large and to begin to shape teaching and communication around this stark reality, a reality that stands in opposition to the very things that give us a tremendous amount of professional pleasure.

    Teaching other people how to do software design means that we have to break our addictive dependency on the constant self-stimulation we get we get from hearing our own voices roll on over our favorite terms.

    When we realize that we’re often more focused on self-stimulation rather than the stimulation of students, things will start to change. Until then, it’s just a bunch more intellectual group masturbation, both from ALT.NET and from Roy. As representatives of their positions, they’re both missing the mark for chasing after manifestations rather than putting more thought into root causes.