# Developer value

## Developer is more valuable if his / her code does not have to be rewritten for a long time.

A good developer can write a lot of good code and bring a lot of revenue to the company. The value of a great developer is much much higher not becaue he is writing 10x better code, but because his code runs in production 10x longer! Here is the math that makes it obvious. I cannot claim the ownership of this example, it belongs to Joe Hicklin, chief scientist at MathWorks, with whom I had pleasure working at one time.

Each year MathWorks roughly gets \$1 million in revenue per each developer. This is huge number, do we really write such exceptional code every year? Each and every one of us? Definitely no. Instead we do not rewrite the same code over and over again. We give every developer time to write good code that we expect to run for a long time, bringing enough money over its lifetime to add up to \$1m.

Imagine a developer writing new software every year that the company can sell for \$100k per year. Assume the software written in year one keeps working and producing same \$100k in year 2, 3, etc.

``````year    value written that year     total per year value
1             100k                    100k
2             100k                    200k
3             100k                    300k
...
10            100k                    1m
``````

Lets say the software written during the first year now needs to be rewritten (due to platform changes, for example)

``````year    value written that year     total year value
11             100k                1m + 100k - 100k = 1m
``````

If any software needs to be rewritten, the developer's value curve platoed at \$1m.

Good developers might rewrite software every 3-5 years to port to new platform, language, hardware. Thus their average per year value platoes around \$400k per year. Nice, but not exceptional.

A great developer might design software that can be maintained without major costs for a long time, producing value. He might also write the software in modular fashion, so that porting to new environment only costs 10%, leaving the main bulk to keep producing value. Assuming per year loss of productivity 10% (to write long running software), a great developer could reach \$1m in per year revenue in 11 years.

In reality, a smart developer would reach the mark much faster, since a good base makes producing better software easier and cheaper. Of course it requires long term thinking from both sides: the developer and the organization needs to calculate the numbers, just like I did to see that the most expensive thing one can do is cut corners each year.

One needs to be very very rich to afford cheap things.

See project commit-survivor that computes how much code survived from your previous commits.