Source Code Is Only Half the IP

Nowadays every company needs to be making some kind of software. Every company needs a website, a mobile app maybe or more. Because of that most companies, including non-tech companies have either adopted a team of developers or have allocated a budget for outsourced software development.

We have all come to realize that source code becomes stale very quickly if it is not maintained and updated. Libraries, API’s, plugins, smart phones all change and applications that depend on those eventually stop working if they’re not updated. This means we live in a world where you can’t just pay a team of developers to build a website or an app and then it’s just “done”. Software development is a never-ending process.

Because software development is never ending, projects typically last years if not eternity. People rarely stick around for the whole lifespan of a software project. Software developers stick around even less than others because they get bored and the market currently offers a tremendous amount of opportunities.

A high turnover of software developers has a negative impact on the source code. An interesting paper: “Impact of Developer Turnover on Quality
in Open-Source Software” (Foucault et. al.) looked into the impacts on quality of turnover in open-source projects.

I think source code is just as valuable as the people who wrote it. It is tempting sometimes but you can’t just buy source code from a vendor or acquire a startup for its source code. Turnover has a negative impact on quality because it takes an incredible amount of effort for a new person to get accustomed with an existing code base. This leads new developers to often want to rewrite code they don’t understand, mis-use existing functionality, duplicate existing functionality they’re not aware of and so on. High turnover eventually leads to deprecation of the product’s quality as a whole.

So what do leaving developers have that new developers don’t have? Developers who wrote some code and leave know something. They know what works, how it works, what’s possible and also… what doesn’t work. They have ideas for what should be done next, what can be improved and how. They have the confidence to tear down what needs tearing and the knowledge on how to use complex functionality that newbies may not understand.

All the above knowledge I believe is a part of the intellectual property of a software product. Many software developers are interchangeable but a team isn’t because a team keeps that knowledge alive.

Something interesting I have found recently is that this also applies to design. Essentially any role that is creative (I count software development as creative) involves some abstract knowledge that doesn’t get recorded. New designers on a team often want to re-design elements and flows they don’t fully grasp. Those eventually end up repeating past efforts. The design of a product as a whole ends up suffering from designer turnover just like the source code’s quality.

The point of this post is essentially to uncover the abstract and non-recorded aspect of software products’ intellectual property. Code and designs are half the intellectual property, the people who made it always carry the other half.