A recent Slashdot book review (about learning Computer Science by starting with Assembly language) sparked a discussion about the importance of developers knowing and being proficient with assembly.

The person who contributed the story wrote:

I’ve found that the key difference between mediocre and excellent programmers is whether or not they know assembly language. Those that do tend to understand computers themselves at a much deeper level.

This observation parallels one of my own - that some (most?) developers believe in magic, and others (a few) don’t.

By this, I mean that there seem to be a lot of developers who believe that some parts of their software are unknowable - or magic.

Some examples include:

  • Those who say that it isn’t important to know how the object we’re using in this computer gets transported to that server in the corner;
  • Those who believe that the way garbage collection works is completely irrelevant to the way the application behaves; and
  • Those who have no idea how a method call in the language of choice (Visual Basic, C#, Object Pascal, C++, xxx) resolves into invoking the correct function in the face of polymorphism, inheritance, and interfaces.

I believe that you can be an everyday, competent, ordinary developer without knowing any of these things.

The problem is, as Joel Spolsky details, Encapsulations Leak.

To put things another way, you can never completely ignore the layers below the level you work in - because sometimes the errant behavior you see is due to a problem in an underlying layer that has leaked out.

An example from my own experience …

The Autocomplete Combobox

This was a combobox in a Delphi application that autocompleted the first character you typed to match the first item starting with that letter.

Trouble was, this combobox didn’t have any autocomplete code, and it only happened with the first character you typed - delete that character, type something else and nothing happened.

It turned out that the cause of this was the code we had written to change the colour of the control - we had a GUI standard that modified controls should have blue text, while unmodified ones were black.

Changing the colour of a combobox resulted in the underlying windows control being destroyed and recreated, which in turn resulted in an “auto lookup” through the items list and changing the text to the first match found.

If I hadn’t been somewhat familiar with both the way Windows controls actually work and with the way that Delphi wraps them - that is, if I had believed in some kind of Delphi magic - I would never have found and fixed that bug.

I don’t think that knowing assembly language is necessary to being a great developer (although, I did once know Z80 and 6502 and can read x86 assembler).

I do believe that a great developer can’t believe in magic - anything that the computer does can be understood, if a little time is taken.


blog comments powered by Disqus
Next Post
Ethics and Professionalism  11 Feb 2004
Prior Post
Agile Development - The People Factor  04 Feb 2004
Related Posts
Using Constructors  27 Feb 2023
An Inconvenient API  18 Feb 2023
Method Archetypes  11 Sep 2022
A bash puzzle, solved  02 Jul 2022
A bash puzzle  25 Jun 2022
Improve your troubleshooting by aggregating errors  11 Jun 2022
Improve your troubleshooting by wrapping errors  28 May 2022
Keep your promises  14 May 2022
When are you done?  18 Apr 2022
Fixing GitHub Authentication  28 Nov 2021
February 2004