Tag Archives: programmer

The Top 10 Attributes of a Great Programmer

With all the latest attention again on what does and doesn’t make a good programmer, I couldn’t help but put together my own top 10 list.

  1. Being a great problem solver.
  2. Being driven and lazy at the same time.
  3. Ability to understand other people’s code
  4. Having a passion for programming
  5. Loving learning for the sake of learning
  6. Being good at math
  7. Having good communications skills
  8. Strong debating skills
  9. Extreme optimism
  10. Extreme pessimism

     

    1. Being a great problem solver – Hopefully everyone recognizes this one. Most good programming is all about being able to find solutions where others can’t see them. If you don’t have this skill the others matter far less.
    2. Being driven and lazy at the same time – This one surprises some people. Programmers question things and are often “too lazy” to take the long route. The will spend countless cycles trying to simplify the problem and simplify their task. That said they having a burning need to get the job done, they just want to do it as efficiently as possible.
    3. Ability to understand other people’s code – This point is essential but cuts some good programmers off from being great programmers. It doesn’t matter how well you can rewrite everything yourself – you need to be able to work with other people’s code on existing projects, lean on opensource in new projects, and learn good techniques from the code base that is already out there.
    4. Having a passion for programming – on some level you have to love programming for programming’s sake. I suppose to be truly great at anything you have to love it in most cases.
    5. Loving learning for the sake of learning – Programming is a moving target. Unless you love the art of edification you will sink fast. There are no laurels to rest on and no one cares what you did yesterday. Unless you are aware of the techniques on the horizon, you won’t be ready to embrace them when they become relevant.
    6. Being good at math – Different people will have different opinions here – but at the very least having a strong grip on pre-Calculus math. I’ve never seen a great programmer without a solid grasp of at the very least algebra and trig.
    7. Having good communications skills – This doesn’t mean that they can communicate with anyone and everyone. Specifically this means that they are able to clearly express their thoughts on their own terms. I’ve met plenty of great programmers who couldn’t communicate well with the world at large. However, given someone to talk to who understands the problem domain, they were all able to clearly state the problem and the solutions proposed.
    8. Strong debating skills – This follows the same logic as #7.
    9. Extreme optimism – Great programmers I have encountered have an insane certainty they can get the job done once they have chewed on it a bit.
    10. Extreme pessimism – Great programmers I have encountered have an insane insistence that when they lack the information needed to make a good judgment that they won’t be able to make one at all.
      After putting together this list some aspects surprised me, and I was the one who put together the list. So let me explain each in detail.These attributes describe those I’ve found in pretty much every great programmer I’ve come across. There were a number that fell through the cracks and I’ll explain those later. 

      Some of the things I instinctively wanted to put on the list but couldn’t say were true of at least 95% of great programmers include the following:

    1. Being extremely organized – Understanding when and where organization is important, yes. But anal attention to detail is something present in great programmers as often as it is people in other disciplines.
    2. Being good at managing other people and or programming projects – Somehow these skill sets are wonderfully synergistic when they sit side by side, but management and programming are often completely different disciplines.
    3. Being able to write good design documents – Same as #2. This skill may make some people better programmers and I am in favor of learning it. However, plenty of great programmers I have encountered couldn’t write a coherent design doc if their life depended on it. This will know doubt be debated by heavily by some.
    4. Having an ability to estimate time frames – Once again like #2. This is an acquired skill and a very useful one. However, I have seen absolutely zero correlation between great programmers and estimation skills.
    5. Prolific reading of tech books – I do this all the time myself, but many great programmers don’t. Let me be clear though – most programmers who aren’t all that hot could definitely benefit from bootstrapping their skills with some good reading.
    6. Ability to transfer their programming skills to any programming domain – Although many can, some great programmers can’t, or refuse to, grok other programming technologies. I like to think that this is a “refuse to” situation.
    7. Write code that is correct the first time around – Many great programmers commonly have syntactic issues flagged by compilers or at runtime interpretation. Some are zealots about the details the first time out, others are much more “extreme” in this area.
    8. Having other areas of great skills – some great programmers are good at only one thing – programming.
    9. Social or antisocial – Great programmers come in both forms.
    10. Are someone you’d want on you team – Unfortunately some of them just can’t work with others well.
    11.  

    How null breaks polymorphism; or the problem with null: part 1

    Preface: After talking to a number of people I realize that somehow I managed to misrepresent myself with respect to type systems in this article. This article is an attack on null, and to point out that null is still problematic in many (if not all) strongly typed languages. Many who prefer strong types and static types feel they are more immune to certain runtime type related inappropriate behaviors. I feel the ability to use null in most languages in place of an object breaks polymorphism in the most extreme possible way. I am in no way implying that dynamic or weak type systems are better at handling these issues. As for me – I prefer languages with stronger compile time type checking.

    This is a difficult concept for a lot of died in the wool strong statically typed OO programmers to fully digest and accept. There is an immense sense of pride in the strong statically typed community about the fact that unlike untyped languages, strong statically typed languages protect them from run-time errors related to type mismatches and unavailable methods. Unless you do a dynamic type cast (frowned upon heavily) you should be safe from at least this broad class of error. But they are wrong. Type mismatches and unavailable methods occur all the time in strong statically typed languages. And it is a common form on runtime surprise. What causes this common problem: the null which can be used with any type yet breaks polymorphism with every single one.

    Unlike types in loosely typed languages the null is guaranteed not work polymorphicly thus requiring a specific type check. Did I say type check? But I have no dynamic casts, I’m following all the rules. Why should I have any type checks? Checking for null is a type check. It’s the mother of all type checks. Instead of having code littered with conditional checks for types and branches based on those types (an OO worst practice) you have code littered with conditional checks for null having branches based on whether it is null or not.

    Now granted, life in a world without nulls isn’t easy and I use null often myself. It’s too tempting to use this magic value instead of writing code more appropriately. Some will mention the null object design pattern that “does nothing” with pride as a solution to this problem. These are in fact polymorphic. The only issue is that null objects only work in special circumstances. If you really don’t have a thing you shouldn’t be pretending you do and having it do nothing. You should have a separate chain of logic that doesn’t use the thing you don’t have.

    I have talked to a number of coders that think that removing null from a majority of their code would be difficult to impossible. A difficult to grok kind of problem perhaps but intractable, no. Consider the following function:

    int DoSomethingSpecific( int x, int y, int z);

    Now I will asked the magic question. Do you check z for null in case you don’t have it? (or x or y for that matter). In C++ that isn’t even possible because it’s passed by value. If an appropriate default exists for z you may set z to that default before it is called. However plenty of times that concept isn’t the one you are looking for. What do you do? You simply write another function that doesn’t take z.

    int DoSomethingSpecific(int x, int y);

    Now let’s use generic objects:

    int DoSomethingSpecific(object x, object y, object z);

    int DoSomethingSpecific(object x, object y);

    Using this approach doesn’t break polymorphism. You only call the appropriate function when you actual have the parameters in question.

    Of course this brings us back to a more fundamental problem. The concept of null is so burned in to most OO languages that visual inspection of code reveals that most any object should be nullable and thus checked for null. C++ has a way around this with references that can not be null or checked for null (yes I know many compilers will let you assign null but you make clear your intent in using a reference:it should not be null). The C++ reference being used this way is at best an afterthought in the language. These references can’t be reassigned and thus are limited to incoming parameters on function calls in many cases.

    Even if you create a class which prohibits non-null assignment casual readers of your code in many languages will miss this fact and do gratuitous checks for null anyways; defeating much of the purpose. The key is supporting syntax that makes clear the fact that an object can not be null. But that discussion is for another day.

    In part two of this article I will explain many of the misconceptions and supposedly intractable issues related to removing null. It’s not as hard as you might at first think. I will also further explore the syntax issue, or without language support at least a possible naming convention.

    The D Programming Language

    The D Programming Language – a Pleasant Surprise

    From the D website,

    “D is a systems programming language. Its focus is on combining the power and high performance of C and C++ with the programmer productivity of modern languages like Ruby and Python. Special attention is given to the needs of quality assurance, documentation, management, portability and reliability.

    D is statically typed, and compiles direct to native code. It’s multi-paradigm: supporting imperative, object-oriented, and template meta-programming styles. It’s a member of the C syntax family, and its look and feel is very close to C++’s.”

    This language first piqued my interest about 2 years ago. At the time I saw it as a great idea but wanted to wait to see if it would catch on at all. Since then I have been hearing about it from time to time and finally decided it was time to take a close look. And I’m really glad I did.

    This article mainly compares C++ to D from the perspective of what C++ is missing that D has. If you haven’t read my last article about what I love about C++, you’ll probably want to do that first.

    Favorite additions C++ is missing:

    1. Garbage Collection – this is almost always faster and more efficient use of runtime cycles and the developer’s development cycles; a total no-brainer in most cases. You can do manual memory allocation when you think you know better.
    2. Nested functions – The nested function has full access to the local variables of the function it is nested in. Being able to break up large functions in the scope of the calling function makes things sensible and clean.
    3. Inner (adaptor) classes – Nested classes support access to the variable scope of the calling class. Use a static nested class to prohibit access.
    4. Properties – Being able to use the syntactic sugar of values with underlying functions makes good sense. Why shouldn’t value be able to be abstracted out and have underlying functions?

    5. foreach – cycle through all the elements and let the compiler decide the most efficient way.

    1. Implicit Type Inference – this is coming to C# soon as well. It’s nice not to have to specify the type when it is already specified by what it it’s being set equal to.
  • Strong typedefs – This one is especially nice. You want to create a typedef that isn’t considered the same as the original as function signatures are concerned. C++ forces you to create a class to do this thing that should be simple.
  • Contract Programming – puts your in and out contract constraints into the code in a clean, consistent way. The compiler can now better optimize and inherit contract constraints.

  • Unit testing – makes it simple to include unit tests directly within each class to validate it.

  • Static construction order – Being able to explicitly define in what order static objects are created in shouldn’t be too much to ask. I’ve seen more than a few projects bit by this in C++. In C++ you have no guarantee when statics will be initialized. Interdependencies in C++ can leave you shaking your head as you unravel the evil.

  • Guaranteed initialization – you have to explicitly say that you want no initialization for performance reasons. 95% of the time not initializing is a mistake – let the compiler do it for you.

  • No Macro text preprocessor – the source of so much potential ugliness – gone!

  • Built-in strings – sure the STL has them but being built-in to the language certainly seems like a reasonable way to go.

  • Array bounds checking – built-in support for checking bounds on all arrays. Turn it on or off – very nice. How many times in C++ have you wished you could flip a switch and make sure nothing was going out of range at runtime. Maybe you should use the STL all the time, but I don’t know anyone who doesn’t use built-in arrays at least some of the time.

  • Nice to haves C++ is missing:

    1. Function delegates – a convenient way to point at member functions.
  • Resizable arrays – being built-in to the language is the way to go for such a basic operation.
  • Array slicing – another minor convenience.

  • Associative arrays – an STL plus that is built-in to the language.

  • String switches – its definitely convenient at times.

  • Thread synchronization primitives – with the prevalence of threads having basic sync support in the language is a timesaver.

  • Type-safe variadic arguments – gets around C++ clunky access to an unknown number of arguments.

  • Documentation comments – a consistent way of documenting code.

  • Try-catch-finally blocks – I’m still not a big fan of exceptions. I blame it on my background in-game programming.

  • There are more advantages over C++, but I just wanted to mention a few of the highlights.
    For a complete comparison of D vs. C, C++, C# and Java go to the D website’s comparison

    Doing a little deeper digging under the covers I found a few things I didn’t like – and one was a deal-breaker.

    First of all – all classes in each module have access to each others private data. There is no way to turn this off. This forces a loss of encapsulation – a concept i don’t agree with.

    Unfortunately the deal breaker that would make me prefer Managed C++ from Microsoft over D is the lack of interop with C++. D is very proud of its simple interop with C. But unlike Microsoft’s Managed C++, D requires cumbersome mechanisms to interop with C++. This is extremely unfortunate and leaves me wishing the C++ standards committee would make C++ over time more like D.

    All in all, D appears to be a very promising language with much to offer. With more straightforward support for coexisting with C++, I would think it would be a shoe-in to eventually gain mainstream popularity. It seems very suitable for performance based coding across multiple platforms. It certainly might be possible to use an auto-wrapper generator like SWIG to bridge C++ libraries to D.

    I will admit that I have only given D a laymen’s overview. I haven’t coded at length in it yet. However I think I’ll end up coding lower level constructs in C++ and using C# for higher level garbage collected code.

    In my mind D is a pleasant surprise but doesn’t quite fit the bill. I would love to see more convenient interfacing with C++ to the extent that such seamless interfacing is feasible.

    How To Be A Deep Thinker

    Programming over the years

    Yes, it still is the most popular square peg round hole on the block. The most interesting element is that – yes agile programming is both evolutionary and emergent. Evolution and emergence are processes and properties where the results are arrived at in a way that straight foresight never could have anticipated. But ironically the most adept agile developers are those who were “forced” to learn non-agile product development techniques. This should make sense at the end of the day, evolution and emergence only produce good results when they are building on other good practices. Unless you carefully analyze what those practices are you will never realize them.How many agile/extreme programmers have you come in contact with that have absolutely no concept about their problem domain. I’m not talking about the problem domain realized by “domain experts” in other fields. I mean the problem domain they are supposed to be experts in. We’ve all encountered it. People who are truly bright but have a little understanding of programming technique. Abstraction and simplification are lost on them. But convenient extreme mantras are held close to their heart. They love the built-in protection of extreme tenements.

    Without access to a customer 24-7 how could they know what a customer wants? Anticipating needs is unimportant – code for todays needs. Long term scheduling is unimportant and a waste of time. All of these concepts work if you’re an experienced developer. Not because they are correct, but because they have become automatic to an almost sub-conscious degree. Their code auto magically is written to the tune of design patterns, simplicity, flexibility, and automatic recognition of common long-term needs. But the new-comers fail miserably. They end up building for today and generating a spaghetti mass that is impossible to maintain.

    Continue reading