some top tips to piss off your colleagues

Every day you stumble into work and go about your daily routine. You’re reasonably sure that you’re a model work colleague and everyone likes you. But this is pretty boring right? So from this day forward you decide to make other people’s life a misery. Here are a few handy tips guaranteed to help you with this.

(A short note: in case confusion ensues the tone of this article is meant to be somewhat tongue-in-cheek! And please let me know of any annoyances that I may have missed in the comments 🙂 )

Constantly receive incoming phone calls: to be honest it doesn’t even have to be constant, just enough to make it appear constant to those sitting around you. I have no real problems with people talking around me or even playing music out loud (as long as it’s not all the time), but the torture of constantly hearing a one-sided conversation is exasperating. For maximum effect, I suggest you have a really bad ringtone, and make outgoing calls with regular frequency as well.
Take that chicken curry back to your desk so everyone can smell it at lunchtime: I can’t work out whether this is the thing that annoys me most. There is nothing worse than sitting down to do some work and some dude slaps his lunch down on the table 2 feet away. OK, eating certain things at your desk is fine, but there are others that should just be outright banned, and it doesn’t take a genius to figure out if you are eating one of those things. Or maybe it does! My suggestion to obtain the maximum effect with this one is to leave it sitting on your desk for a bit to “cool down” prior to eating it.
Constantly ask people the same questions (or make the same mistakes): I know this one affects more than just me – I will elaborate. Imagine sitting next to someone who constantly asks you the same questions about how to do something. OK, at first they were new and you answered with glee, but it’s been two years since this person started in the job and they still ask you how to the most simple tasks (like how do you build the software). Not only that but when you tell them they always experience a problem, the same problem, and ask you why it’s not working. This is guaranteed to make people start muttering under your breath at you as soon as their name leaves your mouth. Note: This works best if you don’t say their name too loud at first and just lightly let it drift off your lips. This will give the “pink panther effect” where they will gradually think they are going insane. Those who cannot learn from history are doomed to repeat it.
Find out the names of new buzz technologies, then constantly suggest the inclusion of such things in your app, especially if they are not relevant: remember you don’t need to know what the new technology does or the advantages/disadvantages of it – in fact it’s better that you don’t understand what they are, this heightens the effect. For example, say you want to use AJAX in your legacy desktop COBOL application. To make this even more powerful don’t listen to people when they try to tell you that it’s not relevant, just state “it is” and then bring it up again in the next meeting.
If you’re a manager, have favourites: this is just soooo cool to do if you are a manager. There is literally no better way to piss off those people who are not on your favourites list. If you want people to really talk about you, this is the one to go for. For added value, place all those that you don’t really like in a maintenance team, fixing all those pesky bugs that your favourites create.
If you’re not a manager, and your manager has a favourites list, try to be on it: everyone hates a brown nose and this will easily get you straight to number one spot of your colleagues diatribe without a shadow of a doubt. For this to be especially effective you have to be on that list because you know nothing, but are not going to let that get in the way of your career. Once you are on it though, try to do things that you know will annoy other people, but your boss will let you away with because you are his favourite, e.g. show up late for stuff.
Keep meetings running on longer than they should: if you think a meeting is nearing its conclusion, try and extend it for at least another 30 minutes – you can do so by going over the same points that were discussed in the previous hour of the meeting.
If you’re a manager, send programmers on courses they will really really hate: one course that will probably do the trick is communication skills. Ensure that the course has lots of role playing, and drops the average programmer waaaaaay out their comfort zone. To really rub it in, make them write a report about it when they get back. Then when they give you the report, make it obvious that you are never going to read it anyway.
Make people feel completely uncomfortable if they have to ask you a question: the key to this is to make them feel STUPID. Some possible tips with this are to sigh loudly when they get to your desk; don’t make eye contact when they speak to you, just keep typing and looking at your screen while talking to them; speak to them as condescendingly as possible, phrases such as “it’s obvious!” and “everyone knows that!”, normally hit the mark; and finally show disdain toward any ideas they come up with. Also, never finish the conversation by confirming that they have actually understood what you have just said, just sit in silence and see how long it takes for them to realise the conversation is over. Essentially you are trying to be as unapproachable as possible.
Occupy other people’s space: just start to gradually leave pieces of paper and books on the person’s desk next to you. Don’t limit it to objects though, try to put yourself in their space as well. Leaving empty mouldy coffee cups, and half eaten food will likely yield a reaction, just don’t let this stop you.

programming language obsession makes you look stupid

It appears that many people seem to have too much of their life wrapped up in a particular programming language. You only need to look over at dZone, Reddit or Digg to see this fandom in all its glory. All too often we find articles about why such and such a programming language sucks. However, just because a language sucks for one (or a couple) of particular reasons, it doesn’t mean it is not useful in general. It’s like me saying computers suck because they crash. However, just because my computer crashes from time to time doesn’t mean it’s not useful.

I just find the whole religious aspect to a language rather pathetic. The result often leads to the inappropriate choice of language for development of an application, simply because the individual’s voice that is heard the loudest makes the decision. Ok, if any language will do then just go with whatever you are comfortable with, but stop yourself bitching about other people’s choice of language.

For example, the number of times you hear people saying dynamic languages are no use, for a plethora of reasons, is stunning. You would think that no one had ever developed anything of reasonable size and scale in these languages. It’s not as if most of the largest websites on this planet have not been written in PHP/Python/Ruby, yet you still read articles where people are saying where such a feat is likely to lead to catastrophe. Stop doing this it makes you look stupid.

The same can be said for those that diss Java. OK, I think it’s possibly a poor choice for those considering a startup web business (basically if you are going to be considering shared hosting Java as an option on this platform is nonexistent), but there are many places where the use of existing libraries written in Java make it the ideal choice for an application. An example of this can be seen in what I’m currently working on, which is an application that uses constraint programming techniques. There are a few such libraries in other languages but the most mature and feature rich (and free) are in Java so sense dictates you use Java.

Essentially my bug bear boils down to people choosing a language for the wrong reasons, more often than not due to blind faith rather than education. Don’t just use a language because it is popular, use it because it best fits the job needing done. Popularity can come into it though, because at the end of the day you might wish to tap into a large set of existing programmers, or you may want to attract the brightest young talent who want to work in what’s popular/new. Just don’t let it be the only thing that dictates your choice.

Unfortunately, regardless of however many blog post or articles people read and write, I feel that we are never going to remove this inherent language evangelism. Maybe the industry would be in a far better position if we were all language agnostic. Can you imagine how much more work would get done if people spent the first two months of a project actually doing work rather than arguing about what language it should all be written in.

forgive me for i have sinned, it’s been two years since i last used an ide

Right, this ain’t as bad as it seems, honest! But in the last two years I have pretty much coded Java without the use of an IDE, albeit I wasn’t doing too much Java, all the same though, I was doing pretty much everything by hand. Why I hear you ~~ask~~ SCREAM!

A little background first. In my first job I used Visual Studio (6!) almost exclusively and being just out of uni with no prior experience of any IDE, I thought it was brilliant. Time has move on since then and if we all face facts VS is still a top (the best?) developer tool. On to my next job where development was done in XEmacs and debugging with some Sun IDE, god I can’t remember the name of it for the life of me, it was ancient at the time, Work(something) I think? This was going back a step. However, I got to love XEmacs, and within our organisation we had quite a few Emacs Lisp scripts that allowed us to automate adding things like header files or creating classes. Then when I moved onto Java development near the end of my time there I just stuck with XEmacs – there wasn’t too much else around at the time (2002-2003) that wouldn’t run on a dog of a Sun U10. After this I went back to uni to do a PhD (that’s back to Grad School for my readers over the Atlantic) where I done a fair bit of Java in my first year but largely went without programming after this. I always think it seems bizarre that you can do a PhD in the area of Algorithms and most folk barely write a line of code – and some don’t even know a programming language, no joke! Fortunately though I done a fair bit of contracting work throughout my graduate studies using Visual C++ (.NET 2003 then onto .NET 2008). Also, in the last year or so, I have managed to do quite a bit of JavaScript programming and some PHP stuff – again non IDE based.

Right not sure whether the background was need but you got it anyway. So where was I. Yeah, I tried Eclipse at the start of my time as a graduate student and just thought it sucked! It was slow, froze often and I ended up back with trusty old XEmacs. I did miss a debugger though – especially as I was using VS for the contracting work. I just couldn’t face Eclipse though.

Now skip forward around 4 years to a few months ago and I find myself writing loads of Java again. By this time I had ditched XEmacs for the very nice e text editor – I seen a Google developer videocast and in it they were using TextMate and I thought it looked awesome, so I wanted a windows version of it which is what e promised, and delivered. This was great, it did have some nice autocompletion stuff but I was still doing quite a bit manually. I never really felt that it was a problem though, as I just got on with doing what I was doing. Then after a couple of conversations with people I gradually started thinking that I may be missing out on stuff that the IDE provided, so I decided to give it a go.

I tried Eclipse and I still think it sucks. It’s not that slow anymore but I can’t put my finger on why I don’t like it, just tastes I suppose. Or maybe it was because I had tried NetBeans 6.5, which I think is rather excellent. I have no doubt Eclipse does all the things that NetBeans does but I could “figure out” NetBeans quicker.

For starters, it made it pretty clear where I should put my unit test files, you simply click add on the “Test Sources” tree. Easy. When I added my existing source files it didn’t seem to have the same bizarre problem that Eclipse was giving me for my package name. Then when I wanted to run one of my tests it seemed easy I just right-clicked and selected Run File. I mean I’m not saying you can’t do these things in Eclipse but it certainly wasn’t as easy as doing them in NetBeans, so why go with Eclipse? I won’t go on further but essentially getting started in NetBeans just seems easier than Eclipse, which has got to be the single most important thing for gaining new users.

All that said and done, my general point is that boy have I been waaaaaaay more productive with the IDE over using an editor and the old System.out.println style of debugging! I would say the key elements to this improvement have been intellisense, automatic compilation (probably a fancier word for it), ease of unit testing and of course a nice shiny debugger (I had tried JSwat as a stand alone debugger at first but it constantly failed to repaint its window).

There are a few things that annoy me about both Eclipse and NetBeans, the first is the color themes. With e it is so easy to change themes and plenty of themes available – I really need a dark background for developing. However, it’s a royal pain in the ass with both of the above IDEs. Furthermore, NetBeans gave me a laptop destroying moment where I deleted files from the NetBeans project and expected it only to delete them from the actual project. No, afraid not, it deleted them from the file system, without making it obvious it was going to do this. I was seconds away from throwing my laptop against a wall, seriously!

Apart from that though it really has been a bonus switching to an IDE. Those of you out there that are thinking a text editor and println will do are just kidding yourself on – like I was. Those using an IDE are going to be way more productive than you are. Now if we only had a decent IDE for every programming language, we all have a dream right?

the secrets to obtaining a happy programmer

The ideal working environment for a programmer is an topic which has received considerable attention. What we (programmers) normally idolise after are, amongst other things, (multiple) large monitors, Herman Miller Aeron chairs, private offices, break-out rooms, and, of course, the best tools for the job. Joel Spolsky, the Godfather of programmer satisfaction, went even further and gave us the Joel Test for assessing a prospective employer. However, are the above all that it takes for programming nirvana? Probably not.

First up, I would love to experience an environment where each and every one of the things mentioned above was in place. However, in my career so far, I have yet to work in an environment where these things have been par for the course, and maybe I would be content with such a work environment. I’m pretty sure I wouldn’t though. Not because these things aren’t good but there is a vital ingredient that can make these things irrelevant.

So what is this ingredient? Well it’s FUN, or lack of it. Yes a fun workplace! I’m sure there will be those out there that think work isn’t supposed to be fun, well ask yourself why. Fun doesn’t necessarily mean that no work gets done – the contrary in fact. It’s a place where like minds can sit and create and innovate about things they find interesting. Now here is our first problem.

Essentially fun is the environment combined with the people. However, all too often we find ourselves in an environment where the people are not like minded. What surprises me most is that in an office full of software developers only a handful (or less) may be genuinely interested in software development. I’m not sure if I have just worked in the wrong places – however friends have confirmed a similar problem. It’s not simply that you couldn’t sit and talk to certain individuals about software development, it’s that you pretty much had difficulty talking about anything. It was often like talking to a baked potato.

For me this not just a job, software is one of my top three interests (along with music and cycling, for those who are nosey 😉 ). Wouldn’t it be nice if an employer could respect this – I’m not saying they all don’t, but most don’t, it makes it easy to see why Google attach such an importance to their culture.

All this is not to say that I think we should all be the same, it may be the case that you have to turn good people away because they simply don’t fit your culture. I think the culture is that important. This has been shown in the past by the likes of Richard Branson whose music empire started by providing an environment (in essence a community) where both the employee and consumer found it fun to gather in his record shops. Certain universities have also found this valuable over the years.

So essential we can have all the goodies we like, but unless we are working with people that are Smart and Gets Thing Done (or preferably Done and Gets Things Smart), and fit our culture, then maybe we are never going to reach our programming nirvana.

7 ways to write beautiful code

I’ve noticed that the developer and designer community appear to be obsessed with lists. Is this for a reason that I have somehow missed? For example, over at dZone, 2 out of the top 3 most popular articles are lists: 15 CSS Tricks That Must be Learned and 10 Dirty Little Web Development Tricks – incidentally I liked both articles so I seem to have this obsession myself. OK this is not that many but hey I’ve seen loads of lists elsewhere. Anyway, I thought I would embrace this culture to feed my own addiction and I have detailed 7 (I was only going to do 5, and 6 was out as it’s not prime 😉 ) ways to write beautiful code.

First things first here, I’m talking about pure aesthetics, nothing else. As I have said previously, good code starts by being something other people find easy to read. In fact, Jeff Attwood had a blog post comparing coding to writing citing several sources. I urge you to take a look.

Anyway on to my list.

Return from if statements as quickly as possible.

For example, consider the following JavaScript function, this just looks horrific:

function findShape(flags, point, attribute, list) {
    if(!findShapePoints(flags, point, attribute)) {
        if(!doFindShapePoints(flags, point, attribute)) {
            if(!findInShape(flags, point, attribute)) {
                if(!findFromGuide(flags,point) {
                    if(list.count() > 0 && flags == 1) {
                          doSomething();
                    }
                }
            }
       }
    }   
 }

Instead we can change the above to the following:

function findShape(flags, point, attribute, list) {
    if(findShapePoints(flags, point, attribute)) {
        return;
    }
 
    if(doFindShapePoints(flags, point, attribute)) {
        return;
    }
 
    if(findInShape(flags, point, attribute)) { 
        return;
    }
 
    if(findFromGuide(flags,point) {
        return;
    }
 
    if (!(list.count() > 0 && flags == 1)) {
        return;
    }
 
    doSomething();
 
}

You probably wouldn’t even want a function like the second one, too much going on (see point 7), but it illustrates exiting as soon as you can from an if statement. The same can be said about avoiding unnecessary else statements.

Don’t use an if statement when all you simply want to do is return the boolean from the condition of the if.
Once again an example will better illustrate:
1 2 3 4 5 6 7 8
function isStringEmpty(str){ if(str === "") { return true; } else { return false; } }
function isStringEmpty(str){ if(str === "") { return true; } else { return false; } }
Just remove the if statement completely:
1 2 3
function isStringEmpty(str){ return (str === ""); }
function isStringEmpty(str){ return (str === ""); }

Please use whitespace it’s free!

You wouldn’t believe the amount of people that just don’t use whitespace – you would think there was a tax associated with using it. Again another example and I hesitate to say this but this is from real live code (as was the first example), all I have done is change the programming language and some function names – to protect the guilty:

function getSomeAngle() {
    // Some code here then
    radAngle1 = Math.atan(slope(center, point1));
    radAngle2 = Math.atan(slope(center, point2));
    firstAngle = getStartAngle(radAngle1, point1, center);
    secondAngle = getStartAngle(radAngle2, point2, center);
    radAngle1 = degreesToRadians(firstAngle);
    radAngle2 = degreesToRadians(secondAngle);
    baseRadius = distance(point, center);
    radius = baseRadius + (lines * y);
    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);
    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);
    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);
    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");
    // Now some more code
}

I mean I won’t bother putting an example of how it should be – it should just be sooo bloody obvious. That said, I see code like this ALL the time and so certain people do not find it that easy to judge how to use whitespace. Screw it, for them I will inject some whitespace into the example and it’s shown below.

function getSomeAngle() {
    // Some code here then
    radAngle1 = Math.atan(slope(center, point1));
    radAngle2 = Math.atan(slope(center, point2));
 
    firstAngle = getStartAngle(radAngle1, point1, center);
    secondAngle = getStartAngle(radAngle2, point2, center);
 
    radAngle1 = degreesToRadians(firstAngle);
    radAngle2 = degreesToRadians(secondAngle);
 
    baseRadius = distance(point, center);
    radius = baseRadius + (lines * y);
 
    p1["x"] = roundValue(radius * Math.cos(radAngle1) + center["x"]);
    p1["y"] = roundValue(radius * Math.sin(radAngle1) + center["y"]);
 
    pt2["x"] = roundValue(radius * Math.cos(radAngle2) + center["y"]);
    pt2["y"] = roundValue(radius * Math.sin(radAngle2) + center["y");
    // Now some more code
}

Don’t have useless comments:

This one can get quite irritating. Don’t point out the obvious in comments. In the example below everyone can see that we’re getting the students id, there is no need to point it out.

function existsStudent(id, list) {
    for(i = 0; i < list.length; i++) {
       student = list[i];
 
       // Get the student's id
       thisId = student.getId();
 
       if(thisId === id) {
           return true;
       }
    }
    return false;   
}

Don’t leave code that has been commented out in the source file, delete it.
If you are using version control, which hopefully you are – if not why not! – then you can always get that code back easily by reverting to a previous version. There is nothing more off putting when looking through code and seeing a large commented out block of code. Something like below or even a large comment block within a function itself.
1 2 3 4 5 6
//function thisReallyHandyFunction() { // someMagic(); // someMoreMagic(); // magicNumber = evenMoreMagic(); // return magicNumber; //}
//function thisReallyHandyFunction() { // someMagic(); // someMoreMagic(); // magicNumber = evenMoreMagic(); // return magicNumber; //}

Don’t have overly long lines.

There is nothing worse than when you look at code that has lines that go on forever – especially with sample code on the internet. The number of times I see this and go ahhhhhhhhhh (I’ll switch to Java for this, as generics makes this particularly easy to do):

public static EnumMap<Category, IntPair> getGroupCategoryDistribution(EnumMap<Category, Integer> sizes, int groups) {
        EnumMap<Category, IntPair> categoryGroupCounts = new EnumMap<Category,IntPair>(Category.class);
 
        for(Category cat : Category.values()) {
            categoryGroupCounts.put(cat, getCategoryDistribution(sizes.get(cat), groups));
        }

I’m not suggesting the 70 characters width that you had to stick to on old Unix terminals but a sensible limit like say 120 characters makes things a little easier. Obviously if you are putting sample code on the internet and you have it within a fixed width container, make it easier for people to read by actually having it fit in the container.

Don’t have too many lines within a function/method.
Believe it or not a few years ago now an old work colleague exclaimed that Visual C++ was “shit” as it didn’t allow you to have a method with more than 10,000 lines. I kid you not – well ok I can’t remember the exact number of lines but it was huge. I still see this time and time again where a function/method is at least 50 lines long. Can anyone tell me this is easy to follow? Not only that but it normally forms part of an if statement that you can never find the enclosing block because you are scrolling. To me anything over 30-35 lines is pretty hard to follow and requires scrolling. My recommendation is if it’s more than 10-15 lines consider splitting it up.

This is by no means an exhaustive list and I could have gone on longer – in fact my abolish the switch statement motto would have been number 8 if I had not already mentioned it before. However, it has to end somewhere but feel free to state your own annoyances and maybe I can update the post with some more.

Over and out.

abolish the switch statement

I can’t explain how much I hate the switch statement. I often do everything and anything to avoid using it. I just think that it makes code very very ugly. Moreover, the amount of times I have seen people using it when they only have two cases, you just wouldn’t believe me! Let’s look at an example in Java:

switch (n)
{
    case 0: 
       System.out.println("I'm zero");
       break;
    case 1:
    case 3:
    case 5:
       System.out.println("I'm odd");
       break;
    case 2:
    case 4:
       System.out.println("I'm even");
}

Surely no-one can tell me this actually looks “nice”? I mean coding is all about looking nice and neat after all. You can give the compiler something that looks like dog meat and it won’t give a shit as long as it’s valid syntax. Code is ALL about us humans reading it. The above is also a simple example and switch statement are normally way more complicated than this.

The normal argument for using a switch is that it looks better than loads of if-then-elses, which I completely agree with as that looks ugly as well. Also, with Java (and others) you can only switch on integer values which is the height of annoyance. Furthermore, there can’t be a single person that has not suffered the “forgetting the break” problem on a switch statement. For the record, my main bugbear is the extra indentation the switch forces on me along with the fact that scrolling all the cases is frequently a nightmare.

So what am I proposing? Well what I tend to use to solve both the ugliness problem and the lack of support for switching on stuff other than an integer is a HashMap. I’m sure some are screaming “Am I hearing this idot correctly”!

I really do think this looks particularly nice when used in code and can reduce a massive sprawing switch statement in a method to one simple call. So what does this entail. First lets assume that we have a method that takes a string as an argument and depending on the contents of this string we perform a specific operation – this is a particularly common task. Let say we have a class like the following:

class Operations {
    // Operation is an interface with the method do attached
    HashMap<String, Operation> mapper;
 
     public Operations() {
        mapper.put("eyeSurgery", new EyeSurgery());
        mapper.put("heartSurgery", new HeartSurgery());
        mapper.put("heartKeyHoleSurgery", new HeartSurgery());
       // etc
     }
 
     /**
      * Carries out an operation, which is dependant on the value of op
      * and returns a string containing the results of this operation.
      */
    public String do(OpContext op) {
        return mapper.get(op.toString()).run(op);
    }
}

Now surely the code in method do looks better than a switch statement would? Obviously in this case you couldn’t even use a switch statement in Java, but even if the type of the HashMap key was Integer, I still proclaim this looks better. OK, you have the extra setup cost but it’s got to be worth it and should run fast enough for most needs. It also opens up the possibility of “switching” on any object based type rather than just an integer – presuming a sensible hash function being declared for your object. Obviously this is a simple example but hopefully it illustrates what I’m try to put across.

I’m not sure if this was really obvious and everyone is doing this already. Hopefully someone will get something out of this. So, down with the switch statement, long live the hash map!