Code ownership

This article is about a term used during software development. For the actual ownership of software, see Intellectual property rights.

In software engineering, code ownership is a term used to describe control of an individual software developer or a development team over source code modifications of a module or a product. ^[1]

Definitions

While the term is very popular, there is no universally accepted definition of it. Koana et al., in their 2024 literature review, found 28 different definitions, ^[2] and classified them as follows:

• Psychological ownership is a feeling by the developer of ownership and pride in the particular element of the project; ^[3]
• Corporeal ownership is a set of formal or informal rules defining responsibility for a particular software piece. The rules depend on the development approach taken by the team, but generally can be partitioned along the lines of "what is being owned?" / "who owns it?" / "what is the degree of control?": ^[3]
  • while the answer to "what?" is typically some part of the source code, the ownership concept have been also applied to other artifacts of the software development as diverse as an entire project or a single software bug; ^[4]
  • the owner ("who?") might be an individual developer or a group that might include authors of the code, reviewers, and managers. ^[5] The two extremes are represented by a dedicated ownership with just one developer responsible for any particular piece of code and a collective code ownership, where every member of the team owns all the code; ^[5]
  • the degree of control by an owner can vary from a mandatory code review to responsibility for testing to a complete implementation.^{[ citation needed ]}

Authorship

Some researchers also use the term to describe the authorship of software (identifying who wrote a particular line of software). Koana et al. state that this is a different, although related, meaning, as the code owner might not be original author of the software piece. ^[3]

Influence upon quality

It is generally accepted that the lack of clear code ownership (usually in the form of many developers freely applying small changes to a shared piece of code) is causing errors to be introduced. At the same time, with no code owner, the knowledge about an artifact can be lost. This is confirmed by large-scale studies, for example, involving Windows 7 and Windows Vista. ^[6]

Code owners in version control

Modern version control systems allow explicit designation of code owners for particular files or directories (cf. GitHub CODEOWNERS feature). Typically, the code owner is either receiving notifications for all the changes in the owned code or is required to approve each change. ^[7]

References

1. Metiu 2006, p. 424.
2. Koana et al. 2024, p. 2.
3. Koana et al. 2024, p. 8.
4. Koana et al. 2024, pp. 9–11.
5. Koana et al. 2024, p. 11.
6. Greiler, Herzig & Czerwonka 2015, p. 2.
7. "About code owners". GitHub.

Sources

• Greiler, Michaela; Herzig, Kim; Czerwonka, Jacek (2015). Code Ownership and Software Quality: A Replication Study (PDF). IEEE. doi:10.1109/msr.2015.8.
• Koana, Umme Ayman; Le, Quang Hy; Rahman, Shadikur; Carlson, Chris; Chew, Francis; Nayebi, Maleknaz (2024-09-27). "Examining ownership models in software teams". Empirical Software Engineering. 29 (6). Springer Science and Business Media LLC. arXiv: 2405.15665 . doi:10.1007/s10664-024-10538-5. ISSN   1382-3256.
• Metiu, Anca (2006). "Owning the Code: Status Closure in Distributed Groups". Organization Science. 17 (4). INFORMS: 418–435. ISSN   1047-7039. JSTOR   25146047 . Retrieved 2024-11-04.