Somehow this is a grossly exaggerated notion within the software community but in every field we find people that performs better (by some measure) than the average by a very high margin.
I witnessed that with my very own eyes and they are not magical creatures. There’s a lot written about them but they tend to share some common traits of overachievers that make the real difference from the rest:
- They have a clue about what they are doing.
- They are focused.
- They work on things that matter.
(Or as Yosef puts it in http://yosefk.com/blog/10x-more-selective.html, things that aren’t going down the toilet. I like it when he says, “The hardest part of “managing” these 10x folks – people widely known as extremely productive – is actually convincing them to work on something. (The rest of managing them tends to be easy – they know what’s what; once they decide to do something, it’s done.“)
Now, I’m not the brightest bulb but when I tackle a problem I try as much as I can to understand its domain. I ask myself frequently if there’s a better way to approach it, as it’s very rare to come across something so unique that nobody worked on anything that barely resembles it (or that can be applied to the current problem).
I’m working on a system that it’s getting older but the foundation is solid and it shows. Everything makes sense, even if you have no idea about a piece is often it can be found in an intuitive way and the core looks beautiful, even if it’s made with dying technologies. The architecture is very well designed and implemented.
But then people came and started adding little things here and there without very much thought. They built XML files concatenating strings, they copied the routines into 34 (that’s real) places and each one has a little difference (that’s kinda ok, they talk to things so horrible that can’t process CDATA fields and use a custom encoding instead). The idea of having all the common stuff in one place never crossed their minds or, shiver, use a standard library (they existed and were mature back when those things were implemented).
They also wrote lots, and lots, of functions like (php):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| private function frobnicate($the_frob)
{
// Selects the baz of the frob.
// If it's one kind of baz
if($the_frob->is_of_type('one kind of baz'))
{
return $this->baz = 'Baz1';
}
// If it's a special baz
if($the_frob->is_of_type('a special baz'))
{
return $this->baz = 'Special';
}
// If it's a straw one
if($the_frob->is_of_type('a straw one'))
{
return $this->baz = 'nuts';
}
// ... snip about 200 lines of the same ...
return $this->baz = 'the default value';
} |
private function frobnicate($the_frob)
{
// Selects the baz of the frob.
// If it's one kind of baz
if($the_frob->is_of_type('one kind of baz'))
{
return $this->baz = 'Baz1';
}
// If it's a special baz
if($the_frob->is_of_type('a special baz'))
{
return $this->baz = 'Special';
}
// If it's a straw one
if($the_frob->is_of_type('a straw one'))
{
return $this->baz = 'nuts';
}
// ... snip about 200 lines of the same ...
return $this->baz = 'the default value';
}
And this is repeated in about 56 places, intertwined with many more conditionals. I only hope this was generated code and not typed by hand.
Anyway, I nuked it and turned that wall of if statements into:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| private function frobnicate($the_frob)
{
// Selects the baz of the frob.
$map = array(
'one kind of baz' => 'Baz1',
'a special baz' => 'Special',
'a straw one' => 'nuts',
// ... you get the picture ...
);
foreach($map as $type => $baz) {
if ($the_frob->is_of_type($type)) {
return $this->baz = $baz;
}
}
return $this->baz = 'the default value';
} |
private function frobnicate($the_frob)
{
// Selects the baz of the frob.
$map = array(
'one kind of baz' => 'Baz1',
'a special baz' => 'Special',
'a straw one' => 'nuts',
// ... you get the picture ...
);
foreach($map as $type => $baz) {
if ($the_frob->is_of_type($type)) {
return $this->baz = $baz;
}
}
return $this->baz = 'the default value';
}
And that’s even not clever (table driven programming has been around for quite some time).
I mean, after doing it three times I question if there’s a better, more concise way of expressing the same. But for some people that moment never comes.
Focus.
These days I’m having trouble to keep focused for more than four hours straight, make that six in a very very god day. I guess that’s a given with age and more responsibilities. Doing boring stuff doesn’t help either, but it’s a good incentive to finish as soon as possible without mistakes.
Do things that matter.
This deeply touches me.
Nowadays most of the stuff I do at work to put food on the plate is meaningless and boring to death. It makes life easier for a lot of people but nothing will change if it goes away overnight. Many will cry but nothing terrible.
It doesn’t give me a technical challenge any more. At best it teaches me patience and how to deal with utterly broken and stupid systems that were not designed to be used (not by computers and certainly not by humans). It drains my energy and I’m past the point where it makes sense to put up with it.
It doesn’t make the world a better place, not even by chance.
Do I do things that matter? Yes, on weekends and sometimes by night.
Can I make a living out of them? Not now.
Not yet.
