DaedTech

Stories about Software

Mar
16

By

Two Flavors of Technical Opportunists: Missionaries and Mercenaries

Category: The Life of a Programmer Tags: , , | 7 Comments

“Missionaries and mercenaries” has a pretty intriguing ring to it, huh?  I wish I could claim credit for it, but I heard about it on this podcast with Ribbonfarm creator Venkat Rao.  Apparently, entrepreneurs use this pithy phrase to make a distinction among themselves.  I’ll explain in more detail shortly.

First, however, I’d like to do a bit of explanatory housekeeping.  In the coming months, I’m going to make some changes to my life.  Specifically, I plan to wind down the management consulting in favor of creating content (products) and offering productized-services.  This may sound a little crazy to you.  It would have sounded crazy (or naive) to me up until a few years ago.  Why trade a high profile consulting career for… an unknown?  So I want to explain myself before I lose sight of the fact that I might need to explain that to people.

On “Trading Hours for Dollars”

I’ll tell a quick story to clarify.  A few years back, I’d decided to leave a CIO position in favor of consulting as a free agent (which may also sound crazy, but it worked out).  As I looked to build my book of business, I was chatting with fellow Pluralsight author John Sonmez about the jump he had made away from full time employment.  He said something during that conversation that I’ll never forget, when I asked him about how he finds consulting work.

“To be honest, I’m trying to get away from trading hours for dollars.”

When you listen to the podcasts I listen to, read the books I read, and talk to the people I talk to, you’ll hear this a lot.  At the time, however, I had never heard anyone say that.  I probably replied with something noncommittal like, “oh, that’s awesome, man.”  Meanwhile, I recall thinking to myself, “I don’t even… wat?”

These days, I completely get it.  Back then, I didn’t.  And so I want to start bridging the gap before the curse of knowledge consumes me and I just assume that everyone shares my perspective on hourly work and the corporate condition.

Developer Hegemony launches on May 2nd, and people have been asking me what comes next.  Well, among other things, I plan to pursue a line of business wherein I help support people executing their plan to achieve developer hegemony.  But before I can do that, I have some mental groundwork to lay.  And that brings me back to missionaries and mercenaries.

Opportunist Escapees

If you’ve only recently come to read my blog, understand that I mean something deeper than the dictionary definition when I talk about “opportunists.”  I explain in depth in this post, but this graphic should suffice.

Most simply, opportunists are those who maneuver their way to the top of the pyramid-shaped corporations.  The C-suite consists exclusively of these folks, but you’ll also find them at all levels of the organization.  I think of those working their way up as “ascendant opportunists.”

But wherever you find them in the corporate hierarchy at the moment, you’ll find that all of them have ceded good faith with the organization.  In other words, opportunists ascend rapidly by coming to understand the essential bankruptcy of the corporate advancement narrative.  They arrive at their positions and status through the lonely recognition that the normal corporate rules are for the idealists and pragmatists around them.  They chuckle internally, behind a careful poker face, at the notion that companies can have such things as “missions” and “values.”

If you really want to dive deep into the psyche of the opportunist, my book talks about this archetype and the other players in detail.  For our purposes here, I want to talk about what happens to these players when they exit the game.  (And make no mistake, they’re the only ones who ever do this side of retirement.)  What fates await opportunists that exit pyramid-shaped corporate life?

Read More

Mar
14

By

So, You’ve Inherited a Legacy Codebase

Category: The Life of a Programmer Tags: , | 24 Comments

Editorial Note: I originally wrote this post for the SubMain blog.  You can check out the original here, at their site.  While you’re there, have a look around at some of the other posts and sign up for the feed.

During my younger days, I worked for a company that made a habit of strategic acquisition.  They didn’t participate in Time Warner style mergers, but periodically they would purchase a smaller competitor or a related product.  And on more than one occasion, I inherited the lead role for the assimilating software from one of these organizations.  Lucky me, right?

If I think in terms of how to describe this to someone, a plumbing analogy comes to mind.  Over the years, I have learned enough about plumbing to handle most tasks myself.  And this has exposed me to the irony of discovering a small leak in a fitting plugged by grit or debris.  I find this ironic because two wrongs make a right.  A dirty, leaky fitting reaches sub-optimal equilibrium and you spring a leak when you clean it.

Legacy codebases have this issue as well.  You inherit some acquired codebase, fix a tiny bug, and suddenly the defect flood gates open.  And then you realize the perilousness of your situation.

While you might not have come by it in the same way that I did, I imagine you can relate.  At some point or another, just about every developer has been thrust into supporting some creaky codebase.  How should you handle this?

Read More

Mar
12

By

The Case for a Team Standard

Category: Language Agnostic Tags: , , | 2 Comments

Editorial Note: I originally wrote this post for the SubMain blog.  You can check out the original here, at their site.  While you’re there, check out CodeIt.Right and give it a try.

In professional contexts, I think that the word “standard” has two distinct flavors.  So when we talk about a “team standard” or a “coding standard,” the waters muddy a bit.  In this post, I’m going to make the case for a team standard.  But before I do, I think it important to discuss these flavors that I mention.  And keep in mind that we’re not talking dictionary definition as much as the feelings that the word evokes.

First, consider standard as “common.”  To understand what I mean, let’s talk cars.  If you go to buy a car, you can have an automatic transmission or a standard transmission.  Standard represents a weird naming choice for this distinction since (1) automatic transmissions dominate (at least in the US) and (2) “manual” or “stick-shift” offer much better descriptions.  But it’s called “standard” because of historical context.  Once upon a time, automatic was a new sort of upgrade, so the existing, default option became boringly known as “standard.”

In contrast, consider standard as “discerning.”  Most commonly you hear this in the context of having standards.  If some leering, creepy person suggested you go out on a date to a fast food restaurant, you might rejoin with, “ugh, no, I have standards.”

Now, take these common contexts for the word to the software team room.  When someone proposes coding standards, the two flavors make themselves plain in the team members’ reactions.  Some like the idea, and think, “it’s important to have standards and take pride in our work.”  Others hear, “check your creativity at the gate, because around here we write standard, default code.”

What I Mean by Standard

Now that I’ve drawn the appropriate distinction, I feel it appropriate to make my case.  When I talk about the importance of a standard, I speak with the second flavor of the word in mind.  I speak about the team looking at its code with a discerning attitude.  Not just any code can make it in here — we have standards.

These can take somewhat fluid forms, and I don’t mean to be prescriptive.  The sorts of standards that I like to see apply to design principles as much as possible and to cosmetic concerns only when they have to.

For example, “all non-GUI code should be test driven” and “methods with more than 20 lines should require a conversation to justify them” represent the sort of standards I like my teams to have.  They say, “we believe in TDD” and “we view long methods as code smells,” respectively.  In a way, they represent the coding ethos of the group.

On the other side of the fence lie prescriptions like, “all class fields shall be prepended with underscores” and “all methods shall be camel case.”  I consider such concerns cosmetic, since they concern appearance and not design or runtime behavior.  Cosmetic concerns are not important… unless they are.  If the team struggles to read code and becomes confused because of inconsistency, then such concerns become important.  If the occasional quirk presents no serious readability issues, then prescriptive declarations about it stifle more than they help.

Having standards for your team’s work product does not mean mandating total homogeneity.

Read More

Mar
9

By

Considering a Port to .NET Core? Use NDepend

Category: .NET Tags: |

Editorial Note: I originally wrote this post for the NDepend blog.  You can check out the original here, at their site.  While you’re there, take a look at the latest version of NDepend, with extensive features around technical debt measurement.

An American colloquialism holds, “only two things are certain: death and taxes.”  If I had to appropriate that for the software industry, I might say that the two certainties are death and legacy code.  Inevitably, you have code that you have had for a while, and you want to do things with it.

Software architects typically find themselves tasked with such considerations.  Oh, sure, sometimes they get to pick techs and frameworks for greenfield development.  Sometimes they get to draw fancy diagrams and lay out plans.  But frequently, life charges them with the more mundane task of “figuring out how to make that creaky old application run on an iPhone.”  Okay, maybe it’s not quite that silly, but you get the idea.

If you earn a living as an architect in the .NET world, you have, no doubt, contemplated the impact of .NET Core on your application portfolio.  Even if you have no active plans to migrate, this evolution of .NET should inform your strategic decisions going forward.  But if you have use for deploying the framework along with your application or if you want to run on different operating systems, you’re going to need to port that legacy code.

I am, by no means, an expert in .NET Core.  Instead, my areas of specialty lie in code analysis, developer training, and IT management and strategy consulting.  I help dev teams create solutions economically.  And because of this, I can recognize the value of NDepend to a port from what I do know about .NET core.

Read More

Mar
7

By

Expert Beginners Rendered Obsolete

Category: The Life of a Programmer Tags: , | 8 Comments

I got an awesome tweet at the Expert Beginner twitter account the other day.  Omer had one of those “wow, I can’t believe I never thought of this myself” ideas.

Yes, please.  Up until this point, I have run this account as a solo effort.  But I certainly have no exclusive claim to some of the world’s worst wisdom delivered with some of the world’s most confidence.

So I am now accepting submissions via twitter DM.  Please send them my way, and I will curate, catalog and queue.  As my work becomes increasingly remote and reclusive, I need all the fodder I can get for the account.

Speaking of Expert Beginners

In case you followed this blog only recently, I’m talking about a phenomenon that started with this post.  You know that one job you had once?  It lasted a year and a half, but seemed like 12.  It dragged because of the senior principal architect on the project.  Courtesy of random name generator, we’ll call him Dale.

Dale eschewed popular frameworks because he once wrote this combination ORM-MVC platform back in 2004 and, in his mind, it’s still chugging along nicely.  This framework set the world record for depth of inheritance hierarchy at 124, per your last count.  Every time you wanted to add a column to some table in a CRUD app, Dale would have to come over and perform open heart surgery at your desk while you tried to read XKCD on your phone without his notice.  But should you ever go off on your own and download something like an actual ORM, Dale would go completely nuclear.

In Dale, we have a classic Expert Beginner.  You put up with him for as long as you could before moving on to greener pastures, but you’re pretty sure he’s still there, jamming his tortured framework into some already-doomed CRUD app.

Dale will tell you what’s wrong with so-called professional ORMs.

Anyway, as I decided to throw the satirical account open to public suggestions, I began to contemplate this older concept of mine against the backdrop of some newer ones.  (Can you believe this dude is 5 years old, already?)

Expert Beginners and Developer Hegemony

Specifically, I started to think about how the relatively simple profile of the Expert Beginner has aged.  In the years between his birth on my blog and the recent completion of my book, Developer Hegemony, I’ve spent a lot of time and mileage consulting.  In particular, I have done a good bit of training and management consulting following a stint as a technical executive.  This has furnished me with the office politics equivalent of language immersion.

I began to wonder about the fate of the expert beginner in the world of developer hegemony that I foresee.  I mention him some in the book, kind of in passing.  But what will actually come of him?

Read More

« Older Posts
Newer Posts »