Being Cellfish

Stuff I wished I've found in some blog (and sometimes did)

February, 2013

Change of Address
This blog has moved to blog.cellfish.se.
Posts
  • Being Cellfish

    The green February revolution

    • 0 Comments

    I read this great article "the February Revolution" listing four things that tend to happen when great results are achieved. The thing that interested me the most was how similar at least three of the items were to how a successful military unit operates.

    • People know why they are doing their work. This makes me think of how a good order is communicated in the military. Everybody in the unit should know why they need to do what they do. I've seen both projects and military operations fall apart because the team did not understand why they were doing whatever they were doing.
    • Organizations focus on delivering outcomes and impacts rather than features. Again, successful military operations focus on the goal rather than the how. back to giving orders again, it is about telling everybody what the goal is rather than giving step by step instructions. I've seen my squad leaders completely misunderstand an order I give in the heat of a moment but given the initial goal I gave everybody the end result tends to turn out the way I wanted.
    • Teams decide what to do next based on immediate and direct feedback from the use of their work. So this one where I didn't immediately see a similarity with the military. The explanation in the article makes a lot of sense but it is not the first thing the one-liner makes me think. I think the spirit is to empower the team, something (deja vu anybody?) that successful military organizations do too.
    • Everyone cares. One of the most boring parts of being in the military is that after an exercise you need to do a lot of maintenance on guns, vehicles, tents etc. In some units I've been people just do as they are told and often several individuals take a looooong time to complete their first task so that they don't have to do anything else. This way it takes forever to get done. In other units everybody just picks up whatever needs to be done, ask if they can help etc. Probably no surprise but the latter unit typically finishes their work long before the former.

    Though listed last, the everyone cares is the most important point of all these. If everyone cares that is probably enough to achieve great things. But it is also the most difficult one to achieve since it relies on each individual to actually care... In my experience I've seen that if the leaders (formal and informal) of a group cares and show that they care, the rest of the group typically start to care pretty quickly too. This takes the form of both taking action but also rewarding the team for caring.

  • Being Cellfish

    Implementing a good GetHashCode

    • 0 Comments

    If you've ever implemented GetHashCode you probably did it the way suggested in MSDN which is using XOR. And if you use R# you might have seen that it generates a different GetHashCode using prime numbers. So what should you do? I think there are three properties you want to aim for when it comes to implement GetHashCode, in order of importance.

    1. GetHashCode must be consistent. This should be a no-brainer. It simply means that for two objects that are equal, the should generate the same hash code every time.
    2. GetHashCode should provide random distribution output. Random here just means that it appears to be random, not that it is truly random since that would break rule number one. Also the output of GetHashCode is only an integer. That is only 32 bits. So if your object has a lot more possible states there will be hash collisions and you don't want them to be likely. For example if you have an object that consists of two different integers that you just XOR together, then (a ^ b) and (b ^ a) will return the same hash. You most definitely don't want this.
    3. GetHashCode should be fast. Since GetHashCode is used in a lot of collection classes you don't want this method to be slow.

    Given all this it turns out that the approach R# uses is pretty powerful into achieving all these goals. But the best possible approach is to use pick an algorithm that is suitable for your data. A few examples:

    • If your object have up to int.MAX possible values then a simple bit shift is probably a good way. Example: our object have two short values: GetHashCode() { return (a << 16) | b; }
    • If your object consists of other objects that generate good distribution hash codes and XOR or just multiplying them together is likely good enough for you. Please note that the GetHashCode for a lot of basic types do not generate good distribution values (especially bool and integers).
    • In all other cases and especially when in doubt it is preferable to go with an implementation like the one R# generates for you.

    If you want to read more about a number of different hashing options there a is a pretty good list here with lots of good information.

  • Being Cellfish

    Cost of meetings

    • 0 Comments

    This was recently sent to me and anybody who has worked at Microsoft knows that a lot of teams (if not all) have a lot of meetings and do a lot of communication over email. The essence of the article linked is that people who's work mainly consists of meetings need to understand that people who contribute mostly outside meetings will be less effective if their day is chopped up with a bunch of meetings. I think it is hard to argue that this is wrong since yes; meetings do take time from other things and with less meetings more things tend to get done. And if you have a few meetings in a day it makes sense to try to have them back to back I think.

    However I believe meetings is the less disruptive thing during my work day since meetings are scheduled. Every time I walk into somebody's office to discuss something without booking a meeting I interrupt whatever they are doing and vice versa. But that does not mean I want to batch them up. Most of the time a short interruption is not that bad I think and if it means somebody else on the team quickly can be unblocked without writing long emails and/or booking meetings I think the team as a whole will be more productive. And then there is email notifications, instant messages, phone calls etc that cause interruptions. So I think it is more important to make sure the team can handle interruptions and defer them until they can be handled. My favorite method for that is the Pomodoro technique!

    I am a believer in the Pomodoro technique since I do not think you can be productive and in the zone for hours. I do think the brain need some time to process thoughts in the background to quickly find solutions to problems. And I've felt the feeling of accomplishment when you know exactly how much you've gotten done in a day. The manager's vs maker's schedule article is good and worth reading but IMO it's just the tip of the iceberg and not addressing main problem. But it makes an important point that should not be forgotten.

  • Being Cellfish

    Implementing IDisposable

    • 1 Comments

    The IDisposable is probably one of the most abused interfaces in .Net. Except from all the cases where you actually have an unmanaged resource you need to release I've seen it being used a lot of times (including by myself) just to guarantee some code is executed immediatly when a variable go out of scope. I've used this in test utilities to make sure certain validation happens before the test execution ends but I've also seen this used in non-test code. The people who like to use IDisposable probably (like myself) have some experience from C++ and using smart pointers or similar there. I wish there was a similar construction in .Net where I could force execution of a certain method on an object immediatly when it goes out of scope if (and only if) I explicitly want that. Kind of an IDisposable that does not generate FxCop warnings when not disposed properly...

    Anyway, the best guid I've seen so far on how to actually implement IDisposable can be found here. Follow those guidelines and do what I do; stop abuse IDisposable constructs just because you think they make the code look neat.

Page 1 of 1 (4 items)