Many many years ago when I landed my first coding job, I was amazed at how different working in a software development shop was different from what I had pictured in my mind.  At that time, I did not even graduated yet, I was in need of money and it seemed like a great opportunity so I took the job.  While driving to my new place of employment for the first time, I was running some scenarios in my head, trying to remember some tested and true algorithms, thinking of whole bunch of technical things that might help me impress my then new boss; what came as a complete surprise to me was the fact that I had no idea what the work was about.

After couple of weeks, I began to realize that many things that were part of my job were not covered in school at all.  I can’t really blame school for that, after all they were trying to give me as much information as they could about technical aspects – languages, algorithms and all that jazz, I myself had failed to learn the truth about real time work of a coder, and I did have opportunities to do so.  Later on when I became a manager and was interviewing people for coding positions, I realized that I was not unique in this lack of knowledge.  Most of the recent graduates were in the same boat that I was in years ago.

That time had passed, I learned a great deal from working on different development teams, I could probably be called a veteran of the game called software development, and today I wanted to post about things that I think any recent graduate should educate himself on:

• Time Management.
• Ability to produce accurate estimates
• Ability to write technical documentation.
• Dealing with customers – when times are good and bad.
• Dealing with co-workers in conflict situations.
• Learning is an ongoing process when coding

Lets look at those a bit closer:

Time Management

Time management  in my opinion is the most important skill a developer can have.  I would also add self discipline to this since the two are related.  It is just too easy to get distracted by things that are not really work – after all internet is right there.  Another point is getting way too involved in your project, spending way too much time on tasks that are not really that important.  It is business first, and we are all on a dead line.  Other people’s deadline is depended on you most of the time as well.  One of the biggest time wasters in  my life is email.  I get tons of messages a day, most of those need to be answered.  Most of my clients / co-workers expected me to get to that right away, well guess what?  That does not happen.  I am answering my emails at 10 am and at 4 pm.  If its urgent, people can call me, if they don’t know my phone number, then most likely it is not urgent.  It took a while to convince by boss and my client that this is the best approach to my time.  This works for me, I can’t guarantee that it will work for everyone.

Estimates

What happens most of the time is my boss tells me to code something – a feature, application, you name it.  He wants to know how soon can this be done.   In turn I go to coders and ask them – how long would it take you to do this?  Most of the coders are not able to give me an accurate estimate – and I can understand it – things happen, but could you be at least close?  I can understand if you are off by couple of weeks – my estimate will allow for that, but when you are off by month, that makes me look stupid, and guess who will look stupid next?

Technical Documentation

One of the things developers hate is to write tech documents – manuals, reports you name it.  But despite all that, you still are going to do it.  Hopefully it will not develop into full time job for you, unless you want it to.  I am not a big fan of doing it, but trust me, on top of what developers do, I actually write proposals, analysis papers, reports of various types and so on.  It is a bit of a challenge for me, since English is not my first or even second language.  So many times I had seen a talented coders who can’t write – and believe me, it creates a negative impression which should not be your goal here.

Dealing with customers

Let’s hope that in your career you will never have to speak to a pissed off customer.  We can hope all we want, but it will happen sooner or later.  If I had a penny for every time customer yelled at me, I would have a truck load of pennies by now.  I am not even going to mention a situation where a client demanded that I had  to buy lunch for his entire team simply because my plane was delayed.  I had customers tell me stuff like : “So it can’t do X, then your software is shit”.  Which was especially frustrated, because no sane person wold do X.  In all fairness, this is a way users respond to what we code, and we can’t possibly please everyone.  What I find even more frustrating is when customers do have issues, but won’t tell you anything and then the time to renew the contract is approaching and all of a sudden they don’t want to continue.  Feedback is good for you, even when it comes in a form of a pissed off customer.  Feedback is good because it will not only tell you what customers really want, but what your software is doing right.  I am not saying that you have to fold every time customer has something uncomfortable up his butt, you have to learn how to hold your ground and compromise if compromise is possible.

Dealing with co-workers

Most likely you won’t be working by yourself.  You will be in a team which would consist of several coders.  Most of us have our own personalities, favorite approaches, opinions and so on.  There are going to be conflicts and you will have to deal with it.  Conflicts are not necessary bad – at times it is the best way of solving difficult problems with features or code.  Listen, argue if you believe that you are right, but don’t start getting personal – keep in mind if the conflict is geared towards solving a coding issue, this is what you want to do.  If the conflict is about issues that are on a personal level – stay out of it.

Learning

The industry is constantly changing, there are new things coming out every day, you should be on top of the things that affect your work.  Read blogs, join a social network geared towards developers (dZone comes to mind) get yourself a mentor if you can, trust me, it will pay off.  Here is an example from my previous job – one guy just did not care, he did what he supposed to do, no learning, no progress.  The rest of the team would get raises every year, this guy – well, he did not.  Despite the fact that he was there longer then almost everyone else, his pay was the lowest on a team.  I was managing the team and tried to convince him that learning is good, he did not respond.  At the end of the day, if you will not progress, your financial compensation will not progress either.

I must admit, that this is not a full list.  You could probably come up with lots more, however to me this is what’s important.  I would love to hear from you on what you consider vital.

One of the things that drove me absolutely nuts when our department was in the same building as the rest of the company was the fact that nobody could quite understand what we were doing. Quite often we would get a data entry person storm into our office and demand that we fix their Outlook or install Unix on their machine (it turned out that he needed Putty, not a true Unix install). Usually these conversation started with “You guys are not doing anything, right?”. So many times I was trying to explain to everyone that it just does not work like this. We are not just sitting here pressing keys at random most of the time. Best and by far most common argument to support their need for our involvement that I heard was something like this: “It is not going to take long, could you just do this for me right now”. One of our duties was writing a variety of Excel macros for people(I should probably post some tutorials on this subject). After all when dealing with massive amounts of data, it is faster to write a macro then do something by hand. We did not mind doing macros at all, what we did not like is when the person was sitting on the project for weeks and then decided to approach us at the last minute. Client expects the project to be completed at 5 PM, so the analyst strolls into our office at 4:45. Never mind that it takes him about 3 hours to explain to us what on earth does he want macro to do. Never mind that it takes me couple of hours to code the macro in some cases(trust me, there were some huge macros). It had to be done and that is it.

Number of times we attempted to find a solution to this annoyances. For instance we created a little internal web site that would, in theory, help users solve many issues like setting their “Away” message on Outlook and server connection through Putty and such. I did this web site in about 3 days when my computer was send away for repair and I was working on an antiquated piece of hardware we found berried in a storage. Was this web site ever used? No, it was not. Office people would still storm into our office saying that they did not read the instructions as they would not understand it anyway.

The worst part of these interruptions was that it would completely break my line of thought. So you are working away on a complex algorithm with close to no documentation on the objects that have to interact together available. You are concentrated on the task 100 percent, not even noticing that that cup of coffee is now cold, and then all of a sudden you have someone storms in and demanding that you fix their radio right away, or else.

The idea that you just had about this nice piece optimized piece you are about to write is gone now. I must admit that couple of times I flipped. It ended up with me yelling at a poor data entry person, calling them names, questioning their intelligence and so on. After I usually worked from home for a day, but at home there was a urgent need for a game of soccer or emergency epic hide-and-seek battle with my kids. I do enjoy those, but working from home was not a big option from the point of getting any work done.

Few years have passed and then our lease was up. I knew that was the moment when inaction would cost me dearly; I begged and pleaded with my boss to get us a separate office. Likely he agreed with me, and for the last two years we are in a different building, about 40 minute drive away from the main office. At first, main office was really concerned with who would be helping them out with daily tasks, but after about a month they learned to do it themselves. That little web site was finally used on the regular basis. We were not bothered with those requests and could finally spent close to a hundred percent of our time on coding and related things. Our productivity sky rocketed, we were producing better code more quickly and everyone was much happier.

The point is – developers can’t be disturbed. It is a process where ideas and thoughts need to be followed and processed carefully to produce what could be considered good code. You must create a barrier between your coders and outside distraction to produce quality software, and after all it is the purpose of any development team.

Bad code we all do it.

Well, I had written my share of bad code. Couple of weeks ago I had to fix up a class that was written about 4 years ago. For a while I could not believe I wrote this, but the comments on top clearly identified me as a suspect. The thing is we all write bad code sometimes. If you never wrote any bad code, please raise the hand with which you did not do it.

So, going back to the story – I was looking at it and my first impulse was to try to hide it far away so nobody would ever have to look at it. My second impulse was to rewrite it. I figured, it would probably take me about 5 hours to redo this. I did not do any of it. Instead I brewed a fresh pot of coffee, put my pride far away, printed out copies of it for all developers in the office and decided to play a game. My team consists of 4 coders; two of them were with the company for about 3 years, 1 for about a year and one guy just started in September. So instead of hiding it or quietly rewriting it, I gave my guys the printout and asked them to find mistakes in the class. By the way, the comments that contained the name of the author were not printed.

“Who wrote this crap?” this was the first thing I heard. Then in a typical spirit of our development team there were suggestions on what should be done to the author. And finally there were suggestions, many suggestions. Some of those were good, some were pointless and some were plainly wrong but one thing stood out for me – we all came up with different things to solve the same problem. At the end the class was rewritten and suggestions from the rest of the team were used. After it was done, there was a noticeable performance improvement. Let’s say file X would take Y seconds to run through the original class, after the changes the same file X would take Y/3 seconds. I am talking approximate timing, never actually forced any performance testing. Oh yeah, at the end of it I told everyone who was the author. That did create some awkward silence for a minute or two.

Why did I do it – I was quite capable of doing the work myself. As a team lead, it might be a good idea to hide my own faulty code to keep my image, but instead I did the opposite. I choose to do this for several reasons:

• We are all stressed out, the project we are on. We all needed a break from it. This injection of new problem did wonders for the main project.
• I don’t really care about my image, in fact, I would prefer them not to think that I am incapable of making mistakes and can’t be considered a final authority. I wanted them to find their own solutions.
• We all contributed and the result was truly a collaborative effort.
• It was clear that we all have different approaches to the same solution.

The whole experience was good. Bad code is unavoidable, but if you learn from it, it was not just a bad code it was a learning experience.

When I joined RS team, well, there was no team.  There was Matt, the guy who came up with the concept and there was me.  Rosetta then was in v 1.2, so we did not have many features implemented, basically the app was so vanilla, we only had 2 clients.  We had lots of ideas, and very little time and patience to maintain some kind of development system that would help is stay on course.  On top of coding, we had to do sales and support plus we were expected to help everyone else with their computer related problems (like fixing Outlook and writing Excel macros).  All this left very little time for development, and we had potential clients breathing down our necks twisting our arms to get the features they wanted implemented soon.

We were working in a fire brigade mode, there were fires, and we had to put them out fast.  There was very little time to think about writing optimized and efficient code.  As long as it worked, it was good enough.  This might appear as a good model for someone with a new app, features are added quickly, we had releases quarterly, our client base grew and soon we realized that we don’t need to put out fires.  We still have a list of suggestions (which actually more like demands then suggestions) and we are working on those, but now there is no rush to get it done, so we are doing it properly now.  Matt is gone now, I lead development team, and we got enough coders to maintain a good pace and write quality code.  But the stuff that was written in the past is not going away.

Right now we are rewriting Rosetta from scratch.  We need to adapt to the new framework, plus Office 2007 and localization and let me tell you, it’s a lot of work.  To address the issues of the old code, and believe me, I was thinking about it for quite some time I came up with this weekly code reviews.  Now every week one of us takes a function from those old classes and rewrite it in the most efficient way the developer can imagine.  Then, the developer has to present his work to everyone, explain briefly what the class and the function is all about, what and why was changed as well as measurable benefits of the change.  I thought that first of all we will slowly start changing the code, which when done properly is a good thing, some of us get exposure to classes that we never worked with before and we would share some of or knowledge.  To start it, I decided to go first.

Picked up a function, shaved some time on execution, dropped a loop, did some smaller things.  Just to make sure everyone is paying attention put some goofy things with appending a space to a string and then trimming the end of it.  Everyone caught it right away; I guess the guys are responding to this new idea.  We’ll see how will it progress, but basically I would recommend this to everyone running a small development team as a good exercise and learning experience.