Helltime for April 3

Announcer: Now for quick hits and commentary on software development topics from around the web, the EIP web-ring brings you the stigmatized spawn of a refactory, MoffDub, and Helltime!

  • chromatic writes about How to Ruin Your Ability to Release Software, and mentioned bug trackers, bug counts, and bug severities, and I was surprised when I found these terms to be quite quaint.

    Quaint? Bugs are unavoidable. Yet, during our sprints, when problems come up, they are logged as issues, and almost as quickly as they are logged, they are fixed. The code is built the next day. Until then, our servers are patched and restarted in a matter of minutes. As mysteriously as they arrive, they leave. How could this be?

    I shouldn’t be surprised, since our metrics indicate that, as an organization, we write Space Shuttle-quality code. I’m talking about less than 1 defect per KLOC. On the other hand, I’m surprised to be a part of it.

    I’m not going to say that the reason is the agile process, because I don’t think it is. Rather, I think it is due to near-constant testing efforts. When we are in the requirements phase of the sprint, our testers are writing test cases. As soon as unit and integration tests are done for a story, our system, acceptance, and performance testers jump on the feature, and they’re relentless.

  • Uncle Bob‘s post on software craftsman teams made me mix myself a white Russian early this evening:

    Why should a young aspiring software professional spend four years and $200K+ to attend an institution that will teach them less about their chosen profession than 3 months of working on a real project with talented mentors?

    I ask myself this every day as I pay off my student loan.

    Fortunately, I was part of a paid internship program at my college. Uncle Bob is correct about how much you learn out in the field. What he didn’t mention is how much more fun it is than being a student, with the constant specter of assignments, exams, and moron professors hanging over your neck like a guillotine.

    Uncle Bob’s though experiment places a 20-year veteran coder with a few 5-year journeymen supporting him, and each journeyman has 3 wet-behind-the-ears apprentices fresh out of high school. The master writes the most code, and it is highly architectural in nature. Journeymen write the rest of the code, optionally farming some of it out to apprentices so they can learn.

    Now doesn’t it sound like the master is an architect who codes, the journeymen are full-time developers, and the apprentices are co-ops?

  • Rounding out Helltime is Misko Hevery‘s expoundment of Collaborators versus Factories. Essentially, factories create all your collaborators (classes that you use).

    While this is not anything new from DDD factories, what I found interesting is how factories are special because they know about the internals and dependencies between the objects they’re creating. And I’m starting to think that they are not subject to all of the code smells that collaborators are held to. More on that in a later post!

Announcer: You’re reading the EIP web-ring.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

%d bloggers like this: