We live in a software-enabled world. Software is the infrastructure that powers our digital society. And yet, software development is in a permanent state of crisis. Improvements in programming tools, languages and methods have not been able to keep up with the increasing complexity, demands and trust we expect from all running software.

Most critical software is built as Open Source Software (OSS) or heavily relies on it. While OSS brings many benefits, successful projects suffer from the “tragedy of the commons”: everybody uses them but very few contribute back. Indeed, as the heartbleed bug in OpenSSL dramatically uncovered, many core infrastructure software projects depend solely on the effort of a few committed individuals. Our digital infrastructure stands on shaky grounds with many critical software facing deep sustainability problems.

We propose to use a swarm of bots to ensure the sustainability of critical software. We called our proposal BOSS: Bots for open source sustainability. BOSS aims to transform software development by providing a framework to model, generate, personalize and combine software bots to help in all phases of software development and maintenance, including community management. Simple bots will take care of janitorial tasks (e.g. assigning labels to new issues). Smart bots will learn from the project data to become highly qualified assistants (e.g. able to chat with users to make sure bug reports are detailed enough and automatically triage them). Bots may not be the silver bullet for software development but incremental techniques will not solve this sustainability challenge either.

BOSS aims to make open-source development sustainable by providing a framework to model, generate, personalize and combine software bots to help in all phases of software development and maintenance, including community management. Click To Tweet

A number of useful bots for software development have started to pop up but they are all independent initiatives that, alone, can’t have a significant impact. IMHO, we need a more unified framework that makes it easier, even for non-experts, to easily create, adapt and install bots in their own projects, regardless the programming languages they use, their governance and contributing practices or even the code hosting platform they are in. Xatkit (our open-source bot development platform) could play a role here as it already offers a way to chat with GitHub.

Keep reading to know more about our vision for this bot-enabled future (by the way, we’re looking for funding to make it happen, if you know anybody that could be interested in supporting this initiative let us know!).

On the Sustainability problem in open source software projects

A profound digital transformation is underway, disrupting business and organizational activities, processes, competencies and models to fully leverage the opportunities of digital technologies and their accelerating impact across European societies[1]. Software is the underlying infrastructure powering this digital transformation and therefore it is critical for the daily activities and future evolution of our society.

Most of this software is (or heavily relies on) open source software (OSS). As stated in the European Software Strategy Report: “Software is everywhere today, yet its instrumental role in the modern digital economy is often overlooked. With market revenues of over €200 billion in Europe software is the largest and the fastest growing segment of the ICT market … OSS is now playing a significant role in this Software economy. A number of OSS specific actions could contribute to growth in Europe, jobs creation and improvement of the European Software imbalance

This is, in principle, a good thing since, according to the Open Source initiative: “OSS development is a development method that harnesses the power of distributed peer review and transparency….The promise of OSS is better quality, higher reliability, more flexibility and lower cost“. This level of quality is due to the active participation of the whole community[1] [2], including project owners, external contributors and end users. Indeed, in OSS, users are supposed to be key members of the software community and contribute in any form or shape they can, e.g. submitting bug reports, feature requests or just giving feedback.

Unfortunately, the reality of (open source) software development is rather different. And, therefore, its potential benefits to the European society and to the development of our digital infrastructure are at risk. OSS suffers from what it is known as the “tragedy of the commons”: everybody wants to benefit from the software but they all hope others will chip in. That is, there is a grossly disproportionate imbalance between those consuming the software and those participating in building the software.

This exposes the unsustainability of OSS development.  OSS projects cannot cope with the current pace of increasing complexity of software systems (including cyber-physical systems) and the demands coming from new application domains (like IoT, Big Data). And this is true for many very critical projects. A well-known example is the OpenSSL cryptographic library project that, despite being used by two-thirds of the Web, was maintained by just one full-time employee (as the famous heartbleed bug exposed). A more recent example is the fever around blockchain and cryptocurrencies.  Despite being worth over $30bn and $65bn, there are only 15 meaningful contributors to the core Ethereum and Bitcoin projects respectively. As a result of these sustainability challenges, a significant number of software projects are unsuccessful, fail shortly after its initial release [3] or become vulnerable to security attacks (e.g. malicious code injections). Innovation cannot depend on a process involving a few humans’ timings, circumstances and business luck.

Example of the Sustainability problem in open source: Despite being worth over $30bn and $65bn, there are only 15 meaningful contributors to the core Ethereum and Bitcoin projects respectively Click To Tweet

And while improvements in tools, languages and methods in the last decades have been staggering, I argue in this proposal that an incremental improvement on current software development tools and techniques will not be enough to correct this situation.

Instead, I advocate for a radical shift in the way software is developed and maintained based on a self-guiding swarm of software bots to assist project owners, core developers, occasional contributors and end users in all their software-related tasks, going all the way up from simple tasks like correcting spelling mistakes or welcoming new project members to advanced bots able to help users in writing good bug reports or to automatically reject/fix contributions that violate the project guidelines or code of conduct.

This vision will be achieved by implementing an ambitious and innovative multi-dimensional and cross-disciplinary research agenda that will bring to the software field expertise available in other academic disciplines like AI and sociology and mix it with our own abstraction and language engineering techniques in order to define a general framework to model, generate, personalize and combine software bots as the way to ensure the long-term sustainability of all software projects.

State of the art in open source analysis

The software research community has been chasing forever the silver bullet that will fix all problems in software engineering [4]. Recently, the availability of a massive dataset of software project data in repositories like GitHub (with over 55 million projects, even if data needs to be taken with a grain of salt [5]–[7][8], has opened new research opportunities focusing on mining such repositories for valuable insights on good software development practices. I have performed a systematic literature review of these papers resulting in the selection, analysis and classification of over 100 papers focusing on mining GitHub to learn best open source development practices [9].

Published papers analyze software projects from different angles but mostly with a code-centric view, meaning that they focus their attention on the projects’ source code by evaluating, for instance, the use of programming languages (e.g., [10], [11]), the type of license (e.g., [12], [13]), the potential vulnerabilities and complexity of the code (e.g., [14], [15]) or its testing and refactoring practices (e.g., [16], [17], [18]). Only a few works analyze the social part of the software development process, trying to understand how developers are attracted and (self)organized to work together in the project. There are studies on the team diversity (e.g., [19], [20]), composition (e.g., [21], [22][23][24]), onboarding (e.g., [25]), the pull request development model (e.g., [26], [27]),  social coding (e.g., [28]) and motivational factors (e.g., [29]).

While these works characterize many dimensions of software development, they are of little help when it comes to address the current software sustainability issues, which I see as a grand challenge for software engineering research. The importance of this problem has been recognized by several foundations and organizations (see for instance Sustain  and CHAOSS ) that are starting to define a public research agenda that could solve the problem before open source enters a state of crisis.

BOSS proposes to solve this challenge by means of semi-automating as many software-related tasks as possible by relying on the use of (intelligent) software bots. This idea of cognifying (cognification can be defined as the application of knowledge to boost the performance and impact of a process [69]) software development was already stated by F. Brooks in this famous paper [30]:

“the most powerful contribution of expert systems will surely be to put at the service of the inexperienced programmer the experience and accumulated wisdom of the best programmers” – Fred Brooks already defending the important role of AI in software development 30 years ago

Bots will play this role of expert systems seamlessly integrated in the development process. Some recent “smart” IDEs are indeed now following this path by learning, for instance, from StackOverflow to help you complete your code. Still, AI can play a much larger role to ensure software sustainability and go far beyond helping to code better.

This vision of AI/bots helping in software development has also been explored in several short pieces [31][32][33] but none of them goes beyond the idea phase. A few specific applications of AI (or AI-like) solutions to help on particular tasks have also been proposed. For instance, to recommend developers to open tasks [34], for requirements prioritization [35], software defect prediction [36], developers’ productivity [37]. A couple of them have been deployed as bots that answer developers’ questions [38][39]. Still, these initiatives are the exception rather than the norm. The use of bots in software engineering remains a largely unexplored research field.

Despite the huge size of the bot market (over several billions of dollars), most bots are social bots (e.g. twitter bots faking real humans) or marketing bots on FB messenger and other messaging platforms. There are few bots for software (mostly deployed in GitHub) and most of them do simple janitorial tasks with very limited (if any at all) personalization and cooperation capabilities. Moreover, there is a myriad of low-level libraries (every major software company has at least one!) and platforms to build those bots, each one targeting a specific language and domain focus, fragmenting the market and making difficult the reusability and interoperability of bots. These limitations heavily increase the cost of building software bots and severely restrict their adoption and benefits.

BOSS aims to develop original research contributions to overcome all these challenges. Beyond the core topics mentioned before, BOSS will also rely on previous research done on related areas such as automatic repair and multi-agent systems when possible, as described in the next section.

Research Agenda for BOSS: a Bot-enabled Sustainable future for OSS 

Transforming (open source) software engineering into a successful and sustainable process requires being able to get as much additional help as possible to manage the software and the community around it. But hiring more programmers is not a practical solution given the large number of projects to fund, the shortage of professional programmers and the well-known challenges of onboarding [25] new members into an ongoing project. Instead, I advocate for hiring help for free (well, not all bots will be free; a variety of business models will co-exist: freemium, bots as a service, pay-per-seat,… but in any case they can be regarded as extremely “cheap labour” when compared with the cost of hiring people) and fully available on-demand in the form of bots as the only scalable solution.

Therefore, the main objective of this project can be stated as:

Building, One Bot at a Time, a Unified Framework for Sustainable Software Development

More specifically, BOSS aims to transform software development by providing a framework to model, generate, personalize and combine and coordinate software bots to help in all phases of software development and maintenance. The following figure tries to illustrate this change of perspective, highlighting how we go from the current developer centric view (a) to a more open environment (b) where different types of bots interact with all kinds of member profiles to advance the project in a way that satisfies as much as possible the goals of the community as a whole.

Our proposal for open source software sustainability

This overall objective will be elaborated via the following Specific Objectives: (SO1) Re-thinking the development of software bots, (SO2): Empowering bots through Machine Learning: generating smart bots, (SO3): Bot swarms for software ecosystems, (SO4): Verification and testing of bots and (SO5):  Evaluating the Social impact of bots. To ensure the applicability and impact of these objectives, a number of parallel activities will be also conducted, including the creation of a benchmark of critical open source projects to test the bots, the release of the languages, workbenches and generators developed to build the bots and a bot marketplace where interested people could go to select and deploy new bots for their project.

SO1 – Re-thinking Software Bots Development: A model-based approach for bots

Grady Booch famously said “the entire history of software engineering is one of raising the levels of abstraction”.  This also applies to software bots. Raising the level of abstraction at what bots are specified is the solution to be able to provide a more generic and reusable approach to bot development. Model-driven engineering (MDE) [43] techniques will be used for this purpose. By working at the model level, the developer can hide irrelevant technical details and focus on the core concepts that bot needs to manipulate.

To this purpose, we will propose BotsML, a domain-specific language for software bots. BotsML will would include concepts like project, issue, commit, dependency,… as first-class elements in the language facilitating the definition of bots that need to manipulate those concepts.  BotsML will come with a series of extensible code generators targeting different combinations of code hosting platforms and bot programming libraries. This will be the first platform and technology independent bot framework. Related work from the agents community (see  [41] for a survey) will be used as inspiration.

SO2 – Empowering bots: Generation of smart bots

Integration of machine-learning (ML) components in the bot development process is required to go beyond bots performing janitorial tasks based on simple rule-based definitions. Depending on the bot objective, this ML component could extend the bot with advanced natural language processing capabilities (the case of chatbots, e.g. to help people write good bug reports that maximize their chances of getting the bug solved quickly) or predictive models that enable the bot to better perform its tasks based on supervised learning on the project historical data (or other curated test data from relevant OSS projects), for instance, to detect when a new bug is suited for first-time contributors. Or a combination of both [44].  To accomplish this objective, BOSS will extend the core framework resulting from SO1 with model-based integrations for messaging platforms (like Slack or FB Messenger) and ML libraries (like TensorFlow or Gluon) and platforms (like CloudML by Google,  Amazon ML or Azure ML studio). Beyond modeling the APIs and interactions with these components, a proper integration will require as well coming up with the set of modeling primitives to specify the bot learning model itself, including the hyperparameters to use in the learning process and the test data to be used during the training. There are no approaches that provide this kind of high-level (and platform-independent) modeling for ML scenarios ([45] is a short paper that outlines a vision in this direction for the specific case of Deep Learning)

SO3: Bot swarms

There is only so much a single bot can accomplish. For complex management tasks, project owners should be able to combine different heterogeneous bots. And those bots should be aware of each other and be able to coordinate themselves for a better result. BOSS will investigate how to adapt Belief-Desire-Intention concepts [49] from the agents community in order to propose new software governance and collaboration languages (extensions of [47][48]) for bot swarms. Advanced and autonomous collaboration will also require research on automatic bot discovery services and personalization strategies to facilitate the integration of a bot swarm in a specific project. And projects are always part of a project ecosystem [50], forcing bot swarms to understand the whole ecosystem when needed (e.g. bots could monitor vulnerability databases for potential risks to the project based on its external dependencies and generate automatic fixes [53]). To make sure, no malicious bots are hidden in the bot swarm and attacking the project instead of helping it, BOSS will propose MetaBots for bot monitoring.

SO4: Verification and Testing of bots

As any other software component, quality assurance of bots is a must but nowadays this aspect is completely disregarded. In BOSS, novel research techniques to assess the correctness of bots from different perspectives/dimensions will be developed. Consistency of the bots’ specifications will be evaluated reusing bounded verification techniques [54] and model checking [55]. Bot testing techniques, extending current model-based testing approaches [56], will be proposed to evaluate smart bots especially regarding their integration with the external ML components (black-boxes for testing purposes). Validation will be addressed by simulation. The idea would be to release the bots in historical (or parallel) versions of the project and simulate the behavior of the bots in that sandbox before deploying them on the real data.

SO5: Evaluating the social impact of bots

Software bots do not work in isolation. Their actions constantly interweave with those of the people in the project. As a result, any bot research project must consider the social implications of bots. BOSS will study the factors that influence the social acceptance of bots. The hypothesis is that bots able to learn and mimic the specific idiosyncrasy of a project (including its vocabulary and natural language use) will face less resistance. BOSS will also study how bots can help in creating more welcoming communities. For instance, BOSS will evaluate the power of bots to increase the diversity (geographical, gender, economical) of project communities. Increased gender and tenure diversity are associated with greater productivity [57] but reaching such diversity is a challenge[58]. For instance, bots could be used to identify people from minorities attempting to contribute to the project and help them move along. Similarly, bots could be helpful to detect online harassment and report violations of the project’s code of conduct [59]. Sentiment analysis techniques will be used for this.


[1]      R. Schuwer, M. van Genuchten, and L. Hatton, “On the Impact of Being Open,” IEEE Softw., vol. 32, no. 5, pp. 81–83, Sep. 2015.

[2]      E. S. Raymond, The Cathedral and the Bazaar. O’Reilly Media, 2001.

[3]      C. M. Schweik and R. C. English, Internet Success: A Study of Open-Source Software Commons. The MIT Press, 2012.

[4]      F. P. . J. Brooks, “No Silver Bullet Essence and Accidents of Software Engineering,” Computer (Long. Beach. Calif)., vol. 20, no. 4, pp. 10–19, Apr. 1987.

[5]      C. Bird, P. Rigby, and E. Barr, “The promises and perils of mining git,” in 6th International Working Conference on Mining Software Repositories, 2009, pp. 1–10.

[6]      J. Howison and K. Crowston, “The perils and pitfalls of mining SourceForge,” in Proc. of Workshop on Mining Software Repositories, 2004, pp. 7–11.

[7]      E. Kalliamvakou, G. Gousios, K. Blincoe, L. Singer, D. M. German, and D. Damian, “The promises and perils of mining GitHub,” in 11th Working Conference on Mining Software Repositories, 2014, pp. 92–101.

[8]      B. Vasilescu, A. Serebrenik, and V. Filkov, “A Data Set for Social Diversity Studies of GitHub Teams,” in 12th Working Conference on Mining Software Repositories, 2015, pp. 514–517.

[9]      V. Cosentino, J. L. Canovas Izquierdo, and J. Cabot, “A Systematic Mapping Study of Software Development With GitHub,” IEEE Access, vol. 5, pp. 7173–7192, 2017.

[10]     T. F. Bissyande, F. Thung, D. Lo, L. Jiang, and L. Reveillere, “Popularity, Interoperability, and Impact of Programming Languages in 100,000 Open Source Projects,” in 37th Annual IEEE Computer Software and Applications Conference, 2013, pp. 303–312.

[11]     P. Mayer and A. Bauer, “An empirical analysis of the utilization of multiple programming languages in open source projects,” in 19th International Conference on Evaluation and Assessment in Software Engineering, 2015, no. November, pp. 1–10.

[12]     C. Vendome, “A Large Scale Study of License Usage on GitHub,” in 37th IEEE/ACM International Conference on Software Engineering, Volume 2, 2015, pp. 2–4.

[13]     C. Vendome, M. Linares-Vásquez, G. Bavota, M. Di Penta, D. German, and D. Poshyvanyk, “License usage and changes: A largescale study of java projects on github,” in ICPC conf., 2015, pp. 218–228.

[14]     R. Coleman and M. a. Johnson, “Power-Laws and Structure in Functional Programs,” in 2014 International Conference on Computational Science and Computational Intelligence, 2014, pp. 168–172.

[15]     K. Achuthan, S. Sudharavi, R. Kumar, and R. Raman, “Security Vulnerabilities in Open Source Projects : An India Perspective,” in 2nd International Conference on Information and Communication Technology, 2014, pp. 18–23.

[16]     P. S. Kochhar, T. F. Bissyande, D. Lo, and L. Jiang, “Adoption of Software Testing in Open Source Projects–A Preliminary Study on 50,000 Projects,” in 17th European Conference on Software Maintenance and Reengineering, 2013, pp. 353–356.

[17]     R. Pham, L. Singer, O. Liskin, F. F. Filho, and K. Schneider, “Creating a shared understanding of testing culture on a social coding site,” in 35th International Conference on Software Engineering, 2013, pp. 112–121.

[18]     G. Destefanis and M. Ortu, “Position Paper : Are Refactoring Techinques Used by Developers ? A Preliminary Empirical Analysis,” in REFTEST workshop, 2014.

[19]     A. Lima, L. Rossi, and M. Musolesi, “Coding together at scale: GitHub as a collaborative social network,” in 8th AAAI International Conference on Weblogs and Social Media, 2014, pp. 295–304.

[20]     B. Vasilescu, V. Filkov, and A. Serebrenik, “Perceptions of Diversity on GitHub : A User Survey,” CHASE Work., 2015.

[21]     M. Y. Allaho and W.-C. Lee, “Trends and behavior of developers in open collaborative software projects,” in 2014 International Conference on Behavior, Economic and Social Computing, 2014, pp. 1–7.

[22]     P. Loyola and I.-Y. Ko, “Biological Mutualistic Models Applied to Study Open Source Software Development,” in 2012 IEEE/WIC/ACM International Conferences on Web Intelligence and Intelligent Agent Technology, 2012, vol. 1, pp. 248–253.

[23]     E. Kalliamvakou, G. Gousios, K. Blincoe, L. Singer, D. M. German, and D. Damian, “An in-depth study of the promises and perils of mining GitHub,” Empir. Softw. Eng., Sep. 2015.

[24]     M. Y. Allaho and W.-C. Lee, “Trends and behavior of developers in open collaborative software projects,” in 2014 International Conference on Behavioral, Economic, and Socio-Cultural Computing (BESC2014), 2014, pp. 1–7.

[25]     F. Fagerholm, A. Sanchez Guinea, J. Borenstein, and J. Munch, “Onboarding in Open Source Projects,” IEEE Softw., vol. 31, no. 6, pp. 54–61, Nov. 2014.

[26]     M. Pinzger and A. Van Deursen, “An Exploratory Study of the Pull-based Software Development Model,” in 36th International Conference on Software Engineering, 2014, pp. 345–355.

[27]     Y. Yu, H. Wang, V. Filkov, P. Devanbu, and B. Vasilescu, “Wait For It: Determinants of Pull Request Evaluation Latency on GitHub,” in 12th IEEE/ACM Working Conference on Mining Software Repositories, 2015, pp. 367–371.

[28]     F. Thung, T. F. Bissyande, D. Lo, and L. Jiang, “Network Structure of Social Coding in GitHub,” in 17th European Conference on Software Maintenance and Reengineering, 2013, pp. 323–326.

[29]     J. Tsay, L. Dabbish, and J. Herbsleb, “Influence of social and technical factors for evaluating contribution in GitHub,” in 36th International Conference on Software Engineering, 2014, pp. 356–366.

[30]     F. P. . J. Brooks, “No Silver Bullet Essence and Accidents of Software Engineering,” Computer (Long. Beach. Calif)., vol. 20, no. 4, pp. 10–19, Apr. 1987.

[31]     E. Shein, “How AI is Changing Software Development | News | Communications of the ACM,” Communications of the ACM.

[32]     M.-A. Storey and A. Zagalsky, “Disrupting developer productivity one bot at a time,” in Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering – FSE 2016, 2016, pp. 928–931.

[33]     M. P. Acharya, C. Parnin, N. A. Kraft, A. Dagnino, and X. Qu, “Code drones,” in Proceedings of the 38th International Conference on Software Engineering Companion – ICSE ’16, 2016, pp. 785–788.

[34]     J. Xavier and A. Macedo, “Understanding the popularity of reporters and assignees in the Github,” in 26th International Conference on Software Engineering and Knowledge Engineering, 2014, pp. 484–489.

[35]     A. Perini, A. Susi, and P. Avesani, “A Machine Learning Approach to Software Requirements Prioritization,” IEEE Trans. Softw. Eng., vol. 39, no. 4, pp. 445–461, Apr. 2013.

[36]     M. Shepperd, D. Bowes, and T. Hall, “Researcher Bias: The Use of Machine Learning in Software Defect Prediction,” IEEE Trans. Softw. Eng., vol. 40, no. 6, pp. 603–616, Jun. 2014.

[37]     C. Lopez-Martin, A. Chavoya, and M. E. Meda-Campana, “A machine learning technique for predicting the productivity of practitioners from individually developed software projects,” in 15th IEEE/ACIS International Conference on Software Engineering, Artificial Intelligence, Networking and Parallel/Distributed Computing (SNPD), 2014, pp. 1–6.

[38]     Y. Tian, F. Thung, A. Sharma, and D. Lo, “APIBot: question answering bot for API documentation,” Proc. 32nd IEEE/ACM Int. Conf. Autom. Softw. Eng., pp. 153–158, 2017.

[39]     B. Xu, Z. Xing, X. Xia, and D. Lo, “AnswerBot: automated generation of answer summary to developersź technical questions,” Proc. 32nd IEEE/ACM Int. Conf. Autom. Softw. Eng., pp. 706–716, 2017.

[40]     F. P. Brooks, The mythical man-month : essays on software engineering. .

[41]     G. Kardas, “Model-driven development of multiagent systems: a survey and evaluation,” Knowl. Eng. Rev., vol. 28, no. 4, pp. 479–503, Dec. 2013.

[42]     V. Cosentino, J. L. Cánovas Izquierdo, and J. Cabot, “Gitana: A SQL-Based Git Repository Inspector,” in 34th International Conference on Conceptual Modeling, ER 2015, 2015, vol. 9381, pp. 329–343.

[43]     M. Brambilla, J. Cabot, and M. Wimmer, Model-Driven Software Engineering in Practice, vol. 1. Morgan & Claypool Publishers, 2012.

[44]     D. Kavaler, S. Sirovica, V. Hellendoorn, R. Aranovich, and V. Filkov, “Perceived language complexity in GitHub issue discussions and their effect on issue resolution,” Proc. 32nd IEEE/ACM Int. Conf. Autom. Softw. Eng., pp. 72–83, 2017.

[45]     A. Sankaran, R. Aralikatte, S. Mani, S. Khare, N. Panwar, and N. Gantayat, “DARVIZ: Deep Abstract Representation, Visualization, and Verification of Deep Learning Models,” in 2017 IEEE/ACM 39th International Conference on Software Engineering: New Ideas and Emerging Technologies Results Track (ICSE-NIER), 2017, pp. 47–50.

[46]     M. J. Wooldridge, An introduction to multiagent systems. John Wiley & Sons, 2009.

[47]     J. L. Canovas Izquierdo and J. Cabot, “Enabling the Definition and Enforcement of Governance Rules in Open Source Systems,” in ICSE SEIS conf., 2015, vol. 2, pp. 505–514.

[48]     J. L. Cánovas Izquierdo and J. Cabot, “Collaboro: a collaborative (meta) modeling tool,” PeerJ Comput. Sci., vol. 2, p. e84, Oct. 2016.

[49]     M. Georgeff, B. Pell, M. Pollack, M. Tambe, and M. Wooldridge, “The Belief-Desire-Intention Model of Agency,” Springer, Berlin, Heidelberg, 1999, pp. 1–10.

[50]     T. Mens and P. Grosjean, “The Ecology of Software Ecosystems,” Computer (Long. Beach. Calif)., vol. 48, no. 10, pp. 85–87, Oct. 2015.

[51]     O. Franco-Bedoya, D. Ameller, D. Costal, and X. Franch, “Open source software ecosystems: A Systematic mapping,” Inf. Softw. Technol., vol. 91, pp. 160–185, Nov. 2017.

[52]     R. G. Kula, D. M. German, A. Ouni, T. Ishio, and K. Inoue, “Do developers update their library dependencies?,” Empir. Softw. Eng., pp. 1–34, May 2017.

[53]     S. Mirhosseini and C. Parnin, “Can automated pull requests encourage software developers to upgrade out-of-date dependencies?,” Proc. 32nd IEEE/ACM Int. Conf. Autom. Softw. Eng., pp. 84–94, 2017.

[54]     C. A. González and J. Cabot, “Formal verification of static software models in MDE: A systematic review,” Inf. Softw. Technol., vol. 56, no. 8, pp. 821–838, Aug. 2014.

[55]     E. M. Clarke, E. A. Emerson, and J. Sifakis, “Model checking,” Commun. ACM, vol. 52, no. 11, p. 74, Nov. 2009.

[56]     M. Utting, A. Pretschner, and B. Legeard, “A taxonomy of model-based testing approaches,” Softw. Testing, Verif. Reliab., vol. 22, no. 5, pp. 297–312, Aug. 2012.

[57]     B. Vasilescu et al., “Gender and Tenure Diversity in GitHub Teams,” in Proceedings of the 33rd Annual ACM Conference on Human Factors in Computing Systems – CHI ’15, 2015, pp. 3789–3798.

[58]     J. Terrell et al., “Gender differences and bias in open source: pull request acceptance of women versus men,” PeerJ Comput. Sci., vol. 3, p. e111, May 2017.

[59]     P. Tourani, B. Adams, and A. Serebrenik, “Code of Conduct in Open Source Projects,” SANER conf., pp. 24–33, 2017.

[60]     A. U. P. P. Council, “Statement on Algorithmic Transparency and Accountability,” Commun. ACM, 2017.

[61]     C. Metz, “Open Source Software Went Nuclear This Year | WIRED,” Wired, 2015.

[62]     Nadia Eghbal, “Roads and Bridges: The Unseen Labor Behind Our Digital Infrastructure / Ford Foundation,” 2016.

[63]     J. L. Canovas Izquierdo and J. Cabot, “Enabling the Definition and Enforcement of Governance Rules in Open Source Systems,” in 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering, 2015, vol. 2, pp. 505–514.

[64]     J. Cabot, R. Clarisó, M. Brambilla, and S. Gérard, “Cognifying Model-Driven Software Engineering,” in Grand Challenges in Modeling – STAF 2017, 2017.

[65]     H. Brunelière and J. Cabot, “On Developing Open Source MDE Tools: Our Eclipse Stories and Lessons Learned,” in OSS4MDE@MoDELS 2014, 2014, pp. 9–19.

[66]     J. Cabot, “Looking at WordPress through the eyes of a Software Researcher.” WordCamp Europe, 2015.

[67]     K.-J. Stol and B. Fitzgerald, “Inner Source–Adopting Open Source Development Practices in Organizations: A Tutorial,” IEEE Softw., vol. 32, no. 4, pp. 60–67, Jul. 2015.

[68]     J. L. Eveleens and C. Verhoef, “The rise and fall of the Chaos report figures,” IEEE Softw., vol. 27, no. 1, pp. 30–36, Jan. 2010.

[69]     K. Kelly, The inevitable : understanding the 12 technological forces that will shape our future, 2016th ed. Viking, 2016.

[70]     M. Squire, “The Lives and Deaths of Open Source Code Forges,” in Int. Symp. on Open Collaboration, 2017, p. 15.

[71]     M. Gladwell, The Tipping Point: How Little Things Can Make a Big Difference. Back Bay Books, 2002.

[72]     Thomas C. Schelling, Micromotives and Macrobehavior. W. W. Norton & Company, 2006.

Join our Team!

Follow the latest news on software development, especially for open source projects

You have Successfully Subscribed!

Share This