How Developers Learn

I took a sarcastic look at developer motivation to learn in the last post, but let's take a look at how developers learn. First, let's detour briefly to the realm of behavioral science, where David A. Kolb created a chart categorizing learning styles.

I'm leery of the categorizations that social science tries to put on humans. You can't stick people in boxes because some parts of them won't fit and the ones that do might be trying to climb out. But I agree they are useful for identifying general traits and tendencies. You've seen these things before, possibly in your management or project management classes. Similar charts for categorizing personality types are used to help you empathize with teammates and understand better how to communicate with them.

David A. Kolb
Kolb wrote Learning Style Inventory in 1984. There's a nice summary of his theories of human learning at Don Clark's Performance, Learning, Leadership, & Knowledge site. Essentially, Kolb's theory is illustrated on a two dimensional grid.

One dimension represents a continuum that rates a person's tendency to be task oriented (doers versus watchers). The other represents a person's emotional state in learning (expressive versus detached). The extremes of each continuum yield four types of learning style:

1. Concrete Experience: People that like this learning style learn best from the experience of others and information they receive hands-on. They favor anecdotal lessons, peer feedback, and direct experience with a situation over theoretical study.
   


2. Reflective Observation: This learning style represents those that learn by watching others work and can ponder how it affects their life. Learners of this style appreciate having a mentor to learn from or an advancement structure where they can serve in apprenticeships and see how others perform a task.


3. Abstract Generalization: This is learning via deep analyses of published theory and case studies. Learners preferring this style tend to reflect heavily on hypotheses and compare and contrast the theoretical against their own personal experience.
   


4. Active Experimentation: Learning here is achieved through the "school of hard knocks." People using this method to learn like to jump right in right away. They probably don't have the patience to absorb large amounts of theory or to poll peers for advice. But hey, some situations call for Dick Marcinko and some call for Robert Gormly.
   

The intersection of the dimensions creates four quadrants that generalize the types of people based on their learning preferences.

1. Theorists: These people are readers and thinkers. They prefer book study and tend to think in abstract theory rather than practical application. They might be what Joel Spolsky calls Architecture Astronauts.



2. Pragmatists: Like the Theorists, Pragmatists will use abstract learning to study theories, but they are more interested in ultimately how they'll apply that theory to practice.
   


3. Activists: Activists like to learn by just diving into something and learning as they go. They like to experiment and may be too impatient for the books the Theorists would use, instead relying on immediate feedback.
   


4. Reflectors: Reflectors, like Theorists, need time to ponder and come to grips with a subject. But like Activists, they depend on concrete experience to help them make sense of things and determine how they'll apply them. Theorists use observations and studies to develop and challenge a theoretical model; the Reflectors use their observations and intuition to learn and apply themselves.
   

It sounds interesting and I do find Kolb's work fascinating, but then again maybe it's all a bunch of moldy elephant crap. As I said before, you can't categorize human beings with cookie cutters. Not all criminals are, as the liberals would have us believe, simply lonesome, misguided kids that can't help themselves and therefore shouldn't be locked up. Yeah, whatever. Maybe that's true for Dostoevsky's Raskolnikov, whose guilt drove him to turn himself in, but how many times does that happen in real life? I digress. The reality is that a person can use any of those learning styles and belong to several of those categories.

Learning Through Code
How can you help improve your company's applications and reduce time spent fighting fires if your developers don't have time to learn or advance their skills? If they're not motivated to do it themselves? After years fixing other people's code, and realizing that mine at times has been even worse, I think there are a couple of tactics that can help.

• Document, Dummy!
  I know. I harp on this all the time. And I may be one of less than 20 developers in the world that actually care about it. But would you work on an engine without a Chilton guide? Would you build a house without a blueprint? Even a LEGO model without the instructions?
  
  Then why, with something as complicated as software, would you jump into 100,000+ lines of code without a map? I know the answer already: because the knuckleheads that cooked up that pile of spaghetti didn't leave a recipe behind! Forget it. I'm done talking about user documentation, technical documentation, and training. If you don't value it, that's your problem, and good luck with that as your application grows in complexity and your users start spreading across time zones.
  


• Get a Decent Lead or Architect
  If you can't get a decent road map for a project, at least get a decent foreman. There's a reason young lieutenants are told to defer to the platoon's senior non-commissioned officers: experience and proven competence. This is especially important when the team is navigating the minefield of a new paradigm such as when adding substantially new chunks of functionality, porting the application to a different technology, or even retraining en masse to a new language. A good lead can help the team make good decisions and bypass common pitfalls. But leads aren't perfect; if the team is making the jump to something really different, get a consultant in that has proven expertise to work with the team. This is especially important because of the next point.
  


• Make Version 1 as Clean as Possible
  You want to know how developers learn? Some will read books, some will listen to advice from the lead or architect. And some won't do either of the above. Maybe they're not interested in the time it takes outside of work to read books or take classes. Maybe they're self-conscious and feel that asking for help makes them look stupid.
  
  But every developer eventually has to dig into the code. Every one. Has to, at some time or another. It doesn't matter if they're supporting an old app or just looking for ways to write a new one, they'll likely try to cut-and-paste to save time. And this is where you can do good things for them if you've got good people leading the way. Regardless of their preferred learning methods, all developers learn from existing code. That means that if the bulk of the code is fugly, average developers are going to propagate those techniques forward.
  
  Good developers will try to improve things; they too cut-and-paste to make deadlines, but bad code smells will trigger a reflexive action and they'll at least try to clean it up a bit.
  
  Average or less experienced ones may not introduce worse techniques, but cut-and-paste still deteriorates the code because it expands the existing technique's use. That hardcoded routine that was already a maintenance hassle is now a maintenance hassle in two or more places.
  
  Poor developers will make it worse, by cobbling on even more hacks on top of the copied code.
  
  If you don't have strong developers maintaining an application, it's going to stay about the same or get worse. Everything from data access and variable naming standards to GUI techniques and script formatting will likely be carried forward from the original foundation. That means the application is well served by a decent version 1, assuming the software is going to live long enough to need continued maintenance.

Still, making Version 1 as clean as possible is no guarantee of a happy, extensible application. I've seen apps that had a decent first cut, but poor follow-on developers compromised it over time. And sometimes, the first cut is necessarily rushed and you could make a case that a good lead developer/architect is as valuable in the first several refactorings of the code as he/she is in the original design. Writers have an adage that applies here: The best kind of writing is re-writing. Perhaps the best kind of programming is refactoring.

Knowledge is Power
Software is hard. It almost always grows in complexity as it evolves, sometimes by design and sometimes by misstep. You can't do everything, but do everything you can to give your developers an edge against chaos. Lobby for thorough requirements, demand proper resources and tools, and get a good project manager to enforce scope control. And educate them, knowing that each person has a different blend of learning styles. Institutionalize the team's knowledge through documentation and impress on them the importance of keeping it updated, hold technical sessions, live training for both business and technical topics, give them a book budget, and for crying out loud, don't always say "No" when they ask to take external classes or attend technical conferences.

What Motivates Developers to Learn?

What Kind of Learning Developer are You?

Getting to a place where a person calls himself a developer is just part of the story. The other half is really about how he develops himself once he's in his career.

Ultimately, it depends on the kind of person the developer is. I've seen a couple scenarios in my experience:

The Renaissance Man
You know the character that is always the nemesis of the everyman hero in romantic comedies?He's the guy that looks like he's going to get the girl the hero wants because he's a double PhD in law and medicine, inherited more money than you'll find in the Denver mint, plays guitar, can charm cats, is an award-winning chef in his spare time, owns stocks that only go up in value, and looks like he walked off the cover of some glossy magazine. Oh yeah, he also knows every language O'Reilly has ever published a book on and can work at a high level of mastery.

Yeah, that guy. Not many exist, thank God, but these guys aren't just lucky, they're also deeply talented. They are the Mozart to your Salieri, and you can't do anything about it. Programming is well served by people capable of blending outstanding memories with quick minds, an ability to manage complex concepts, and organizational skills. Most of us have some of those things but not all of them. What does that mean? It means the Renaissance guy can study less and learn more because it comes naturally. So for him education doesn't require quite the investment of time it does everyone else. It also doesn't hurt that these guys make the effort to learn and can apply what they learn in their craft and their lives. That's what makes them Renaissance guys; learning isn't some uphill battle they do to try to get ahead, it's just a part of who they are. And it isn't just programming crap. These guys seem to learn everything.

Management advice: Don't worry about these guys, they'll take care of themselves. They're probably already making more money from their side businesses than what you pay them.

The Nerd
Nerds are en rapt by the whole world of software and computers. Unlike the Renaissance Man, for whom learning is natural, the Nerd has to work at it. The Nerd tells himself he enjoys it, but that's just a defense mechanism to deal with the fact that again unlike the Renaissance Man, the Nerd is socially estranged and isn't doing much else on Saturday nights. Learning about new techniques and technologies is above rejection on the entertainment scale. Fortunate Nerds work for companies that pay for the cost of education. But most are like the other 80% of the world's tech workers, where IT is considered a cost center, and they'll have to learn on their own resources. But either way the drive to learn is self initiated and they seek knowledge of their own volition.

Management advice: Nerds make great employees if you can handle their eccentricities. They won't make a jump to sales anytime soon, but they'll do good work and they're reliable. Do what you can to support their interests in learning. It'll boost their morale and benefit the organization.

The Resume Builder
This developer's strength is that she is always looking forward and cognizant of industry trends. The weakness is a desire to always be at that cutting edge and a fear that working on the old stuff is death in the marketplace. While there is some validity to that fear, I'm still seeing systems that run on COBOL, so its death, for those that are proficient in the language and willing to work with it, has been highly exaggerated. The same could be said for FoxPro, pre-.Net Visual Basic, PowerBuilder, and C++.

The Resume Builder is always learning, but unlike the Nerd and the Renaissance Man, the Resume Builder never develops deep proficiency. The Resume Builder, currently using language X, will be satisfied with a year or less of experience with it, and even at the day job, will be stealing time from work to study language Y. When an opportunity to use language Y appears, at the same company or elsewhere, the Resume Builder will move on. Once entrenched in her new position, the Resume Builder will begin studying hot new language Z, and will be ready to move on again in a year.

The Resume Builder's resume is indeed impressive, with every programming language conceivable on it. But what the resume doesn't tell you is that the code the Resume Builder wrote wasn't very high quality. It might have been Visual Basic, or PL/SQL, or Java, or C#, but it tended to solve problems the same way in each language, rather than using the language's strengths. It would include T-SQL that used lots of cursors instead of set theory or it might be an OO language where the methods were each 500+ lines of spaghetti code instead of smaller, logically partitioned components. The resume also doesn't mention that the Resume Builder, busy moving between languages, tends to repeat the same mistakes in each new language.

Finally, the resume also doesn't tell the story of the Resume Builder's poor motivation while working with language X. Any assignments in language X were done quickly and with a band-aid approach. Sometimes a band-aid approach is the correct tactical response when the preferences of a developer and a project manager clash but everyone wants to stay employed. The actions of the Resume Builder aren't of that type; they don't leave behind a rushed solution with useful documentation for those who must follow; they leave behind a train wreck caused by neglect for maintenance.

Perhaps I shouldn't be so hard on the Resume Builders. At least their learning is still self motivated, even if the motivation is for the next job and not necessarily for building quality solutions. Frankly, the Resume Builders probably don't care what I think. They're too busy counting their money.

Management advice: Nope. I know you wouldn't listen to me anyway because you keep hiring these guys.

The Anchor
Sometimes developers don't care to learn. It's not that they won't or that they don't enjoy it. They might even like it, but they're not motivated to do it regularly on their own. This is because learning involves substantive effort outside of work. And that's an important distinction I haven't mentioned: learning job-related skills on the job versus learning them as an extracurricular activity.

The Renaissance Man learns with ease anytime, anywhere. The Nerd has to work on it but typically doesn't have a problem committing personal time. The Resume Builder might also do it at work and at home, but prefers to bootleg time from work (and I don't mean bootleg in the nice 3M way, where bootlegging led to the creation of the now ubiquitous Post-It Note). The Anchor will plod along at work, primarily doing work, and when the bell rings at 5pm, he's only doing work at home if it's for a production emergency. The Anchors will learn if someone is forcibly hauling them through the water or holding their hands through a software learning exercise. But it had better be on company time. Left to their own devices outside of work, they'll opt to do something else they find more palatable.

There's nothing wrong with the Anchor's philosophy. It's rather laudable in a work-life balance approach. However, learning isn't really about work even if it's about work-related skills. It's about self development and furthering one's ability as a developer. If someone is too busy at work to learn new things that help both himself and his employer, they'll both be endlessly mired in the same approaches with the same problems. Any improvements from this camp will be rare and of incremental value. Having lots of these guys means that instead of building a staff of Renaissance Man wannabes, you'll have a staff of guys that do as little as possible. They'll never sufficiently refactor the software so that they can spend more time furthering the company's strategic goals and less time fighting fires in overtime (see, I worked the overtime angle into the post after all).

Management advice: Anchors aren't going to lead the way in evolutionary improvements for the organization. They can be reliable in some roles, but be careful about putting them in positions where they are going to make decisions for software projects of considerable risk and complexity.

Keeping it Real
Despite some grains of truth, the above was a largely humorous look at different learning motivations for developers. The truth is that you can't cleanly and completely categorize any person. I myself could have fit into any of those categories (except for that Renaissance thing) at different times in my career depending on my level of maturation, experience, and the environment.

That's enough about intrinsic motivation. Next time, I've got some thoughts on how developers learn.

The Difference a Year Makes

I've done the very thing a blogger isn't supposed to do. I went nearly a year before posting. What happened?

IT and Happiness
A job change can always be a time sink. I made a decision last year to trade a little money for some intangibles. I've been busy as blazes trying to wrench a big project into order. Was the change worth it? I think so; as I tell my friends, you're not supposed to be able to buy happiness. But I sort of did that, not by buying it direcly but by giving up purchasing power in trade (a fancy way of saying I took a pay cut to make the move).

A theme I was supposed to pontificate on last year was what happiness means in IT. What a pretentious bastard to assume I could know such a thing, huh? I'll take a stab at it anyway, because if nothing else, writing is cheap therapy.

On that note, and given my recent experience, let's talk about money. Everyone needs it even if they don't love it. And you know what? I think everyone loves it even if they say they don't. Not everyone loves it equally, but it means a lot in a world where things tend to get more expensive, not less. But it's an important part of any worker's life, so here's the truth about it from my perspective.

How Much is Enough?
That's what employees and employers want to know, right?

Employers, you don't have to be a top compensator, but do keep abreast of the salary surveys and make sure you're not too far out of the loop. Seriously. And be willing to boost your long time loyal veterans if they're not up to the market standard, or they'll leave and do it themselves. If they're not smart enough to keep up with what's going on, do you even want them working for you?

Employees, keep an eye on those salary surveys but keep a decent perspective on reality too. Are you really delivering the quality a 15 year senior person is supposed to be delivering? Are you being honest in your assessment of yourself? In the end of course, your network may have more to do with your career success than your ability. How much is enough? That's ultimately up to each individual, but I believe most are reasonably happy if they are enough above breaking even to live comfortably. They're even happier if they can get far enough above that to have a savings account and live with some minor luxuries. For most developers, that's a good spot to be in. Money above that point is gravy, but isn't worth having if you have to give up having a decent supervisor, good working conditions, and challenging work that engages you.

The Intangibles
When you get older, you realize that money is important, especially in a society where it is the main bartering tool. But there are indeed things money cannot buy that developers do appreciate:

• Decent work environment
• Quality peers
• Decent tools
• Access to training
• Book budget
• Flexible hours
• Mangement that understands quality is not always free, swift, or easy
• A work environment with minimal interruptions
• Career path (including a non-management path)
• Management that values its full-time employees more than contractors (and pays for it with more than lip service)
• Decent equipment (reasonably current PC and dual monitors)
• Management that says Yes as often as it says No
• Opportunities to work with advanced or new technology in productive and meaningful ways