Flash-backing multiple years to my days at Multiplitaxion Inc, I am reminded of my work with a senior technical manager who we shall call Fred. This particular individual had been vested with the responsibility of running multiple projects and getting them implemented successfully. When I talked first talked to Fred, while touring him around the office, something didn't quite click. It wasn't a lay-your-finger-on-and-objectively-criticize-what-is-wrong kind of a feeling. It was more of a feeling that did not involve a lot conscious thinking; just a nagging gut whispering gently in my ear, telling me very softly but clearly that something was wrong somewhere. Then, the feeling grew stronger and stronger as we engaged in a casual discussion on software development and how both of us felt about it.

Under normal circumstances if this would have been an interview, the vibe he was sending, would have been enough for me to let him go but this wasn't an interview. Mr. Fred had been already recruited, he wasn't my selection and he wasn't even in my team. Fred was going to run over three parallel projects on mainframes something I knew absolutely nothing about; and because I knew nothing about his area of expertise, or what he would be working on, it didn't made sense to judge Mr. Fred based on just one discussion. Besides, Pops told me to shut my big mouth up and play a nice guy, so I did.

Weeks went by and we slowly started involving Fred with multiple other projects. Over a period of time, I started hearing names of cutting edge technologies in pre-beta stages in design sessions. I started reading names of random technologies in design documents of multiple projects Fred was handling. When I looked at the weekly status reports that were being uploaded to our centralized lotus notes based document repository, the sky looked blue, the grass green and the universe looked just fine.

Our projects were using state-of-art-cutting-edge technologies and frameworks. Mr. Fred was starting to take us to next heights enabling us for what was then refereed to as the e-commerce era. There was one little problem however; our submit buttons, didn't work all that well.

Have you ever had an incident where you are about to present an application to a client or a potential client;  and you get this chill run down your spine when you're about to hit that button because you're not sure what'll happen when you press the submit button which is 'technically supposed to' save things to a database? Those cold chills are exactly what I would experience when I was vested with the task of giving a demo to a client or a potential client of any project or product Mr. Fred had been involved with.

The strange part however was that Mr. Fred was working with decently good teams who weren't exactly known for programming by co-incidence at Multiplitaxion Inc. All of them, had been involved with and had attributed to multiple successful projects in the past. They seemed pretty excited about the new technology stack being used and were spending late nights in office trying to meet deadlines as they picked up and learnt new technologies. There were too many of those cutting edge, state-of-the-art tools and technologies being used in our projects.

It wasn't until six months later that I realized what Mr. Fred was doing has a name in software development world. It is in fact, lovingly called Resume-Driven-Development. Justice Gray does a pretty good job at explaining Resume Driven Development in his post on - New development methodologies for the 21st century - he explains Resume Driven Development as:

You want to have an exciting career full of exciting accomplishments and nothing is more exciting than introducing exciting new technologies into a project!  But what do you do when the new technology has no business justification or simply isn't the best solution for the problem as opposed to something less sexy?  That's the beauty of Resume-Driven: in this methodology, you don't care!  If you think XSLT is cool, how about using them to completely deliver HTML pages with static JavaScript inside?  Sure it's a maintenance nightmare but with XSLT on *your* resume, what does it matter?  You'll have left this project by the time it gets maintained anyway!  Building a static web page for a capella band?  Why not use Microsoft Biztalk?  With RDD your career is only limited by your imagination!

I can do a long post to describe how Mr. Fred applied Resume Driven Development to all his projects but I won't. Generally, here is how it would work:

1. Mr. Fred would look at a collection of technologies out there and pick the coolest one out.
2. Mr. Fred would then look at the technology, and decide it was a perfect tool in his toolset. He would in-fact consider it synonymous to a golden hammer.
3. From that point, because Mr. Fred had a hammer, Baruch's Law would kick in, and to his eyes, every single problem looked like a nail.
4. Without much ado, Mr. Fred would strike the hammer really hard irrespective of what the problem was; he would build himself what he called a 'proof of concept' to prove that he had picked the right technology for the problem.
5. Mr. Fred would announce the Proof of concept as successful, hand his cool technology to the team asking them to continue as he moved on to find something else to add to his resume.

I have a few acquaintances do the usual hi-how-are-you courtesy calls to catch up with me. They are often curious about technologies I am working on and often indulge in comparing the technologies I am working on with the technologies they are working on.

As developers, it is human nature to flaunt hot and sexy names of technologies out there and tell the world you're working on Windows Workflow Foundation and Silverlight but before you take a technology and apply it to your project, ask yourself if you are doing justice to your project by honoring Occam's Razor or are you just working at increasing the page-size of your resume at the risk of having a failed project on your organization's resume.

No-one cares what technologies you use or what your code looks like. Your job as a developer is to get successful implementations done; your job isn't even writing code. After all, the whole wide world runs on PHP. Go ahead, grab that book on Windows Presentation Foundation and read it well; but before you strike with your hammer, do validate that what you are striking, is in fact, a nail. Resume driven development is tempting, but in the long run, neither is it very effective, nor does it scale up as a philosophy to base a life on.

If you're into dice-driven board games chances are that you'll love MAD. If nothing else it's hilariously funny, confusing and completely insane all rolled into one. The objective of the game? You have to be the first one to lose all your MAD funny-money before someone else looses all of theirs. The funny feel of the game reflects right on it's cover which has funny pictures and a remark, "What, me worry?".

The board game comes with a printed document which is supposed to be your 'proof of purchase' with a warning inscribed very prominently:

DON'T PANIC: If you and your opponents find a board space or a Card card to be confusing, we wouldn't be the least bit surprised. But don't fight about it! Take a vote and play according to the majority rule. To most people, a majority is anything over 50%. However, because you're sufficiently intelligent and persistent to have read this far, you're clearly not most people. Therefore, determine in your own mind what constitutes a majority, take a vote and decide according to the majority rule.

The game is insanely funny; it is by far the funniest board games I've played till date. In-spite of the warning you will invariable see yourself get into really funny arguments with other players over interpretations of what the cards and board spaces mean.

The game has nothing to do with software development, but overall, the game is a very apt representation of the confusion and chaos that happens in game of software development.

1. The customer thinks he knows what he wants.
2. You think the customer knows what he wants.
3. You have meetings with customers in attempt to try and understand what he thinks he wants.
4. You think you know what the customer wants.
5. The customer thinks you know what he wants.
6. Neither you nor the customer knows what is it that he really wants and how you'll get there.
7. You convince the customer that you know exactly what he wants.

Then added opponents of software development start attacking from multiple directions and before you know it, something creepy and weird happens: Everyone Panics.

MAD, the board game begins with the same practical, pragmatic advice that Douglas Adams had picked for his famous book, The Hitchhiker's Guide to the Galaxy:

As far as software development is concerned panic contributes as much to the failure of the projects as much as any other factor.

Chad Myer Provides added insight into why every project usually goes into panic mode:

There is a point in every project - well, every project I've ever been a part of in one shape or another - where panic starts. I'm not quite sure what starts it every time, but the ones that I do know of have all been about money and 'burn rate' and I'm willing to bet that all of them (even the ones that were not made known to me) are about that. The point of Agile, in my opinion, is to allow visibility and more frequent opportunity for decision points for the stakeholder for just these types of moments.  The appropriate response, when this moment of panic is about to ensue is for everyone, especially the stakeholder, to put on their big boy pants and start making the hard decisions about what to cut. The inappropriate response - oh there are many, but they boil down to this - is to start mistrusting the developers and start assuming they're lazy SOBs who have been cleverly avoiding work throughout the whole project.  Looking back, nearly every single time the panic season started, this was the demeanor the stakeholders took.  Instantly the project went sour, all pace was destroyed, morale tanked, some people went into psycho 100hr/wk work mode to prove the stakeholders wrong, others proved them right by giving up and not doing anything. Ultimately, the project died a rather undignified and flaming death. Failure resulted (or perhaps success didn't happen to the degree to which it needed to happen), the team burned out and most left while the stakeholder was stuck with a failure product and all their critical brain trust gone or demoralized.

Ever been a part of a project where the panic button is pressed because the team is failing and someone realizes that it's failing because of lack of policing mechanisms? If you've been a part of any such projects in your life you're probably related to what Chad is saying here. If you, dear reader, have been through this experience, you probably know the feeling and can smell this panic button being pressed based on incidents that start happening. Office timings are made stringent, holidays and leaves are canceled, emails lose their touch of basic niceness, dead-lines for every single task are asked, micro management begins and everything starts failing apart.

I've seen quite a few Agile projects fail when the panic situation becomes public knowledge. After all, transparency is the biggest blessing and curse of Agile or simply an open culture in general. It brings the chaos and panic right on your face, forcing the weak hearted to either abandon it or press the panic button and replace the fundamental premise of trust on which Agile Projects are built are managed with policing measures and mechanisms.

I've often seen individuals accuse agile as being an excuse for being sloppy, but agile, by far, requires a huge deal of talent and discipline within, the development team and entire organization. In fact it requires more talent and discipline than any other process I've seen in my life. Chad in his post explains:

This is it, there's no turning back. Everyone on the team - stakeholder and producer alike - must trust each other to make the hard decisions and cut what they must to make the plan happen. You must resist the urge to bear down, roll up your sleeves and do everything wrong as fast as you can and ruin everything you've strived for. It's during the hard, trying times that discipline pays its debt. Soldiers don't go to boot camp to learn how to salute during peace time, they go there to learn how to be disciplined when the bullets are whizzing past your ears.

All of Agile is about forcing you to take the correct and sometimes hard decisions sooner than later. It won't give you a cozy feel of the 'green status report' when things are not fine. Software development is much harder than losing all your money in MAD. Before you start the software development game, the least you can do is remember the rules from MAD:

DON'T PANIC: If you and your opponents find a board space or a Card card to be confusing, we wouldn't be the least bit surprised. But don't fight about it! Take a vote and play according to the majority rule. To most people, a majority is anything over 50%. However, because you're sufficiently intelligent and persistent to have read this far, you're clearly not most people. Therefore, determine in your own mind what constitutes a majority, take a vote and decide according to the majority rule.

If you are a young and budding manager, developer or whatever-it-is-that-you-are, I leave you with one humble thought, that you can put on your not-to-do list. Take the hard decisions if you must, cut down on features if you must, motivate and train your team to work independently if you must; whatever you do; don't police and don't panic; because that is what spreads like wild fire and causes everything to fall apart.

During his early days as a mentor to some of the junior programmers at Multiplitaxion Inc; one of them, who we shall call Fred, had an issue with me and my management style. His issue was that I wasn't pushing him to meet deadlines.

Mr. Fred believed that my not pressuring him really hard, like most other traditional managers had pushed him in the past, was bad management on my part.

He patiently explained to me that, instead of me making him estimate the duration for his tasks and then letting him have enough time to complete them with a quality implementation, he would really appreciate it if I could estimate how long his tasks should take and then give him a dead-line so that he would start working harder as the deadline approached.

For most other thick-skinned programmers who were getting projects rolled out successfully at Multiplitaxion Inc, deadlines weren't working out all that well. They seemed to like the idea of estimating their own tasks and working in a pragmatic non-panic environment.

I had discovered, early on in my career that the mounting pressure to ship based on a given artificial deadline encourages developers to program by co-incidence. As a developer, I had learnt the lesson the hard way, and had told myself that I would not push teams I work with to program by coincidence just to meet a deadline; specially artificial ones.

As I grew in my professional and personal life I started realizing that not imposing any deadline on people and empowering them with trust, makes them much more productive. Then I met Mr. Fred who had issues with the whole no-deadlines-we-trust-you-to-get-things-done way to running projects. Here was a guy telling him me that he desperately needed deadlines and he needed to be pressured so that he would do his work as I stood there and looked at him, completely confused.

Deadline Driven Development or DDD as some call it lovingly, isn't new in the world of software development and this wasn't the first time I was seeing it in action. During my early days as an young and budding developer, I had seen deadline-driven-development in the world of project managers where it was rampantly popular.  Having said that however, this was the first time in my life when I was seeing a team member crave for it. This was indeed my first experience of seeing young and budding engineers infected with an otherwise managerial disease. 

Tom DeMarco and Timothy Lister describe a real life story, of how managers and senior executives, like keeping their teams under constant pressure of deadlines, in their book Peopleware: Productive Projects and Teams:

During the past year, I did some consulting for a project that was proceeding so smoothly that the project manager knew she would deliver the product on schedule. She was summoned in front of the management committee and asked for a progress report. She said she could guarantee that her product would be ready by the deadline of March 1, exactly on time according to the original estimate. The upper managers chewed over that piece of unexpected good news and then called her in again the next day. Since she was on time for March 1, they explained, the deadline had been moved up to January 15.

The story might seem extreme to a few of you dear reader, and even though moving the deadline ahead might seem a little dramatic for most management teams to do, consider this: how frequently has your management seen you ship comfortably on time and have thrown in a couple of extra features in the mix asking you to build the new features in the same timeframe. Maybe the deadline wasn't randomly moved ahead, but adding random features, just to keep the team on their toes, equates to the same thing.

Deadline driven development is an approach to software development where the management constantly and rampantly disrespects the iron triangle. At multiple organizations that I've seen or visited, I've personally heard of or participated in more than one project and utilization meetings where people being able to head home comfortably at 6:30 is cited as a bad example of resource utilization.

Most veterans understand and have mastered the art of balancing between aiming for perfection and shipping and these kick ass developers will ship as fast as they humanly can. At times they'll estimate stupidly, stumble like babies and miss deadlines. Then they'll get up, get better and ship successfully. Peopleware does a pretty good job at describing the paradox of success when it comes to deadlines:

How many times have you heard that some new technique is going to be used because it is the only chance to make the hard-and-fast deadline, and that if the deadline is missed, there will be hell to pay?  The  setup of the change has already made its  outcome more than a little  dubious. The  kid-like  willingness to throw ourselves into a potentially  embarrassing endeavor is defeated by the potential for ridicule. Paradoxically, change only has a chance of succeeding  if failure, at least a little bit of failure, is also okay.

Every time there is a business push to ship faster I see countless managers, just take the email, forward it to their teams and push them harder; under the optimistic belief that if the team really pushed harder they might be able to pull of a magic trick.

If you're a manager, your job is not just to build a gantt-chart and then run behind your team collecting the status in terms of percentage complete. Business is expected to rush software development teams into it's own death-bed through continuous increase in velocity but and some point you need to take the crap upon yourself, cushion your team from it and let them function un-interrupted without the pressure of continuous and mostly artificial dead-lines. If you need to sit through a thousand meetings to convince the business, please do; if you must get into heated argument with marketing guys and your bosses please do; but if you pass of a stupid artificial deadline to your team all you do is demonstrate the lack of your management skills.

If you're a budding manager and the next time they tell you that there'll be hell to pay if a deadline is missed, try to investigate a little more into exactly how the business gets impacted and what is the actual loss involved if you were to miss a deadline for a few days. Chances are, there'll be none and there is invariable a high possibility that the so-called magical deadline which appeared out of nowhere would be the brainchild of a prick trying to push the team a little harder by pushing random deadlines.

I've been a part of multiple projects and have worked with a huge numbers of developers. I have hardly ever seen programmers cheat their organizations and have a fun time watching movies and playing video games when they had a clear sense of what they were expected to do and what the organization expected out of them. Working under the assumptions that your employees are out there to rob you and then pushing constant deadlines at them so that they don't miss-utilize their office time is outright stupidity which does nothing other than encourage the infinite loop of failure within the organization and the software development world in general. 

Deadlines Driven Development is for a team of Dummies. For everyone else who is decently smart, there is communication, collaboration and successful implementations.

When acquaintances and distant relatives strike a conversation with me in parties and during these discussions want to know what it is that I do for a living, I tell them that I read, talk, listen and besides doing all of that, I write. The reply often results in a confused acquaintance or an even more confused distant family member looking at me like I am an alien with a third eye when in-fact I'm just passing Zen-line statements that you would usually hear from Yoda.

I am no-where close to being as insightful as Yoda but labeling myself as a programmer, project manager, technical architect or any fancy designation sounds like an incorrect introduction of my true self.

When I'm not reading, talking and listening to others in development teams, 'writing' describes what I do rather well:

1. I write code.
2. I write about code.
3. I write about my experiences with reading, talking and listening to others.

Of course, this blog reflects my love for reading, talking, listening to others and writing. Going ahead I'll be exploring my love for all of these activities using stories with lessons to learn both from projects that I've worked on and the ones I've witnessed or seen from the outside. These are stories from my past with a fictional sugar coating and no direct names of organizations, clients or individuals.

Most of these stories will be real with a fictional coating. Others will be completely fictional with real lessons. I will weave and knit words to confuse you just so that you don't find out what's real and what's not; but my intent isn't evil here. The intention is to share with you, dear reader, lessons learnt during my software development career in ways that are exciting and fun.

We will, for the sake of creative imagination use a few common characters and personas in all the stories that we publish on this blog from this point on. This post is about describing some of those personas and laying down the basic framework for the stories and posts to come.

Multiplitaxion Inc.

Multiplitaxion Inc, is a fictional company where things just don't seem to go right. The name, as usual, was suggested by my very smart nephew when he was first taught multiplication. The guy had mastered the idea of multiplication rather well and could multiply numbers decently well; but there was a 'little' bit of a problem. He was having a hard time pronouncing multiplication; so he came up with Multiplitaxion. The name was way too cool to be wasted. That's when Multiplitaxion Inc, was born.

The idea of Multiplitaxion Inc, was inspired by three different sources.

1. Lots of Organizations - During a point of time in my career I was hopping from one client office to other and visiting multiple so called big software development houses. I was realizing one thing; The bigger they were the bigger their stupidities were. There were a very few who were maintaining the magic touch of small but most of the bigger organizations were hugely big even when it came to their stupidities.
2. Office Space - This was a comedy that a colleague of mine introduced me to. The movie had a fictional organization called Initech; which was a pretty funny representation of the kind of stupidities that happen in a huge number of software development shops.  
3. The Poster - I remember a conference room where project status was analyzed and decisions for future versions were taken; I remember a single conference which continued for a very long time where I was barely close to catching my zzzzz, hardly ever spoke and kept staring that this poster on the wall. 

You would think that anyone with the common-sense and sense-of-humor to stick a poster of this sort in the conference room would be careful about the stupidities they would indulge in. However, I sat in the conference room, waiting for a very lengthy meeting to finish, where everyone involved tried to freeze the requirements for the next version followed by a finger pointing exercise of why the first version didn't meet all the requirements. I sat there and admired the idiocy that happens even when some reasonably smart people come together in large groups with conflicting interests. Multiplitaxion Inc, isn't real; and neither does it represent one single organization form my past; but the problem this fictional little organization faces are real. Very real.

Fred

To be honest Fred is not my brain child. He belongs to Venkat Subramaniam and Andy Hunt who conceived the idea of Fred in their book The Pragmatic Programmer where they described Fred using a simple example:

Suppose Fred is given a programming assignment. Fred types in some code, tries it, and it seems to work. Fred types in some more code, tries it, and it still seems to work. After several weeks of coding this way, the program suddenly stops working, and after hours of trying to fix it, he still doesn't know why. Fred may well spend a significant amount of time chasing this piece of code around without ever being able to fix it. No matter what he does, it just doesn't ever seem to work right. Fred doesn't know why the code is failing because he didn't know why it worked in the first place. It seemed to work, given the limited "testing" that Fred did, but that was just a coincidence. Buoyed by false confidence, Fred charged ahead into oblivion. Now, most intelligent people may know someone like Fred, but we know better. We don't rely on coincidences—do we?

I loved the idea of Fred and went ahead and said that there's a little bit of Fred in all of us. But then throughout my career I've also met perfect embodiments of Fred. This blog is not about criticizing Fred. Instead it's about analyzing what Mr. Fred does and learning from his stupid mistakes; but before we do that it's really important that we know Fred; which is why, dear reader, I present to you, Mr. Fred.

Fred, Meet the world. World, Meet Mr. Fred.

Pops

This one's not my brain child too. This is the brain child of Michael Lopp in his book Managing Humans where he referred to himself as Rands:

The icing on this semi-fictional cake is Rands. This is a name I began using in the mid-’90s for my virtual presence; when I began web-logging about management, the name stuck. Think of Rands as your semi-fictional guide walking you through the fake stories of fake people that have had incredible relevant (yet fake) experiences. Rands has a bit of attitude, but, then again, so do I.

I'm of Indian origin and I carry my Indian origin and accent rather well when I travel around a flat world. I'm definitely not an Indian call center employee with a thick Indian accent trying to assume an identity of 'Sam' or 'Harry' and making a fool of myself.  My real name is Rajiv Popat and I have no complexes what-so-ever about that.

Pops however, is a rather funny identity which allows me to step out of myself to be just as critical of myself as I am of others including Fred. Then the idea of Pops is even more appealing when I go ahead and make random mistakes which, of course, I do all the time. I can blame it all on Pops. After all, it's not me making those stupid mistakes. It's Pops.

More Personas

Of course, Multiplitaxion Inc, Fred and Pops are a good starting point for story telling; but I do realize we'll need more characters as we move ahead. I'll be making changes to this post as I go ahead and introduce other characters in future.

Consider this page the Introduction to all of the characters that you'll meet in the stories about management and software development from Pops at ThousandtyOne.com.

Every time I want to go ahead and add a new character to the story I'll just go ahead and add him here. I know I'm not supposed to be going back and editing a post that has already been published, but it's not me who'll do that, remember? It's Pops. The guy just doesn't understand blogging rules all that well after-all.

One of my seniors told me something on the lines of - "Senior engineers are supposed to wear multiple hats and juggle multiple tasks at the same time"; the issue at hand was that I was not 'utilizing' the senior most members in my team to their fullest extent by not giving them multiple tasks to work on all at once. According to him, even though I had promoted these individuals I wasn't tapping into their full potential by pushing them to undertake multiple tasks at once.

This particular senior of mine believed that all senior members in all teams should multitask and if they couldn't, they weren't senior enough to be promoted to the position of senior programmers. He wanted, expected and demanded that anyone who was to be promoted as a senior programmer had to be a serious, mind-blowing, kick ass juggler when it came to handling multiple tasks as once before he was lifted to the position of a senior programmer or promoted.

During the early parts of my career I had been a ruthless multitasking guy myself. The obvious expectation from someone like me was that I would push multiple members in my team towards multitask as well, but then something creepy happened. All the multitasking that I was doing was starting to have it's toll on me.

There would be days at a stretch when I would stare at the monitor losing a track of what it is that I was doing and what I was supposed to be doing next. I had taken multitasking to the next level and was suffering through what can be, most aptly, defined as the ALT-Tab-Syndrome. That is when I started realizing how expensive a human context or task switch was.

In his article on human task switch Joel Spolsky explains how harmful human multitasking is by comparing it with multitasking on computers. He argues that both are expensive and the only thing they do is provide is a perception of speed, not actual increase in speed or productivity. He explains:

OK, back to the more interesting topic of managing humans, not CPUs. The trick here is that when you manage programmers, specifically, task switches take a really, really, really long time. That's because programming is the kind of task where you have to keep a lot of things in your head at once. The more things you remember at once, the more productive you are at programming. A programmer coding at full throttle is keeping zillions of things in their head at once: everything from names of variables, data structures, important APIs, the names of utility functions that they wrote and call a lot, even the name of the subdirectory where they store their source code. If you send that programmer to Crete for a three week vacation, they will forget it all. The human brain seems to move it out of short-term RAM and swaps it out onto a backup tape where it takes forever to retrieve.

In his post, Joel basically pushes the idea that human multitasking in all it's form is not as productive as working on one-thing-at-a-time. In fact Joel feels it's harmful.  

G. Wade Johnson argues that what Joel is talking about can be described as preemptive programming. Wade on the other hand, introduces another form of multitasking where he talks about utilizing multitasking to utilize idle time:

An interrupt forces a task-switch. You incur all of the overhead of changing state, just like in the time-slice case. In fact interrupts are worse for humans than for computers. If you know you will be changing tasks after lunch, you can generally aim for a good place to stop. With an interrupt, you have no choice of when it occurs. On the other hand, I try to keep one major task and two or three minor tasks on my plate at all times. This way, when something causes me to block on the major task, (waiting on technical or business input, lack of some resource, a design problem that I just can't seem to beat right now) I can spend some time on the minor tasks. Every minor task I complete, is one more thing that actually gets finished. That way I don't spend the blocked time busy waiting (browsing the web, reading slashdot, etc <grin>).

As valid as Wade's point seems, I've been a first hand example of what happens when you try to utilize and squeeze out every second of your idle item. Human RAM's are relatively limited in size, writing a few functions, firing a build that is going to take a minute to fire, reading a blog-post in that one minute and coming back to the code when the build is complete with all the variable names, function names and class names you were working with fresh in your head doesn't sound real life as well.

Kathy Sierra believes that the perils of multitasking aren't just limited to lowering the quality of the tasks that you are multitasking. According to her multitasking may have perils which are much more profound. She explains:

Where I once believed that the myth of multitasking was about time (that doing four things simultaneously takes much longer than to do those same four things in sequence), scientists now know it's also about quality. And it gets worse... it's not just that the quality of those four things in parallel will suffer, it's that your ability to think and learn may suffer. Some researchers believe that all this constant, warp-speed, always-on multitasking is causing young people, especially, to become less able to follow any topic deeply.

Kathy has indeed done her research on the topic really well. Go ahead, browse through her post and you'll get everyone from The Time Magazine to Jordan Grafman, chief of the cognitive neuroscience section at the National Institute of Neurological Disorders and Stroke, telling you that multitasking and being involved in too many things at once is harmful.

While I see countless young and ambitious engineers wanting to take on more and more projects, bigger and better challenges, grow in life and go places all at once, Kathy's post does a good job at reminding them their physical and mental limitations:

Whenever I talk about the big myth of multitasking, people always come up to tell me how they themselves just "have the kind of brain that can do this." Riiiiiight. They don't. I don't. You don't. And maybe you'd realize it if you turn off your cell phone, disable IM, mute the little "ding" alarm that says you've got email, and just sit there for a few moments. The big problem for most young people, it seems, is that they don't know how to "just sit there." They get the shakes after just a few minutes without media stimulation.

What ever be the form of multitasking that you're doing; chances are that it is doing you or your work more harm than it is doing you or your work good; and that includes the kind of multitasking Wade explained in his post. As developers we tend to believe it's beneficial and we like to think we can handle it really well; but the truth of life is we can't. Kathy explains:

One of the most interesting things discussed in the Time article is that neuroscientists have established the specific area of the brain responsible for context switching. And unfortunately for some of us, it appears that this part of the brain performs less well as our brain ages. In a nutshell, the older we get, the less quickly and effectively we can multitask. But... most parents of teenagers already know that we have no frickin' idea how our kids manage to do what they do simultaneously. The key issue, though, is that while we now know they're better at it than we (the parents) are, they aren't half as good at it as they think they are. And chances are, you aren't as good at it as you think you are.

The next time you fire a build and you feel this yearning temptation to read a blog post or reply to an email, ask yourself if you can handle the task-switch and come back to the build elegantly and completely when it's complete? If not, maybe you're just better off sitting there, admiring the build getting fired and slowing down a bit as you think about the next few lines of code you are going to write. After all you'll hardly get anywhere with just random multitasked speed.

If you're leading a team, if there is one lesson you can take back from this post, Joel describes it rather articulately:

As it turns out, if you give somebody two things to work on, you should be grateful if they "starve" one task and only work on one, because they're going to get more stuff done and finish the average task sooner. In fact, the real lesson from all this is that you should never let people work on more than one thing at once. Make sure they know what it is. Good managers see their responsibility as removing obstacles so that people can focus on one thing and really get it done. When emergencies come up, think about whether you can handle it yourself before you delegate it to a programmer who is deeply submersed in a project.

Are you still expecting your team members to multitask before you promote them? Are you only promoting your team members based on their multitasking abilities? Here's my advice to you: Don't use multitasking abilities as a measure for promotion.

Are you knitting your brows and telling yourself what a moron I am because you think that as you climb up the corporate ladder you have to multitask? Well, Multitasking is a real need in my job profile as well. I tend to give a very strong perception of multitasking when I work on multiple projects at once; but that's exactly what it is - a perception. Behind the curtains; I try my best not to multitask as long as possible.

A colleague recently told me that he was planning on picking up Ruby on Rails in the next three months while he also worked on something learning something else during those three months. My immediate response and suggestion to him had been that he should buy a Ruby On Rails book, stop learning the other thing that he was planning on learning and just focus on Ruby On Rails and finish it off in the next one and half month instead of three. Then he should consider moving to something else.

This is but, one simple example of avoiding the perils on multitasking. All situations in your life may not be as simple as this and I clearly don't have all the answers, but the biggest favor that you can do yourself is by starting to realize that human task switching is expensive and that multitasking in a real problem in our lives. Once you realize that, work consciously towards finding ways and means to avoid multitasking every time you can see an opportunity to avoid it.

Bottom line; whenever you have an option to avoid multitasking, avoid it.

The trick is to blind out everything else when you start with a task at hand and not look at anything other than the task as had till the task comes to a logical end where it's safe to switch to something else without having to keep too much about your first task in your head. Till you reach that point, don't open your outlook; close your browsers and if that stupid phone is ringing continuously switch it off too. Once you reach a logical end where you know it's ok to switch to another task, then by all means do; but random aimless multitasking in attempt to do too much in too little time gets you nowhere. Absolutely nowhere.

The Perils of multitasking are huge; both in software development and life in general. Multitasking is truly impacting and preventing us from being successful and happy; but you don't have to take my word for it; see Scott Berkun talk about attention and sex to help you decide for yourself.

During my school life, I quit my karate lessons within a couple of years or learning and practice. Today if I got into an award confrontation requiring self defense here's how I would defend myself: I would run, as fast as I could. I would run so freaking fast that I wouldn't even look behind. That's how much karate I remember.

On the serious side of life, my reasons for my early interest in martial arts, besides being physical, were also philosophical. Martial Arts, in all it's forms has ideas and concepts which can be borrowed and used for life and software development. This post is about one such concept and if you are a programmer, this post is also about asking a very important question: are you a code samurai?

Martial Art gurus believe that a perfect weapon is one which becomes a seamless extension of the warrior's body and brings him greater reach, humility and grace. On the same line of thought, a perfect warrior is one who can blend himself with the perfect weapon. In other words, in the world of martial arts it is believed that to become a great at a warrior you must pick the great weapon and then reach a stage where the warrior and the weapon become one.

I've often announced that software developers need to turn themselves into warriors and one man armies. If you look at it, your machine is your only weapon against the countless enemies of software development. Yet, I rarely find programmers who are one with their machines. A huge number of programmers on the other hand, are hunting and pecking for keys on their keyboards as they type and fumbling with the mouse as they hunt for points on the screen to click.

I've always said that hitting the window key and typing iexplore is fast. It's faster than reaching out for the mouse and clicking that Internet explorer icon but Jeff Atwood provides a much more compelling example:

Let's assume that we're typing some text into a document of some kind, and we wish to save the document we're working on. (I could argue that the user should never have to explicitly save anything, but humor me.) If it seems ridiculous that the mouse method: Take your right hand off the keyboard Place your right hand on the mouse Mouse over to the File menu Click File