Code bases can easily become unwieldy and fragmented over time
Developers wasting time looking for existing implementations of functions reduces departmental efficiency
Developers rewriting code that already exists creates a fractured code base which is difficult to maintain
Present State
Desired state
Large codebases are difficult to manage and fragmented
Large code bases act as fonts of knowledge for new and established devs
Decrease the size of codebases and make them more streamlined
Create a large volume of documentation and keep track of all of the code written by the software department
Make programming languages which abstract a lot of the volume away, reduce the functionality of corporate applications to their bare minimum, enforce strict coding guidelines to reduce clutter
Compile all of the README's from the company's repositories and make the software developers write thorough documentation, manually go through the old codebases and document everything, get senior developers with experience with the older parts of the codebase show new developers what there is to learn
Generate an automated code indexing software which developers can use to search for pre existing code and the associated documentation in their favorite IDE
Timing: rapid development of this solution would have to occur for it to be useful. We are at a point when many legacy companies are either going out of business or are starting to develop new pieces of software. Should they go ot of business for not adapting, that is a source of revenue that we have missed. However, should they want to build new software we can provide a very alluring promise. The ability to efficiently search through their old codebases and reuse functional logic would save them a tremendous amount of development time. Additionally, the ability to index their new code in an efficient manner guarantees that they will be able to modernize their systems even faster in the long term.
Trend: Numerous pieces of software have tried to address this problem tangentially. Some of it is done through documentation services like Doxygen, other platforms try to efficiently index dependencies and build parameters like npm and yarn, however, nobody has tried to index code yet. Based off of the rapid growth of the technology sector and our increasing reliance of software this seems like the best time to come up with a good way to organize it.
Impact: New companies will be able to rapidly grow and expand their services by taking advantage of repeated logic acorss platforms. Additionally, employee onboarding to their software departments would be rapidly sped up, as they would have extensive access to a database of existing code an documentation. Older employeed wouldn't need to walk them through it. Older companies would be able to modernize their services more efficiently be being able to take full advantage of the resources they have at their disposal, as apposed to doing a complete rework of foundational systems.
What
We know that maintaining large codebases is difficult
We are constrained to not force a huge amount of extra labor on the developers, therefore reducing their productivity
We want to make using existing knowledge easier and make code bases more modular
When
The problem started after companies started building layer upon layer of product over old code
The solution must be implemented as soon as possible
Who
Employees at larger companies like IBM would be able to provide invaluable insight
The customer is the head of product implementation / tool acquisition at companies
The customer is an independent developer who wants a clean and easy way to search through his / her old code and keep their work consistent
Where
Technology companies
Companies with large amount of code
The customer can be located anywhere in the world
Why
The problem is important because increasing efficieny of software departments increases product quality, profit, and turnaround time
The solution work because it is automated and easily searchable
The problem is there because people aren't perfect, so things get disorganized over time
How
The problem developed through natural entropy and employee turnover.
The task can be perfomed by a large amount of menial labor or by developing an automated program to do it
This problem is unique because software has an additive property. You can build new code on top of old code in a way you normally can't with other things