{"id":118718,"date":"2019-10-10T16:38:02","date_gmt":"2019-10-10T16:38:02","guid":{"rendered":"https:\/\/livablesoftware.com\/?p=118718"},"modified":"2019-10-10T16:40:26","modified_gmt":"2019-10-10T16:40:26","slug":"governance-strategies-programming-languages","status":"publish","type":"post","link":"https:\/\/livablesoftware.com\/governance-strategies-programming-languages\/","title":{"rendered":"Governance strategies in Programming Languages – Who decides what gets in the language?"},"content":{"rendered":"

General Programming Languages (GPLs), like Java, PHP, C++,… continuously evolve to adapt to the ever changing technology landscape. The evolution is rooted on technical aspects but it is ultimately decided by the group of people governing the language<\/strong> and working together to solve, vote and approve the new language extensions and modifications. As in any community, governance rules are used to manage the community, help to prioritize their tasks and come to a decision.<\/p>\n

Typically, these rules specify the decision-making mechanism used in the project, thus contributing to its long-term sustainability by clarifying how core language developers (external contributors and even end-users of the language) can work together. Despite their importance, this core topic has been largely ignored in the study of GPLs.<\/p>\n

In this post, we present our paper “Analysis and Modeling of the Governance in General Programming Languages<\/em>” accepted at the ACM SIGPLAN International Conference on Software Language Engineering (SLE’19)<\/a> where we study eight well-known GPLs and analyze how they govern their evolution. We believe this study helps to clarify the different approaches GPLs use in this regard. These governance models, depicted as a feature model, can then be reused and mixed by developers of new languages to define their own governance.<\/p>\n

1. Introduction<\/h2>\n

Evolution of General Programming Languages (GPLs) is a highly technical activity that may involve improvements on the language syntax, parsing, conformance and performance, among others. Similar to any (open source) software project, this evolution largely depends on the work of a community of developers and end-users of the language willing to contribute to its evolution, some times on a volunteer basis (contributors may also be paid by companies that sponsor the project or, for some languages, employed by the companies that drive the language forward). While several works have focused on the technical challenges of language evolution [11, 13, 14], little attention has been paid to the problem of better understanding how the community organizes itself to evolve the language.<\/p>\n

Ideally, the community organization should be transparent and explicitly explained in a set of governance rules, where each rule partially describes how to contribute to certain aspects of the language evolution and how decisions for the acceptance\/rejection of such contributions are made. Governance rules could be as simple as stating the project follows a BDFL model (i.e., a dictatorship model) or complex enough to model more democratic and participatory processes.<\/p>\n

So far, little is known regarding the governance practices in current GPLs. Even if there is no one-fits-all solution, having a broad perspective of the governance models<\/a> in place (and how these models relate to other characteristics of the language) can shed some light on the complex problem of language evolution from a new and fresh perspective. We believe this would also help developers of new languages to make informed decisions when creating or developing languages. This paper, where we analyze the governance models of eight well-known GPLs and build a feature model characterizing them and facilitating the configuration of governance rules for new languages, is a first step in this direction. We focus on GPLs, which usually have larger audiences and facilitate the analysis, but our work can also help when developing Domain-Specific Languages (DSLs) [1].<\/p>\n

The rest of the paper is structured as follows. Section 2 introduces the languages considered in our study. Section 3 analyzes the selected languages and Section 4 summarizes the results as a feature model. Section 5 presents threats to validity. Section 6 shows the related work and Section 7 finalizes the paper and discusses our ideas for future work.<\/p>\n

2. Language Selection<\/h2>\n

To perform our initial study we selected eight well-known GPLs representing the diverse set of governance models in language development<\/strong>. As all the selected languages are well-known, we only comment on the most relevant governance or evolution aspect that we took into account to include the language in our study.<\/p>\n

C++<\/strong>\u00a0\u00a0 The language was created in 1985 by Bjarne Stroustrup as an extension of C. It has been included in the study as an example of a language standardized by the International Organization for Standardization (ISO; in 1998).<\/p>\n

Go<\/strong>\u00a0\u00a0 Google designed Go in 2009 mainly to address multicore and networked machines. We included Go in our study as an example of a company-driven language.<\/p>\n

Java<\/strong> \u00a0 The language was created in 1995 by Oracle Corporation, being James Gosling one of the main designers. The language relies on a decision-making mechanism were membership levels play an important role, which we considered interesting for our study.<\/p>\n

Kotlin<\/strong>\u00a0\u00a0 The language was created by JetBrains in 2011 and adopted by Google to support the development of Android applications. As for Go, we selected this language as an example of a company-driven language. But, different from Go, the company behind Kotlin has a business model directly related to the GPL field.<\/p>\n

PHP<\/strong>\u00a0\u00a0 The language was created in 1995 by Rasmus Lerdorf and later developed by PHP Group. The development process relies on a participatory governance model which we found interesting to consider in our study.<\/p>\n

Python<\/strong>\u00a0\u00a0 Guido van Rossum created this language in 1990 and ruled the development process until 2018. The Python Software Foundation is currently in charge of its development. We selected this language due to the evolution of its governance model in the last years, which started with a classic BDFL model.<\/p>\n

R<\/strong>\u00a0\u00a0 The language was created by several developers in 1993. We selected this language as it is mainly designed for statistical and data analysis, a field different from the other languages considered in our study.<\/p>\n

Scala<\/strong>\u00a0\u00a0 The language was designed by Martin Odersky at the \u00c9cole Polytechnique F\u00e9d\u00e9rale de Lausanne in 2004. We selected this language as example of a language with clear origins in academia and a visible leader.<\/p>\n

3. Analysis of Governance in GPLs<\/h2>\n

The selected GPLs were analyzed according to four dimensions, namely: transparency, membership, language changes (with two main subdimensions: structural changes and language improvements) and decision-making process to move the language forward. Next we describe each dimension and present the results obtained in our study. Table 1 shows the dimensions and summarizes the results.<\/p>\n

\"\"<\/a><\/p>\n

Table 1. Analysis of the selected GPLs.<\/strong><\/p>\n

Transparency<\/strong>\u00a0\u00a0 This dimension examines the existence and content of the informative resources helpful to understand the development process of a GPL. We analyze whether (1) the language is developed under a specific license (column License), (2) there is a code of conduct document (column CoC) and (3) there is a clear and public release cycle (column\u00a0RC).<\/p>\n

Interestingly enough, our results reveal that only half of the analyzed languages are transparent and provide this kind of information. Not having a clear description of the code of conduct or the release cycle sets the entry barrier for future contributors rather at a high level.<\/p>\n

Membership<\/strong>\u00a0\u00a0 This dimension studies membership levels in the GPL community and whether contributors have to be members (and, if so, what kind of members and how they can progress from one membership level to the upper one) before being able to drive the development.<\/p>\n

Only three of the analyzed languages used a membership organization in their evolution processes, all them with specificities:<\/p>\n