the real geek test

I’m sorry, I’m sorry, but I object to the use of the word geek. I’d always imagined that a geek was someone who was obsessive about computer programming. Lately though I’ve seen people use it in a way that is beginning to annoying me – it’s used to describe someone who simply uses the latest and greatest software or gadgets. This was brought to a head when I clicked a link in a tweet (thanks Colin!) which sent me to an article called “Top 10 Ways to Provoke a Geek Argument“.

I mean, I like to think I’m a geek, sad, but true. However, if the things mentioned in that article are likely to incite an argument in a geek, then I ain’t a geek. True geeks laughs in the face of such insults. So bearing all this in mind I say a real geek is someone who takes offense when:

  1. someone states that programming is just a day job;
  2. someone tells you they work in IT/computing and they can’t program – this often comes in the form of a third-person telling you their friend works in IT just like you!
  3. someone tells you that the technology used doesn’t matter;
  4. someone’s role call of programming languages does not extend to at least 4 and they don’t know at least one dynamic language – real brownie points go to those who know a functional language;
  5. someone shifts a conversation about programming to something else – oh yes, including girls, well maybe not!
  6. a developer tells you they don’t have broadband at home;
  7. someone states that Agile development is essentially the same as the Waterfall model;
  8. someone becomes a “developer” during a one year Masters conversion course – in particular sociology and arts students;
  9. a “developer” tells you they want to be a manager;
  10. people don’t think they’re a geek.
  11. There you go, if you don’t agree with these then you ain’t a geek! However, you are at least one tenth of one! ūüėÄ

the problem with frameworks

I love frameworks. You love frameworks. We ALL love frameworks. As web developers we just can’t get enough of these things. They’re everywhere: from Rails, to MS MVC, to CakePHP, to Django, and so on. I’m so obssessed with frameworks that I spend more time thinking about what one to use than actually using it. But this is not the only problem, as after choosing one, your problems can really start.

On a project that I have been intermitently working on for a little while now I chose to use CakePHP. The reason for this choice? Well first, I had a pretty good knowledge of PHP as I wrote my own little PHP framework when web frameworks were a mere twingle in their daddies eyes. Second, PHP is widely supported on shared hosting – though Ruby is catching up (that said, I’ve experienced some horrors with Ruby hosting). The widespread availability of PHP also means that PHP hosting tends to be cheaper.

Anyway, this is all beside the point. My real issue is with the size and complexity of these frameworks. Just the other day I was looking to do something as simple as validate an input that was supplied as an HTML POST parameter. Pretty simple right? Well it ended up taking me a disproportionate amount of time to do this task.

The first port of call was to find out if the framework itself supported this, which to my delight CakePHP (1.2) delivered on. Now it was down to the trawl/skim through the documentation trying to figure out how to actually do it. I found what I presumed done the task – basically I was required to add the appropriate validation rules to my model. Thus I added the following:

1
2
3
4
5
6
7
8
9
<?php
class Section extends AppModel {
    var $name = 'Section';
    var $actsAs = array('Tree');
    var $validate = array( 'name' => array('rule' => alphaNumeric,
                                           'required' => false,
                                           'message' => 'Alpha numerics only'));
}
?>

Then in my controller I simply called the validate method:

1
2
3
4
if(!$this->Section->validates()) {
    parent::handleAJAXError($this->Section->validationErrors);
    return;
}

What happened? NOTHING! I passed data that should have failed and it passed. SHIT! I then decided to check to see that the rules were getting parsed so changed the required key in the rules to true, and passed nothing in. Now it worked – it asked me to specify the parameter. My logic was therefore it can see the data and the rules are getting parsed so what the hell is happening!

By this point I had spent quite some time trying to figure this all out. To be honest, I could have written the validation code quicker. So that’s what I decided to do. Yes I reinvented the wheel, it took me around 5 mins, dwarfing the hours I had spent trying to get the stupid library validation code to work. Not only that, much of the supposed benefits offered by using the built in validation code was of no use to me – it wasn’t built around AJAX requests. So what is the moral of this story?

Well it’s read the documentation better, don’t run the most stupid tests, and don’t charge-in thinking you know how everything works! WHAT I hear you say?!

If only I had taken more care when reading, eh the first paragraph, in the documentation I would have observed this:

First, set the data to the model:

$this->ModelName->set( $this->data );

Whoops I never done this. Basically I wasn’t EVER passing in any data to validate, which makes my shocking test of changing the required to true to convince myself the rules and data were being parsed an absolute joke. Rushing in to write my hand crafted code is as bad as the other old chestnut of complaining “there is a bug in the compiler” – c’mon we have all said it ūüėČ The only thing I can credit myself with here is that after a recent 4 week holiday I was stubborn enough to not give up and go back an look at it. Therefore, if there is anything to learn from this experience it’s that before starting something make sure you have taken the time to either read the documentation or listen to those trying to guide you. Oh and have a certain amount of stubbornness about you – not too much though.

are you in it for the long run?

As developers we are often faced with the issue of time vs. quality. Let’s face it though, we could spend forever getting it all just right, from documentation right through to unit testing. However, there has got to be a point when you let it go and see how it flies.

This is particularly true when you are faced with a real-world optimization problem, e.g. scheduling, time tabling, process optimization.  Often with this type of problem it is very difficult to obtain an optimal solution. However, I find the more time you spend on the problem the better you understand it, which normally leads to an improved model.  In turn, the improved model leads to a better solution, or an equivalent solution found in a shorter time.

This begs the question when do you give up and say it’s finished?

To be honest, I’m not sure what the answer is to that. As a developer I want to keep on going, hoping to pull the rabbit out the bag, but as an employer, I just want the thing done good enough to have a competitive edge.

The same goes for unit testing – especially at a startup. In this setting you are NOTHING until you get your product out the door, and until you do, you are hoping and praying that no one beats you to the punch. Some people say that quality shines through, but how bright it shines I’m not sure. ¬†Take myspace as the perfect example. It has no redeeming features –¬†it just got there before everyone else. Does anyone know a band not on myspace though?

However, Google proved that the best product can establish its market regardless of its starting position – I now find it difficult to believe that I thought Altavista was good. It’s important to remember though that for every Google there is a myspace (or the ipod, for that fact) where the first is not the best, but people have invested too much time in their choice to change (or in the case of the ipod, maybe it’s fashion outshining functionality).

So what IS the answer to when is the software ready to go? Maybe the simple answer is “whenever someone is willing to buy it”!

the future of the humble programmer

Back in ancient times and right up until relatively¬†recently¬†(mid 1400s)¬†scribes¬†were used to copy important documents for kings, queens and other nobility. ¬†It’s hard to imagine that most people couldn’t write back then, and I suspect (but can’t find any hard facts) that many many people still had difficulties writing until the beginning of the 1900s.

However, the job of a scribe became almost redundant overnight with the invention of moveable type. At this point we began to see a power shift, as documents were easily copied and translated, and distributed to the masses.  Obviously there was still the hurdle of learning to read, but now many important documents were available to more than just a handful of people Рprior to this reading such documents was limited to the nobility and the clergy.

Moveable type was the most popular form of distributing documents and information right up to the modern day. However, with the advent of computers and the internet, this has changed for good.

Today we find less and less people reading books, but instead we mindfully overdose ourselves on blogs and social networking sites.  This information exchange only serves to benefit each and every one of us, as now we can observe opinions that are not dependent on the views of an editor whom we share little to nothing in common.

It’s easy to see how jobs have transformed over the centuries, once coveted jobs are now in the hands of “amateurs”; who to their credit provide content that is more¬†pertinent¬†to the interested party. ¬†So where does this leave us as software developers? ¬†How will our roles stand up with the future in mind?

If we think back to what I said earlier, about how not too long ago most people couldn’t even write, and consider that the computer was out of reach, both financially and physically, of most people, but now both these things are the norm in society. ¬†So just as everyone learned to write, is everyone going to learn to program?

OK, you may be thinking that a field like mathematics has been around a long long time, and that not everyone is competent in even basic mathematics. ¬†However, let’s face facts, a general programming task is nowhere near a difficult as even high-school level mathematics. That’s not to say there does not exist¬†difficult computing tasks;¬†in fact I’m hoping to¬†convince¬†you of the opposite.

Is it that crazy to think that one day people will program a computer in the same vein as we read and write English (insert your native¬†tongue¬†here)? ¬†I don’t think so. Programming is not really that difficult (doing it well is as difficult as writing beautifully in English, and that has never stoped people writing, look at me). Just as blogs and the internet pulled down the barrier for each and every one of us to write and be heard, I feel it’s only a matter of time before programming computers becomes something more akin to what many will do in everyday life.

If we look closely the first steps are underway. People are using HTML, CSS and JavaScript as if they were everyday things. ¬†They may be doing them under the veil of certain tools, but the “non-programmers” are programming. ¬†They may not even know they are doing it, and the ability to make more complex applications is only going to get easier.

For example, consider writing a database application for an online bicycle shop using CakePHP (something I have experience of, hence the inclusion). You have to know almost nothing about using a database to create this application. OK, you may say that scaling and optimising these things takes a “professional”, but at the rate we are pushing the technology, this barrier may not be there on 5-10 years time – consider the cloud computing environments as a step in this direction.

What I’m not saying here is that all computing is easy.¬†There are still problems that are difficult to solve and require much much more than simply following a fixed set of instructions. Indeed, this is the domain where us developers must start focusing.

There may be many readers out there that think this is all nonsense and that programming computers is always going to be an elite occupation. Just tell that to the scribes, journalists and the media presenters/organisations, whose occupations have either vanished or are suffering severe contraction. Many of these occupations never seen it coming (or refused to see it coming) and done nothing Р but just remember how quick this actually happened to each group. Do you want to be in the same position?

some thoughts on pair programming

In the last couple of days I have had a chance to do a little bit of pair programming. ¬†In the past I have found myself being a touch sceptical of it all, but predictably I hadn’t actually done much. ¬†So here are some thoughts from my recent experience.

Firstly, I must admit it was only half pair programming, in the sense that I was only an observer and not a driver.

I would say that my biggest concern with pair programming is I found it hard to believe that there would not be a drop in overall productivity with two people concentrating on the same task. ¬†However, I’m beginning to think that, counter intuitively, this may not be the case, but it also depends on the task.

For example, when two people have a completely different skill sets and both skill sets are required for the job. ¬†In my case, I knew literally nothing about the programming language we were developing in. ¬†However, I had a fair amount of knowledge with regards to the ‚ÄúAPI‚ÄĚ we were coding to (fair amount meaning I wrote it!). ¬†As a result of this I knew what we were trying to achieve but just not how to achieve it. ¬†In this situation the pair programming seem to go very well and I would suspect that the functionality was added to the code twice as fast as it would have been if any one of us had to do it alone.¬†

So what are the other benefits? ¬†You generally always learn something when pairing up – ¬† even if you have more experience than the other person. ¬†For me, I learned that you could place a hash (#) in front of the number to specify the ascii value for a character, for example, #9 is a tab character. ¬†This had passed me by for some reason, I mean I knew in HTML you could do stuff like &#33 to obtain an !, but I had just never thought about what it meant. ¬†Now I understand! ¬†You also get the benefits of seeing how someone else thinks, and you can learn a lot from that. ¬†You might also gain “tips” for navigating the environment or valuable tools being used.

There are some downsides too. ¬†When I was doing it the last couple of days I never noticed too many, but I can certainly imagine thinks like different personalities, strong opinions, and reluctance to participate, affecting things quite drastically. Here are a few that I think may annoy the driver, but as I wasn’t driving I don’t really know for sure.

First, as a navigator you sometimes notice tiny things like misspelt names, missed semi-colons, etc, and at the start I pointed these out pretty quickly. ¬†However, I then thought to myself, maybe the person has noticed these things and was going to go back and change them when they finished typing the line. ¬†So I just tried to stop myself interrupting too much – as I suspect someone who constantly points things out can get pretty annoying. ¬†I also had to stop myself preaching my coding habits that don’t make a difference to functionality, that was harder though, as I pretty much have an opinion on just about everything ūüôā . ¬†As for navigating, I’m sure someone that completely ignored your suggestions and coded away regardless would be¬†extremely¬†annoying.

I’m not sure that pair programming is THE definitive development strategy. ¬†I’m certain that someone sitting over you while you are writing some form of input parser in which you are just running through the motions is almost pointless. ¬†Also, when you have to think really hard about something, whether it be debugging a hard problem or some complex algorithm, someone interjecting all the time would be extremely off-putting.

So to sum up: pair programming definitely has advantages and with some careful planning it can be used to improve a projects quality, cost and time to launch.

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 ūüôā )

  1. 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.¬†
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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.

  1. Return from if statements as quickly as possible.

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    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:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    
    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.

  2. 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;
        }
    }

    Just remove the if statement completely:

    1
    2
    3
    
    function isStringEmpty(str){
        return (str === "");
    }
  3. 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:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    
    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.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    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
    }
  4. 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.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    
    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;   
    }
  5. 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;
    //}
  6. 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):

    1
    2
    3
    4
    5
    6
    
    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.

  7. 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.