This question is a bit philosophic and is about making new use cases for software companies. Let me describe what exist for now, why it is not enough, and what is needed.
I know that there are a lot of existing researches in applying ML for software (please don't simply point to this one!), but none of them consider the application of ML for software company, not the software alone.
Existent approaches that apply AI for software engineering tasks consider it as follows:
human1 -> software (big code) <- human2
That means that
human1 makes some part of
software (that is a part of
big code), and
human2 reuses some knowledge from it. It may be a bugfix pattern (as e.g. DeepCode does), API usage pattern, repair of code, summarization of code, code search, or whatever else. I think the main reason for this is the original hypothesis of naturalness:
The naturalness hypothesis. Software is a form of human communication; software corpora have similar statistical properties to natural language corpora, and these properties can be exploited to build better software engineering tools.
(from Allamanis et al, page 3)
But imagine one software company. It has:
- Some number of engineers,
- Some number of managers,
- The software product,
- Information related to the software product (documentation, bug/task tracking system, code review),
- Some number of formal management processes (waterfall, scrum or whatever else),
- Some number of informal processes
But none of these models consider the software as a product itself. I mean that we should consider the model as follows:
company -> software product -> customers | v big code
engineer1 -> | | engineer2 -> | | ... | ----> software product ----> customers | | engineerN -> | | | | manager --> | | v big code
So my questions are:
- Are there any cases of investigation of such models?
- Are there any similar cases in related fields, say in general companies (not specifically software ones)?
- Are there any analogies (not specifically from software-related domains) where some knowledge can be transferred from a bigger object (
big codein our case) to a smaller one (
Any ideas are welcome.