Programmers are Humans, Too: How to Get Crusty Developers to Change
Using the tenets of organizational behavior management to encourage change in stubborn devs.
Join the DZone community and get the full member experience.Join For Free
What? You didn't know that? :-)
On a recent blog post, I received this comment:
Thanks for the video. You've answered my question and given us lots to talk over. Now, do you have any advice on getting those resistant to change — crusty, old, developers — to buy in to change?
My immediate response was: incentives and fun.
So now it is time to elaborate a bit.
First of all, the hardest part of programming is not learning new features or absorbing the syntax of a programming language. After all, learning such a language is waaaaay easier than learning a human language - primarily because when we write code we are communicating with something that "thinks" quickly but is not particularly "smart." It, the computer, however you want to define that these days, does what we tell it to do. Really, it does, no matter how many sci-fi movies you've watched that indicate otherwise.
Since a computer isn't very smart, we have to communicate with it using very formal, stiff syntax. That's a pain, but it also makes things easier.
Anyway, the hardest part of programming is that programming is performed by humans, and we are complicated, contradictory, flawed organisms. Thus, the social processes that envelop the programming tasks are usually a bigger challenge (and opportunity) than focusing on the technology itself (that is, go to another class on Advanced PL/SQL, and so on).
So when it comes to the question of "How do get change-resistant crusty, old programmers to change their behaviors?", the answers are too fold:
- Recognize that we are all change-resistant, not just the Wise Elders.
- We (humans in general) change when we are incentivized to change.
Appeals like "Do the right thing." or "Stop acting your age." or "Nobody's done that for decades." will not motivate a person to change their ways.
We change when we feel it is in our best interest to do so - or we change without quite realized it, because someone was very clever in how they approached things.
So my suggestions for being clever and incentivizing for change:
- Identify the behaviors you want to see changed.
- Figure out how to measure the change.
- Make it as easy as possible to make the change.
- Make the change as fun as possible.
- Reward us as and when we go through the transformation.
Let's look at an example. Suppose that we have a problem in our development team that code re-use is pitiful. Instead different members of the team write the same or similar stuff, over and over again. How can we get the behavior to change?
1. Identify the Behaviors You Want to See Changed
I want my team to find and re-use existing subprograms in package APIs, rather than rewrite stuff.
2. Figure Out How to Measure the Change
How can I tell when people are reusing code? Ah, the beauty of PL/SQL - code is stored in the database and metadata about that code is stored in various data dictionary views. Of most relevance here for PL/SQL developers is PL/Scope and the ALL_IDENTIFIERS view. I can run a query that shows me how many places a particular or all subprograms are invoked.
3. Make It As Easy As Possible to Make the Change
Now, this is a tough one. How do we make our developers more aware of what they can re-use and how? I do not have a simple or "packaged" solution for you, so I will instead offer some ideas:
- Standardize documentation of program headers so you can extract documentation of those subprograms
- Build an intranet site (using Oracle's Application Express!) to display this generated documentation or make it easy to search the code catalog (ALL_SOURCE)
- Monthly code review: highlight new program units and potential code re-use opportunities
4. Make the Change As Fun As Possible
Yes, that's right, I used the word "fun" in the context of not just software, from changing software coding behaviors. Hmmmm. Well, how do people have fun? They play games!
And there is a game you can play - individually and as a group - that will help improve your ability to identify repetitions in code and therefore opportunities for reuse. That game is Set. Set is a wonderfully simple and elegant game. I encourage you to buy the actual deck of cards (but, yes, you can play it online and there is an app, of course).
Play this game with your kids (if they are young enough to still want to play games with you) and play it together as a team. It's fun - and it's all about enhancing your pattern analysis skills.
5. Reward Us As and When We Go Through the Transformation
Oh how we humans like our rewards! They can come in roughly two forms: tangible and intangible.
Examples of tangible rewards: gift cards, promotions, raises, etc.
Examples of intangible rewards: recognition, mostly.
In terms of promoting re-use, I could envision a monthly or quarterly awarding of prizes for (a) who built the code that is reused the most (likely a more senior developer) and (b) who is reusing code most effectively (likely a more junior developer).
How could you tell? Again, in the context of Oracle PL/SQL, PL/Scope would help this.
Published at DZone with permission of Steven Feuerstein, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.