Skip to content

Modeling Risk (Part 4) – Putting It All Together

In this, the final installment of the Modeling Risk series, we going to put together everything we covered in the previous installments into a unified risk model.

risk

In part one we learned about Client Risk: risk that clients bring when they walk through the door.  Based on attributes such as the ability to make decisions, relative insensitivity to price and technology agnosticism, clients can either be part of the problem or part of the solution when it comes to managing risk.

In part two we learned about Structural Risk: risk that is derived from how the team is structured – whether they are familiar with each other, a common process, the tech or the client.  In some ways this type of risk is learning curve risk, because it models how many learning curves are piled onto the project.

Finally, in part three we learned about Qualitative Risk: risk that is driven from the quality of the team, the technology and the support for the team.  The better these things are, the more curve balls they can handle, and the more they can cope with risk from the other vectors.

From each of these three aspects of risk we derived an overall letter grade: from A to F.

Putting it All Together

Here’s how the letter grades combine:

Low Risk: All A’s and B’s

This is a good to great project with minimal risk.  In this range you can count on projects staying on track, and arriving where they are supposed to within budget, on schedule and at a level of quality that will satisfy everyone.

Medium Risk: One or Two C’s

This is a project that has a combination of a relatively problematic client, an immature team, or mediocre quality issues.  It is possible to succeed in this space, but it requires a close watch and quick action to mitigate the problems that inevitably will come up.  The success of the project depends on at least on of the three areas being better than the “C” level – the strength that can hold up the project.

High Risk: Three C’s or One or Two D’s

This is a project that, from its onset, has a good chance of going bad.  Either there is no strong area that pulls the project up to the medium risk level, or there is one or more areas with real problems: a truly high risk client, an immature team or poor quality from the team, the technology or the team’s support system.

Despite the best risk-mitigating activity from management, there is still a good chance that this project will go wrong.  It would be  a sound decision to walk away from such a project, but if taking it on is necessary, then it should be approached extremely defensively, as there will inevitably be serious crises as the project progresses.

Lead Balloon: One or more F’s, or 3 D’s

This is either a project with an impossible client, a disastrous team, or a catastrophic quality issue; or it is a project that is merely poor in all three areas.

Generally speaking, it is not possible to be successful with such a project.  The presence of the F will sink the project on its own, or the general malaise of the 3 D’s will accumulate into a disaster.

A project at this level needs a fundamental reset: generally either the client or the team has to go, depending on the source of the problems.  Risk mitigation at this level will be overwhelmed.

Conclusion

So there you go – my general theory of project risk.  I hope that you find it helpful, and through it gain a greater understanding of why projects succeed and fail, and when to plunge ahead, and when to run the other way.  Good luck!

Posted in business, programming, web agency.

Tagged with .

No comments

By loren – August 19, 2009

Modeling Risk (Part 3): Quality

The plot so far:  there are specific things that cause project’s to fail, beyond the abilities of seemingly competent people to control.  These forces aren’t random, they are specific patterns and antipatterns that create accumulating risk that bears down on projects like debt.

In Part 1 we discussed client driven risk – the problems that clients bring to the table and how they affect the project.  In Part 2 we discussed structural risk – risk that originates with the composition of the team working on the project.

The third and list type of risk I call Qualitative Risk.  This is a kind of risk that is affected by the quality of the tools and people executing the project.  Everything counts, everything matters.  Quality affects the project.

There is a school of thought in business that would dearly like to factor quality out of the equation.  Businesses that trade in commoditized markets, competing on price, basically operate on the supposition that there is a standard level of quality and that it is not a distinguishing characteristic.  The movement towards off-shoring software development included an attempt to factor out quality.  Command-and-control programming languages like Java and .NET are attempts to engineer developer quality out of the equation – at least partially.

Quality, however, matters.  The web development framework you choose will affect the project, positively or negatively.  The skills of the developers you hire will affect the project.  It is not just subjective, some of these things are actually better than others.

I break Quality factors down into 3 main pillars: Team, Tech and Support.

Team: How strong is the team?  My feeling is there should be at least 1 really good senior developer for every 3 medium or junior developers on staff.  In addition, it is good to have at least a couple of honest-to-goodness rock stars around – the people who can be thrown against any technical challenge and still land on their feet.  The bar should be set at a level where the team can be counted on to astonish you on at least a semi-regular basis.

Tech: How good is the tech on which you’re building this thing?  Does it provide features that you need?  Does it provide a means of accelerating custom development, in case you need to go outside those features?  How often is time spent using the technology solving actual business problems, as opposed to just servicing the demanded ceremonies of the technology?  When is the technology enabling you, and when are you fighting it?

Support: The infrastructure: managerial, administrative, legal, HR etc., that surrounds the team – how much is it helping?  Is HR effective in finding new talent?  How about support from IT?  Is it straightforward to get ticket systems, continuous integration servers, new virtual servers etc. set up?  Or does every request take forever, with the development team resorting to circumventing the company infrastructure?  Does management back and support the development team, or are they selling them up the river?

Each of these pillars is deep and complicated, so grading them is a little abstract.  However if you set an aggregate grade for each pillar and take the average you’ll get a sense of the qualitative risk associated with the project.  Again, starting about the C grade and intensifying as you drop below that, you can easily get to a level of unacceptable risk.

In the next and final installment of this series – we’ll look at putting all the various risk factors, client-driven, structural and qualitative, into an overall risk profile.

Posted in programming, web agency.

No comments

By loren – August 6, 2009

Modeling Risk (Part 2)

In part one we had a look at risk that comes to the project from the client, before it even starts.  This time we’ll look at risk that comes from the composition of the project and the project team.

I like to call this second category Structural Risk, because it has to do with how a project is structured: the parts that make it up.  Again, to take the positive angle – each point below is listed in its non-risk-adding, positive side:

  • The team has worked together before. The team itself is a known quantity, with the individual talents and personalities of each team member known to the group.  This knowledge allows team members to guide the project to leverage the various strengths and avoid the weaknesses of the individuals on the team, working together to achieve the highest level of productivity.  Also hopefully people like and respect each other.
  • The team knows the technology. It is a technology that the team has worked with before – they know how to work with it rather than wind up fighting it.  They are unlikely to be surprised by strange quirks of the tech stack that creep up at the most inopportune times.
  • The team knows the client. The team has worked with this client before, and therefore knows the business problems that intersect their space.  This way they will be less likely to make poor assumptions about how things are supposed to work.  Functional specs are great, but they don’t take the place of actual domain knowledge on the part of the team.
  • The team has a methodology for staying on track. Without getting into the comparative merits of individual development methodologies, the main point is that the team has a way to prioritize, track progress, and correct problems early on.  A team that can’t tell that it’s off-course can’t correct.
  • The team can effectively communicate to management, and vice-versa. The cliche is that management understands different levels of priority for requirements, but sees all cost of implementation as equal.  Developers see different costs of implementation, but imagine all requirements to be equally important.  Neither is true, of course, and there needs to be an effective channel for technical and business stakeholders to properly communicate with each other.  A Tech Lead can be an effective method here.

Note that none of this discusses the individual experience or quality of the members of the team.  This is structural.  Process and management – all about getting people to speak with each other, and work well together.

Again 1 point for each “yes” answer for your team, just like in part one.

5 points: A. Your team knows each other, the client and the means to success like the back of their hand.  You’ve probably already made the mistakes you are going to make, so you can count on solid execution from people.

4 points: B. Still solid.  B is as good as a team can get with a new client (and at least in agency work new clients are frequent).  B is structurally still a good risk, but can occasionally throw up a surprise or two.

3 points: C. Medium risk.  At this level there is at least some degree of immaturity in the team – it may reflect new hires, or the creation of a new team where there wasn’t one before.  The team is still working out the kinks in their process.

2 points: D. This is an immature team.  There are enough unknowns going on at this level that the team can easily trip over itself, adding significant risk to a project.  Watch out.

1 and below: F. The team is not ready for this project.  The structural problems will create a significant negative impact on the project, probably leading to some level of failure.

To be concluded in part 3, where we’ll look at qualitative risk, and how to combine all the risk factors together into a single model.

Posted in business, programming, web agency.

Tagged with , .

No comments

By loren – August 1, 2009

Modeling Risk

Why do some software / web projects run off the rails so badly?  Are we just incompetent?  Is it that the very practice of programming is so incredibly difficult that it defies any attempt to manage it?  Perhaps software development is just an inherently terrible idea, and we should leave it up to Microsoft to handle, and focus on other things, such as selecting the best clip-art for our PowerPoint slides.

Okay, no one buys that exactly, but there is a certain amount of seeming randomness in software or web development that makes developers and managers both very, very nervous when entering new endeavors.  Everyone knows from past experience that even with the best of intentions, things seem to occasionally go terribly wrong.

I’d like to suggest that things happen for a reason, however.  In the case of software development projects, there are specific patterns and phenomena that drive projects towards success or failure, and that learning to recognize those patterns can lead one to manage them much better.

In fact I would take that one step further, and say that these patterns can actually be modeled, and together form a bit of a magic 8-ball on what’s likely to happen with the project.

Clients

Many software development projects have clients involved, and for many of them the problems start right there.  Clients present an extremely powerful influence over projects, because if they are not happy, there is no business.  Clients do not always act in their own best interests however, or the best interests for the project.  Therein lies the rub.

I’ve identified a specific set of criteria that identifies good clients.  Clients with these attributes are good, those without them are bad.  Howe much risk a client brings to a project depends on how many items on this list they rate.

  • Strong decision maker: Is there someone (much preferably an individual person) who can make decisions in the client organization?  Or is there a distributed set of stakeholders, all with different agendas, values and visions about what the product should be?
  • Reasonably Insensitive to Price: Does the client appreciate the value of what they’re getting?  Or do they just want to slash, slash, slash prices and get the cheapest possible version of their site?  Do they argue over every last nickle and dime?
  • Technology Agnostic: Tech matters.  Anyone who says differently is ignorant or lying.  The choices of hosting, frameworks, platforms, products etc all compound and add or remove risk from the project.  Good clients are ones that allow and encourage the best tools for the jobs to be used.  Bad clients come in the door with corporate technology mandates that have nothing to do with the specific interests of the project.
  • On a Reasonable Deadline, but Flexible on Scope: Projects need schedules in order to happen, but the uncertainty baked into programming demands that something in the classic project management triangle flex, and the best thing to flex is scope.  When there is a clearly prioritized set of features on the table, the upcoming release may or may not have certain features, or they may be implemented at a number of different levels of complexity.  Hard features of limited business or user value should be jettisoned.
  • Savvy: Good clients know their own business, the Internet and so forth.  Clients that require teaching on every last point that intersects the project slows things down, and opens the door for them to make bad decisions.  A client that is reasonably well educated on their space and how it relates to the project will be much less off than others.
Grading

For your client, award 1 point for each of the above criteria.

5 points: A. Run, don’t walk and get this client’s business.  They are extremely rare and can be the basis of an excellent partnership in which you can do great things.

4 points: B. A good, run of the mill client.  Will occasionally do something bothersome, but well within the parameters of something that can be managed for success.

3 points: C. Fair.  This is starting to get into the range where client risk can adversely affect the project.  If it is combined from risk from other factors, failure can occur.  Nonetheless it is possible to succeed with a C client.

2 points: D. Not good.  This is a high-risk client, and this kind of work should only be taken on if painstaking steps are taken to protect the team from bad influences and decisions made by the client.  A large amount of time will be spent on keeping this client under control, and preventing them from damaging the project.  It better be worth it.

1 and below: F. This client brings disaster with them.  It is almost impossible to succeed with this kind of client, and it usually isn’t worth it.  They will be a never-ending source of problems, and will compel bad decisions that will most likely derail the project.  Avoid.

Continued in part 2, when we’ll look at some of the other risk factors that bear on a project.

UPDATE: Okay, so I covered some of this before, but this is part of the model, so its sort of from the opposite tack.

Posted in business, programming, web agency.

Tagged with , .

No comments

By loren – July 25, 2009

Obligatory Whining About Not Posting

Yes, this is my blog. No, nothing has happened here for some time.

About 11 months ago I became the Director of Technology for HUGE. This took a lot of my brainpower over, and the most immediate casualty was Antipatter. Mea culpa.

I’ve made fun of well meaning friends who have, in the past, spent a lot of time developing their own blog software, but haven’t really posted much. Of course they are now kicking my butt.
Then I became tired of the brown theme, and have spent too much time screwing around with the look and feel. That needs to change, but not at the expense of posting.

Finally, Twitter enables laziness in blogging on my part. Instead of developing an idea enough to blog it, it’s really easy for me to knock out 3 or 4 tweets that capture the barebones essence of my point. This is just lame.

So while I can’t really promise a particular frequency of posting here, I will do my best to put something up once in awhile. I’ve certainly had thoughts that could have gone up here in the last year, it’s just a matter of capturing them and getting them posted.

Posted in meta.

No comments

By loren – July 18, 2009

Golf Course Technology

Why does enterprise technology suck?  Oh yes, of course, it has lots of features, far more than smaller, more compact versions of the same kind of technology, and additionally it often has hooks that allow IT departments to manage it in large deployments (I’m typically thinking about features such as Single Sign On).  And typically, but not always, it’s built to scale: many users, much data, many processors etc.

However it also typically sucks.  Sucks balls.

You’ll Eat It, And You’ll Like It

The basic mechanic underlying enterprise software sales is that the person making the purchasing decision doesn’t have to actually use the stuff.  Image, if you will, a hypothetical golf course where your CEO and the vendor’s CEO are playing a game.  A deal is being made.  Backs are being mutually scratched.  Soon you will be using the vendors stuff, regardless if whether it’s the best fit for the problem.

In this scenario the software is just a transaction.  Money moves hands, brownie points are earned, and a solution is tossed at a not-particularly-exciting internal logistics problem.  Whether its the best fit for the problem, and certainly whether its a good tool, are simply not considerations.  Interestingly, a lot of this is driven by the people at the top – if, for example, they don’t have to actually directly deal with a payroll system, they’re unlikely to care much about its user interface.

Faces of Lame

Speaking of user interface, that’s usually the first victim to be sacrificed with enterprise software.  User interfaces on enterprise are software are typically, oh how shall I put this, fugly as all hell.  Three things drive this: the first is the hypothetical golf course described above, the second is that every time a new feature is added to software the load on the ability of the user interface to represent it increases.  More features mean it’s increasingly difficult to represent well on a UI. Finally, there is a strange inertial “lowering of the barre”, in which the propagation of lame enterprise user interfaces has essentially made it okay for others to not even try.

Just One More Wafer-Thin Mint…

Another problem with enterprise software is feature bloat.  In a race to stay ahead of the competition, and to be able to compete on checklist-comparisons run by people who are unable to strategically assess software, enterprise software often is trying to do way too much.  What gets less attention is the software’s quality of implementation.  In other words, enterprise software has a million features, but they aren’t done very well.

Ironically this can also be a misguided product strategy, because (as Christensen tells us) features are only competitive advantages up until the point where the basic business problem has been solved.  That’s when software starts to commoditize, and is vulnerable to having its customer base eaten out from the low-end up.  The typical response to this is for enterprise software vendors to attempt vendor lock-in, making it inconvenient as possible to migrate away from their platform.  Hm. Do you think their interests may not be exactly aligned with yours?

We Don’t Like Your Kind Around Here

Finally, enterprise software (probably in pursuit of the vendor lock-in strategy) tends to dramatically over-scope itself, attempting to become its own ecosystem of functionality.  This might also be a kind of a not-invented-here syndrome at work.  Whatever the cause, the result is that functionality that might appropriately live elsewhere is rolled into the enterprise product, in kind of an awkward or substandard manner.  Everyone has to live with it regardless, because they’re locked into the ecosystem.  Just think about how many additional services Oracle has built into their database products, or Microsoft has tied into their operating systems.

Less is More

While it is true that giant product deployments are sometimes the right way to go, I think that as organizations we often miss the opportunity to stitch together solutions that meets our specific needs out of best-of-breed components.  Think of the UNIX principle of .  If we can try to use software that solves smaller, more discrete problems in ways that are optimized for their problem space, then the overall technical ecosystem of our organizations will get stronger.  Instead of technology for the golf course, we’d have technology that actually helps us.  Technically savvy organizations like Google understands this – perhaps we should too.

Posted in business.

Tagged with , .

No comments

By loren – October 19, 2008

Problems, Salesmen and Engineers

Remember this old joke?

A mathematician sits on a park bench next to a pretty girl.  He wants to move closer but is struck by the helplessness of the situation: he’ll move half the distance, then half of the remaining distance, then half of that, and so on and so on – but will never actually reach the girl because the remaining distance can always be halved.

Later an engineer finds themselves in the same position.  Like the mathematician, he knows its impossible to actually reach the girl, but he realizes he can get close enough for all practical purposes.

(Okay, it is, and has always been, a dumb joke.  But it’s about how engineers think, and that’s what I want to talk about.)

Engineers solve problems.  In order to solve problems, they need to identify them.  They need to get down in the detailed muck of whatever it is at hand so they can see how things work and find a solution.  This is called “getting your hands dirty”.

Most people are afraid of problems.  Problems make them feel like victims – helpless to control their fate.  They’re used to problems making life worse for them, without any available solutions.

Engineers, on the other hand, relish the thought of new problems.  After all, they’re used to having problems fall before their mental prowess – sliced into bits by Occam’s Razor.  The existence of problems is enjoyable to an engineer: it gives them something to do.  To most, however, the existence of problems is upsetting.

And that brings us to salespeople.  Salespeople identify problems that upset people, and they sell solutions to those problems.  (And since this is a web agency post, by “solutions” I mean “websites”).  In theory, people will feel better because their problems have now been solved. The salesperson also feels better because they now have money.

Now what salespeople don’t want to do is dwell on the problem..  They want to talk about the solution.  No problems should escape the solution.  The solution leads to the sale.  Focus on the solution.  Always Be Closing.  Dwelling on problems creates doubt in the mind of non-engineers, and doubt screws up closing the deal.

So, ultimately, the salesperson wants to play down any problems that are not solved by signing the deal, whereas the engineer wants to dwell on them in detail.  Disconnect.

Weird things can start to happen when you bring an engineer into a sales situation; something that is occasionally necessary.  In the web agency world, the art of deal making is that the sale is made long before it’s clear what is being sold.  For n dollars, something will be built that will do something on the lines of solving these business problems.  Sort of.  Give or take.

This is totally backwards to the engineer, who, in their problem solving mindset, wants to be given a problem to solve.  A set of metrics for success.  A clearly defined goal.  But that’s not the way agencies work.  First you pay, later you find out what you get.

In order to close the deal, the salesperson needs to keep out of the details, and basically imply that the website will do everything that the client wants, but without actually promising anything specific.  The danger to the salesperson is that the engineer, being detail conscious, will screw this up.

The danger for the engineer is that the salesperson might sell something that simply can’t be delivered for the specified budget.  Or perhaps commits the engineering team to a ridiculous technical constraint that adds so much risk to the project, or is so onerous, that what started as a simple project becomes a nightmare.

When an agency works well, there’s a kind of dance between sales and engineering, where sales gets deals done without being drawn down into the muck of engineering, but doesn’t create any deals too stupid for engineering to be able to deliver.

When sales and engineering don’t sufficiently trust or respect each other the dance breaks down.  Then sales closes deals that are impossible, and engineering bogs sales negotiations down in details that simply shouldn’t see the light of day until the ink dries on the contract.

Posted in business, programming, web agency.

Tagged with , , .

No comments

By loren – September 22, 2008

Does it FIT?

There has always been a fundamental impedance mismatch between business and technical folk.  They seem to be living in two different worlds, each with different rules of engagement.  In fact, this is because they have different values – different things that they care about.

On the business side you have project managers, new business types (aka salespeople), and other bean counters.   These people basically care about money: making it and not losing it.  Making cool stuff is a fortunate side effect at best.

On the tech side you have developers and (in a way) UX types.  These people love solving problems.  Give them a problem, they want to solve it – preferably in the most awesome, beautiful and elegant way possible.  On a deep, soul searching, emotional level, they don’t give a flying crap about the money.

Funny things happen when members of these two groups speak with each other.  They describe things using the same words, but they mean fundamentally different things.

It’s very common for the business types in Group A to approach the problem solvers in Group B and ask them a question like “would it be possible to add some snazzle on the frozbot”?  At this point the problem solver gets a far-away look in their eyes and replies “yes, it’s possible”.

Hey, business types: the problem solvers are talking about something entirely differently than what you have in mind.  If you’ve just inferred from their response that you can squeeze that new feature into the project, you’re wrong.  At least potentially you’re wrong.  You actually don’t have any more information than when you started, because the problem solver’s answer actually contains no useful information to you whatsoever.

What you wanted to know was:

“Can I get this extra feature into this project,  it in a way so that I continue to make money?”

What they just really answered was:

“Yes, with nigh infinite time, resources and money, this snazzle can be retrofitted onto the frozbot, in a fabulous dimension of mind over matter where this crappy project doesn’t exist”.

Which, business person, was, of course, not your question.

You see, you thought the money part was implied.  And, to another business type, it would have been.  But as was noted above, the problem solver is not inferring that part.

So I propose you stop asking the question “Is It Possible” altogether.  It’s a useless question.  Instead, I suggest you ask “does it FIT”.

My new favorite acronym – FIT.  Feasible Inside Triangle.  The triangle being, of course, the classic project triangle of Scope, Schedule and Budget.  By including the triangle within the question, the problem solver has to take its constraints as part of the equation.

This is an adjustment at first, but they’ll get used to it.  The barre has been raised.  Business types can expect a lot more up-front pushback to “does it FIT” than “is it possible”.  A lot more “no way”s.  However this is better than the alternative, where people say “yes” and then a project disaster ensues.  FIT forces people to be realists.

This communication barrier between business and problem solver types is really dysfunctional, and has probably led to millions and millions of dollars of waste.  Let’s stop lying to ourselves about feasibility in projects, and keep our problem solving powers relevant to reality.

Posted in business, web agency.

Tagged with , , , , .

No comments

By loren – September 11, 2008

Everybody Disco

I’m looking at a new project called Disco.  It was developed by Nokia as an implementation of MapReduce, the Google-spawned algorithm for sharding a large computing task into pieces that can be crunched by multiple cores or servers.  Word has it that MapReduce is used extensively at Google, probably to build that big index, I’m guessing.

The core of Disco is implemented in Erlang, the concurrent, fault-tolerant, multicore-ready distributed computing platform developed some time ago at Ericsson.  Erlang is brilliant, though kind of weird, and represents a big educational hurdle for the existing programming population.  It’s just too different from the existing major programming paradigms.

Disco takes a stab at solving that problem, by allowing programmers to write their jobs in Python.  The jobs are executed by the Erlang core, buying all that distributed, fault-tolerant goodness that Erlang provides, but keeping it safely sealed away from application developers who can work in the relatively friendlier world of Python.

Here (lifted directly from the Disco documentation) is a Disco job:

from disco.core import Disco, result_iterator
 
def fun_map(e, params):
    return [(w, 1) for w in e.split()]
 
def fun_reduce(iter, out, params):
    s = {}
    for w, f in iter:
        s[w] = s.get(w, 0) + int(f)
    for w, f in s.iteritems():
        out.add(w, f)
 
results = Disco("disco://localhost").new_job(
		name = "wordcount",
                input = ["http://discoproject.org/chekhov.txt"],
                map = fun_map,
		reduce = fun_reduce).wait()
 
for word, frequency in result_iterator(results):
	print word, frequency

So this code snip is about creating a word count of some text.  MapReduce always consists of two functions – the Map function, which is used to split up a big job into a bunch of smaller jobs, and the Reduce function which assembles it back together into a single result.  (This is the essence of MapReduce, and isn’t tied to a particular technology).

The code above has two fun_* functions.  “Fun” is a Erlang-ism that creates an anonymous function, not unlike a lambda in Python.  The functions themselves are passed into the Disco instance which then spits out the results, once all the reduce functions exit no doubt.

So in the above code example, it looks like each word gets its own job, zipping through the text and getting a frequency count.  The job split is initially established by fun_map.  Then fun_reduce runs, concurrently, once per unique word in the text and counts up the frequency of that word, adding its results to the “out” accumulator.  Disco ties it all together and returns it as the “results”.

Wait, this gets better.  Disco comes with tools that allow it to be deployed on Amazon’s EC2 computing cloud.  (Hm, Python.  Django-Disco anyone?) Imagine dynamic, linear capacity scaling, on rented compute cycles, with easily written Python jobs.  I think I might be salivating a bit.

I’m a huge fan of anything that can deliver concurrent programming power in a form that’s paletable to programmers that haven’t grown up with it.  I’m going to eagerly watch the Disco project to see how it does.

Posted in programming.

Tagged with , , , , .

No comments

By loren – September 4, 2008

Learn or Die

I could never get my employers to pay for training.  Back in the beginning of my career, when I was dirt poor, even computer books were really expensive for me.  However, I somehow scraped together what was (for me) an enormous amount of cash to buy the books that I needed to learn (actually paying for classes wasn’t even on the table).  I had heard of the concept of employers paying for training, but the tiny start-ups where I worked could never afford that kind of thing.

That’s why I’m absolutely confounded by people who, when being presented with the opportunity to learn something new on their employer’s dime, refuse or drag their feet.  These people have someone who is willing to pay them to become even more marketable than they are now.  They can earn while they learn.  And yet, their answer is “no thanks”.

What drives this kind of thinking?  Why would someone decline to learn something new?  I can think of a couple of things:

First, I think that people legitimately realize that learning new things can potentially change your worldview, making you re-evaluate the truth of things that you supposedly knew before.  However, this becomes the “path to the dark side” when people reject the idea of learning new things because they’d rather maintain their existing worldview rather than having a greater comprehension of the truth.  It’s willful ignorance.  To avoid learning things for this reason is to choose to be stupid.

Secondly, (and I’m a bit more sympathetic to this reason) some people have been taught that a particular technology as a solution to everything.  Java (where I spent a good decade of my time) has been sold as the development environment for everything from an embedded, to a desktop apps, to web apps, to mainframe computing.  The message was that Java is the tool of choice for everything.  So why would one learn anything else?  What’s the point?  (Okay, so this actually sounds a bit like laziness to me, but such is the human condition – I accept that.)

Finally, a somewhat plausible reason I’ve heard is that people only want to learn things that have a direct impact on their capacity to make money.  Java developers are statistically paid the most of any developers – so again – why learn something else?  What is sad about that is that the best of the development community (and the source of much technology) comes from people who actually love technology.  People who are only in it for the money tend to also be mediocre programmers.

So here’s my plea to those who would choose not to learn new technology (or new things in general), whether out of fear, laziness or avarice: your brain is dying.  Save it.

Learning is a habit that keeps you sharp.  The more you learn, the more capable you are of learning.  This is a virtuous cycle that can get you 1) a robust and well-informed (albeit still disrupt-able) worldview, 2) a deep toolkit of knowledge to take on different problem domains and 3) awesome market value, allowing you to rake in the cash.  In other words – all of the stuff you care about can be accomplished to a much higher degree by learning new things.  There’s work involved, sure, but if you stay ignorant you’ll only be working hard anyway: putting out fires in your career because you don’t have the knowledge to take control of the situation.

Taking every chance I’ve had to learn new things has been the engine that’s driven my career.  So, please, if someone offers you a chance to learn something new, on their dime, take it.  On both a personal and professional level, its keeping you alive.

Posted in programming.

Tagged with , , , .

1 comment

By loren – September 1, 2008