Are you a developer or a coding monkey?

Recently an acquaintance of mine came up with a good question “Do we really have a lack of developers in Malta?

So this stirred some thoughts in my head.  What is a developer? What is the differentiator between a developer and a coding monkey?

In the past, I would stray away from answering such questions, for fear that I am not experienced enough to answer them.  Yet it recently dawned on me that I am getting older, and along a mostly coincidental time-warp, I have amassed over 20 years of experience in the field, making me, potentially, qualified enough to put my opinions forward on the matter.

So, what is a developer? And what is a coding monkey?  I’ll start with a TLDR;

  • A developer, or more aptly, a software engineer, is someone who sees computer software in the same way that Neo saw the Matrix.
  • A coding monkey is someone who slaps his paws on the keyboard continuously until he produces a sequence of characters which coincidentally produce code that does what is required.

Over the years, I have had the pleasure of working with many developers, as well as the displeasure of working with coding monkeys.

These days, it seems that if you have a degree in any of the computer science disciplines you are considered a developer.  Yet this could not be farther from the truth.  Starting with my own experience of I.T. graduates in Malta; which at the time of writing, number approximately 335 a year, if I were to apply the ratio of good/bad developers that I have met in my life, then the actual good developers produced by Maltese academic institutions would number around 10 per year.

I have also been lucky enough to have spent all of my 20s travelling the globe, working and living in different countries (16+), and more importantly, working with developers from every nationality, and I can say that the ratio I witnessed in Malta is also applicable to other countries to some extent, with the exception of Slavic countries, which seem to produce highly skilled I.T. graduates at a far higher rate than any other country that I have witnessed.

So what is a good developer?

IMHO the differentiators of a good developer vs a coding monkey are the following:

  • Curious
    • they have an insatiable thirst to understand why and how the code is working
    • they need to understand how successful systems are designed since they want to steal those ideas for their own project
  • Creative
    • they apply a mix-n-match of all the knowledge they gained from studying other systems to their own project in a way that elegantly solves the problem at hand
    • when trying to solve a problem, they come up with ingenious ways to investigate what is going on and to make said investigation easier (even if it means spending an hour configuring their system to perform remote debugging, and even if it means decompiling third-party libraries)
  • Motivated
    • they are intrinsically motivated to learn as much as they possibly can in the time they have available
  • Patient
    • they RTFM!
  • Passionate
    • they take the quality of their work very seriously, like a religion and they get touchy when presented with sub-par work (whether they express this publicly or not)
  • Smart
    • they are capable of understanding what they are doing and can mentally trace a code-path through an entire system in their brain. i.e. like Neo in the Matrix, when they look at code, they don’t just see those 3 or 4 lines in front of them, but they see them in the context of the full system
    • they understand the problem they are trying to solve, and if the requirements do not make sense, they will question it and propose an alternative
  • Driven
    • they do not give up when faced with a problem to solve, on the contrary, they see it as a challenge to their intelligence, and they will persevere until they fully understand what is going on… even if this means they’ll be at it until 5am in the morning
  • Strategically Lazy
    • they will gladly spend extra time refactoring their code to ensure that any given logic exists only in one place, because they know that when the day comes for them to change this code, they only want to change it once, and in one place rather than having to scan the entire code-base to find all the places where they’re doing the same thing
    • they will also gladly spend time writing automation scripts because they feel that repetitive tasks are mundane and if a computer can do it, then it should, in the false hope that they can then use that time to chill and do nothing (in truth, they will probably use that time to play with some esoteric language or reading Jeff Atwood or Martin Fowler)
    • they will write tests for their code (either before they write it, or after) because they can’t be arsed to stay checking if it works in the future and they think their CI server should do that dirty work
    • they are averse to hacks, since they know that hacks eventually mean unpredictable behaviour which is hard to debug
  • Teachers
    • they are so passionate about their craft that they will gladly and patiently spend time trying to educate developers around them in the hope that they’ll eventually have another smart developer they can converse with and exchange knowledge with
  • Students for life
    • they spend most of their free time reading about new best practices and about the architectures of other solutions
    • they spend at least a couple of evenings a week experimenting with code or contributing to the ecosystem, be it through open-source projects, or merely replying to or correcting questions on
  • Pedantic
    • they understand that what they are doing is engineering, and therefore other than being correct, it also needs to be elegant, precise and reliable
    • they write safe code since they know that if it fails they will need as much information as possible to debug it
  • Pride
    • for them, asking for help is a last resort, they feel they should be smart enough to solve the problem themselves
  • Opinionated
    • they have strong opinions on how certain problems should be solved, and if you propose an alternate solution, you had better explain it to them logically and comprehensively to convince them to do it your way, otherwise get ready for a potentially unpleasant discussion
  • Respect
    • they have endless respect for other good developers, since they consider themselves lucky to be working with one
  • Artists
    • their code is concise and neatly organised in short, highly focused and mostly private methods
    • they stick to naming conventions religiously
    • their code documents itself
    • they love generics or whatever templating syntax is available in their chosen stack

All the great developers that I have met in my life share the above traits, and nowadays when I meet a more junior developer, I find it relatively easy to tell who will be a great developer and who will be a coding monkey.

So what is a coding monkey?

In contrast, the following are the traits of a coding monkey:

  • Demotivated
    • if something does not work, they will spend hours on end trying the same code over and over again, in the hope that by some magic, it might work eventually with almost no changes
  • Copy-pasters
    • they are experts in finding code snippets online and slapping them into their code with no changes, in the hope that they will just work
    • these are easy to spot.. they tend to leave variables running around called ‘myThis’ or ‘myThat’ and generally also leave code that does nothing
  • Lazy
    • they leave commented code all over the place and they commit this in PRs
    • the minute something does not work, they will immediately refer the problem to another developer in the hope they they’ll solve it for them
    • they do not ‘think’ about the problem they are trying to solve and simply do it as they are told, even if it does not make sense
  • Non-creative
    • if they cannot figure out what is going on, they give up immediately without even considering trying to figure out an alternate way to approach the problem
  • Sloppy
    • their code layout looks like an alphabet soup, you have a hard time reading it and wonder how it even works
    • they love writing methods with more than a 100+ lines, and they actually get satisfaction from it since they think they just wrote something complicated (in fact, it IS complicated, rather than complex)
    • they never even think about whether a method should be private, protected or public, let alone if a class should be sealed or not.  These thoughts simply never even occur to them.
    • they commonly ‘forget’ dirty experimental code and submit it in their PRs
    • they commit files with no changes
    • their commit comments have almost nothing to do with what they are committing
    • they leave spelling mistakes in their code, be it in method or variable names, or comments (code or commit)

Work Efficiency

So, from the above, it should be quite clear why some developers charge $5/hr for their work, while others charge in excess of $50/hr.

It is also a common misconception that good developers are fast.  In truth, from my experience, fast developers are just coding monkeys, since they just slapped something together without testing it and if you have any guarantee about this code it is simply that this code will most certainly fail, very quickly, and cost you MUCH more time to fix it.

The fault is partly that of managers, since they push developers to work fast, encouraging them to write sloppy code.  As a result, there is now a misconception as to how much time something should take to be written since projects are measured and estimated by managers who are used to sloppy developers delivering sloppy code in a short amount of time.

I say partly, because it is also the fault of the developer who accepted to write the code in such a short time and who produced the sloppy code in the first place… you are as much to blame, since you are the developer and you should be educating your manager in this regard.

Another side-effect of having coding monkeys on your team is that they take up the time of good developers by asking them questions all the time, leaving little to no time for the good developer to actually do what they are good at.

In Conclusion

So is there a place for coding monkeys on your team?

I would argue no. Coding monkeys only harm your project, both financially and in terms of team interference.

I will highlight two experiences from my past.

Scenario 1

There were 3 highly-skilled developers working on a project.  The technology was new to two of them, and they had one person on the team already skilled in this technology.

Their day was mostly very quiet, they had a stand-up in the morning, and other than casual jokes flying around everyone sat down and did their work.  The only discussions that actually occurred revolved around debating the most elegant way of solving a problem.

Needless to say, the project was very successful, delivered on time and below budget.

Scenario 2

There were 3 developers, 1 was a coding monkey and the other was a smart junior.  Same as for scenario 1, one was experienced in this technology and the other two were new to it.

Their day was very noisy, mostly due to the coding monkey constantly asking questions that they could very easily have figured out on their own with some brain power and the right motivation.  Additionally, more time was wasted because the coding monkey, not understanding what they were doing, explained their problem incorrectly, leading to more time spent trying to solve a non-existent problem.

As a result, the project kept slipping continuously since the more experienced developers were busy trying to solve the problems of the coding monkey and trying, albeit futilely, to educate the coding monkey.

Eventually the coding monkey was rolled off the team, yet the harm had already been done, and other than the time wasted trying to educate them, some bad code had already slipped through and made it to the master branch, so more time would need to be spent figuring out this code and fixing it.

What if you are a client?

If you are a client buying the services of a consulting company, the above should be of importance to you, since this will ultimately be reflected in the end-product you receive (if you ever receive it).

A tell-tale sign that a company employs coding-monkeys in comparison to real developers is their cost.  If they are cheap, then stay away from them.

There is a common misconception that writing code and producing software is easy.  This is wrong.  Not only because it is intrinsically complicated to write good code, but also because it is very hard to find good developers who consistently produce good code… and these developers are not cheap, because everyone wants them, so they will work for the highest bidder.

So, as a client, I would first ask my potential provider to show me how their recruitment process works.  What questions do they ask in interviews? Do the developers have to write any code in their interview?

Next, get a list of the developers who are going to work on your project, and simply search for their names on a web-search engine (ex. Google, Bing or DuckDuckGo).  If their names do not show up alongside a blog, a answer, GitHub or any other code-related site, then this is a very good indicator that this company employs only coding monkeys.


WPF Localised Bindings – What to do when they just don’t seem to work :)

I am currently working on a system in Arabic (no, I don’t understand Arabic), and I bumped into an issue where Bindings were not respecting my CurrentUICulture.

Digging bit deeper (with the help of a handy decompilation tool) I found a not-so-beautiful line in FrameworkElement.cs

public static readonly DependencyProperty LanguageProperty =
DependencyProperty.RegisterAttached("Language", typeof(XmlLanguage),
_typeofThis, new FrameworkPropertyMetadata(XmlLanguage.GetLanguage("en-US"),
FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.AffectsMeasure));

As you can see, WPF does NOT respect your thread’s CurrentUICulture.

The fix is simple… finding it, on the other hand, was a nightmare.

Just override the metadata as follows:

(typeof (FrameworkElement),
new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag)));

Hope it helps :)

WPF RadioButton problems and MVVM

As some of you might know, the WPF RadioButton control does not play nice with MVVM.

The scenario that I was facing was as follows:

– I have a ViewModel with PropertyA set to True and PropertyB set to False on init.
– I have a View with two RadioButton controls sharing the same group, and bound to PropertyA and PropertyB on the ViewModel

Since in this case I was using a ViewModel-First approach, when the View is created, the RadioButton OnChecked and OnToggle where setting the True and False values for me behind the scenes.

I finally solved this using the following logic in the property setters:

:) Hope this helps someone.

Mounting your SkyDrive in Windows Explorer

In this post, I will go over how to set up your Microsoft Live SkyDrive as a mount in Windows, so that you can use it normally as you would use any networked drive.

The first step is to associate your LiveID with your user account.

  1. Launch the User Accounts control panel
  2. In the sidebar, select Link online IDs
  3. If there is an Online ID Provider of type WindowsLiveID, skip to step 7
  4. Select Add an online ID provider
  5. In the webpage that loads, select download, and then install the downloaded provider.
  6. Close and re-open the user accounts control panel
  7. Next to WindowsLiveID, select update credential… and enter your live id
  8. Launch Microsoft Word 2010, or any office 2010 application
  9. Select File > Save & Send > Save to Web > Sign In
  10. Once connected, select Save As
  11. In the save dialog that pops up… copy the address https://qwrapq….
  12. Cancel and open Windows Explorer
  13. Select Map network drive
  14. Give your drive a letter,. and paste the address that you copied earlier
And that’s all there is to it :) Now your SkyDrive is accessible from any program on your machine as easily as you would use a USB drive.
Has this helped you in any way? Let me know in the comments below :)

Using the original Remote Desktop Client (mstsc) in Windows 8 Developer Preview

If you’re using Windows 8 Developer Preview, you will have noticed that the bundled Remote Desktop Client does not play so well with older machines (Windows 7 and below).

If, like me, you are a constant user of the Remote Desktop Client (a.k.a mstsc, and.a.k.a. Microsoft Terminal Services Client), this can be quite a problem.

Luckily the older remote desktop client is still very alive and kicking in Windows 8 Developer Preview.

  • You can either navigate to C:\Windows\system32 and locate mstsc… and of course just fire it away
  • Or you can run it from your run dialog (WIN+R) as C:\Windows\system32\mstsc.exe
  • Or, you can call up your new fancy Metro-Style start menu (or legacy one if you’ve disabled metro), type mstsc, and voilà, it just pops up
And there you have it… from here on, you can launch it any way you want… create a tile, a short-cut, pin it… the choice is yours :)
That’s what I love most about Windows vs Mac… so many choices :)

Update help content in Visual Studio 11 Dev Preview to point to proper MSDN queries

When Microsoft released Visual Studio 11 Developer Previews (express or ultimate), the REST help query service for VS 11 was not yet deployed, therefore when you hit F1, you are sent to the dev10 (VS 2010) help service, rather than the correct VS 2011 service.

In the meantime Microsoft have now deployed the proper Visual Studio 11 help service on MSDN.

Thankfully, we can update our Visual Studio installation to use this new help service via a simple registry tweak :)

NOTE: If any of the keys are not available in your registry hive, feel free to create them.

For Visual Studio 2011 Express Developer Preview

For 32-Bit:

  1. Launch your registry editor (hit WIN+R, type regedit, hit enter)
  2. Navigate to [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VSWinExpress\11.0\Help]
  3. Add a string value called OnlineBaseURL
  4. Set it’s value to

For 64-Bit:

  1. Launch your registry editor (hit WIN+R, type regedit, hit enter)
  2. Navigate to [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VSWinExpress\11.0\Help]
  3. Add a string value called OnlineBaseURL
  4. Set it’s value to

For Visual Studio 2011 Ultimate Developer Preview

For 32-Bit:

  1. Launch your registry editor (hit WIN+R, type regedit, hit enter)
  2. Navigate to [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\Help]
  3. Add a string value called OnlineBaseURL
  4. Set it’s value to

For 64-Bit:

  1. Launch your registry editor (hit WIN+R, type regedit, hit enter)
  2. Navigate to [HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\Help]
  3. Add a string value called OnlineBaseURL
  4. Set it’s value to
Since Visual Studio caches this key upon launch, you will need to close visual studio and re-open it for the change to take effect.

Reactive Extensions (Rx) – Do something after all data has been received

As an Rx user, there are scenarios where you have subscribed to multiple observables, and you want to be notified when all the observables have completed.

A common approach to this problem (albeit a messy one), that I have seen used on my current project far too many times, is to set a boolean flag and to have your ‘final’ method invoked by the OnCompleted of every Observable, which in turn would check this boolean flag.

I consider this very messy, especially since Rx can actually tell you when all the observables have completed.

This can be done as follows:

var observablesObserver = new Subject();
observablesObserver = Observable.Merge( new [] { ObservableMethodA(), ObservableMethodB(), ObservableMethodC() } );

    unit => _log.Info("One of the observables returned data"),
    ex => _log.Error("Oops, we blew up",ex),
    () => _log.Info("All observables have now completed")

The implementation of ObservableMethodX() is essentially a simple wrapper, that returns a Unit (which is Rx lingo for void).

private IObservable ObservableMethodA(){
    var observable = new Subject();

        result => {
            SomePropertyA = result;
            observable.OnNext(new Unit());
        ex => {
            _log.Error("Oops... I blew up!",ex);
        () => observable.OnCompleted();

    return observable;

Now, when using Observable.Merge, all subscriptions happen at the same time, and there is no guaranteed order of how they return their results… all we know is that OnCompletedis only called when the merge is completed (in this case we are ‘merging’ void, so not much really).

So, what if you have a scenario where ObservableMethodC() depends on data from ObservableMethodB()?

One way of doing this is to actually invoke ObservableMethodC() in the OnCompleted phase of ObservableMethodB()‘s subscription, yet this gets messy since we would need to also pass in our subject so that we can inform when we have gotten ‘all’ the data.

A neater way of doing this is to use Observable.Concat() instead, which is exactly like Observable.Merge(), except for one main difference: Subscription to C will only happen once B has completed.So we can mix and match according to need, ex:

observablesObserver = Observable.Merge(
    new [] { ObservableMethodA(), Observable.Concat(
        new [] { ObservableMethodB(), ObservableMethodC() } ) } );

You could of course Concat ALL the observables, but I wouldn’t suggest this since Merge is more performant than Concat, simply because it invokes all calls simultaneously.