Open source software is open digital infrastructure that our economies and societies rely on. Nevertheless, open source maintenance continues to be underfunded, especially when compared to physical infrastructure like roads or bridges. So we ask: how can the public sector better support open source maintenance? 

As part of our efforts to support developers, GitHub’s developer policy team has commissioned a study from Open Forum Europe, Fraunhofer ISI and the European University Institute that explores how one of the open source world’s most successful government programs, the German Sovereign Tech Agency, can be scaled up to the European Union level. That study was published today. Here’s what it says and what you can do to help make the EU Sovereign Tech Fund (EU-STF) a reality.

There is a profound mismatch between the importance of open source maintenance and the public attention it receives. The demand-side value of open source software to the global economy is estimated at $8.8 trillion, and the European Commission’s own research shows that OSS contributes a minimum of €65-95 million to the EU economy annually. Basic open source technologies, such as libraries, programming languages, or software development tools, are used in all sectors of the economy, society, and public administrations.

The flip side of everybody benefiting from this open digital infrastructure is that too few feel responsible for paying the tab. The Sovereign Tech Agency’s survey of over 500 OSS maintainers showed that a third of them are not paid at all for their maintenance work, but would like to be. Another third earns some income from OSS maintenance, but is not able to make a living off this work. Perhaps even more alarmingly, a third of respondents are solo maintainers, and almost three quarters of surveyed projects are maintained by three people or fewer. As prominent security incidents such as the xz backdoor or the Log4Shell vulnerability have shown in recent years, it can mean serious risks for the OSS community’s health and the security of our global software ecosystem if too much is put on the shoulders of small, overworked, and underappreciated teams.

At GitHub, we are helping address this open source sustainability challenge through GitHub Sponsors, the GitHub Secure Open Source Fund, free security tooling for maintainers, and other initiatives. Yet we recognize that there is a significant gap between the immense public value of open source software and the funding that is available to maintain it, a gap that this research is seeking to address.

Designing an impactful fund

Building on the success story of the German Sovereign Tech Agency, which has invested over €23 million in 60 OSS projects in its first two years of operation (2022-2024), the EU-STF should have five main areas of activity:

1. Identifying the EU’s most critical open source dependencies,
2. Investments in maintenance,
3. Investments in security,
4. Investments in improvement,
5. Strengthening the open source ecosystem.

The study proposes two alternative institutional setups for the EU-STF: either the creation of a centralized EU institution (the moonshot model), or a consortium of EU member states that provide the initial funding and apply for additional resources from the EU budget (the pragmatic model). In both cases, to make the fund a success, the minimum contribution from the upcoming EU multiannual budget should be no less than €350 million. This would not be enough to meet the open source maintenance need, but it could form the basis for leveraging industry and national government co-financing that would make a lasting impact.

Equipped with the learnings from the German Sovereign Tech Agency and other government open source programs, such as the US Open Technology Fund or the EU’s Next Generation Internet initiative, the study identified seven design criteria that the EU-STF must meet:

1. Pooled financing. To address the maintenance funding gap, industry, national governments and the EU should all be able to put money into the same pot. It is not in the interest of overworked open source maintainers to have to research and apply to dozens of separate funds, all with slightly different funding criteria. That’s why GitHub’s Secure Open Source Fund pools funding from many industry partners into one coherent program. The EU-STF should follow the same logic and be capable of collecting contributions from industry, national governments and the EU budget alike.
2. Low bureaucracy. If you’re one of those aforementioned unpaid solo maintainers, the last thing you need is to sink several days of work into a complicated application process with an uncertain outcome that many EU funding programs are unfortunately known for. The EU-STF should combine a lightweight application process along with its own research to identify and proactively contact critical OSS infrastructure projects. Funding recipients should have limited reporting requirements to make sure that they can spend their time on improving the health of their OSS projects, not jumping through administrative hoops.
3. Political independence. Public funding programs often follow technological trends, such as blockchain, quantum computing or AI. Open source maintenance often gets overlooked, because it is neither a new development nor limited to a particular economic sector: it is foundational to all of them. An EU-STF has to be politically independent enough to shield it from frequent pivots to new, politically salient topics, and instead keep it focused on the mission of securing and maintaining our public software infrastructure.
4. Flexible funding. There is no one-size-fits-all model for open source maintenance. Many maintainers are hired by companies to work on OSS as part of their day jobs. Others maintain projects in their free time. Some critical OSS projects are governed by a foundation or other nonprofit, yet others are made up of a loose collective of individuals scattered across the globe. The EU-STF should be able to fund individuals, nonprofits or companies in all of those cases for their OSS maintenance work. Living in the EU should not be a requirement for receiving funding, just like the German Sovereign Tech Agency does not restrict funding to Germans. To benefit the EU economy and society, software doesn’t have to be Made in the EU, as long as it is Made Open Source.
5. Community focus. A fund that is solely run by career public servants is going to struggle to develop the expertise and build the trust with the open source ecosystem that are necessary to make a positive impact on open source sustainability. The EU-STF should collaborate with the open source community to co-define funding priorities and design the funding process.
6. Strategic alignment. To be attractive enough to the European Union to justify spending a budget of a minimum of €350 million on open source sustainability, the EU-STF has to demonstrate a positive impact on the EU’s strategic goals. The study lays out in detail how open source maintenance funding contributes to economic competitiveness, digital sovereignty (that is, the ability of individuals, companies and the state to use and design technology according to their own needs), and cybersecurity, for example by helping companies comply with their supply chain security obligations for open source components under the Cyber Resilience Act.
7. Transparency. As with any case of spending taxpayer money, the EU-STF must meet the highest standards of transparency in governance and funding decisions, to ensure that it can earn the trust not just of the open source community, but also of the policymakers who approve its budget.

Making the EU Sovereign Tech Fund a reality

Right now, the European Union is ramping up the negotiations on its new multi-year budget for the period of 2028-2035, the Multiannual Financial Framework. GitHub’s developer policy team is presenting the findings of the study to EU legislators and mobilizing the support of industry partners to demonstrate the need for a novel instrument that allows the public and private sectors to work together on securing our open source infrastructure. We are delighted to partner with Mercedes-Benz, who contributed a foreword to the study and have been vocal supporters of the idea of an EU Sovereign Tech Fund from its inception.

Without sustainable funding and support, it is entirely foreseeable that ever more open source software projects will not receive the diligence and scrutiny appropriate for software of such criticality.

Magnus Östberg, Chief Software Officer, Mercedes-Benz AG; Markus Rettstatt, Vice President Software Defined Car, Tech Innovation GmbH

The first legislative proposals for the EU budget have just hit the desks of the European Parliament and the national governments in the Council of Ministers. Whether you are an individual, a member of an open source organization, or a company representative, you can voice your support for the creation of the EU-STF to the European Commission, your elected representatives in the European Parliament, and your national government. If you’re at EU Open Source Summit Europe on August 26, you can join us for a presentation of the study and community discussion.

The post We need a European Sovereign Tech Fund appeared first on The GitHub Blog.

Source: The GitHub Blog.

Imagine this: you’re scrolling through your social media feed, and suddenly, an advertisement pops up for hiking boots. Spooky, right? Or is it just clever application of machine learning? Behind many such personalized experiences lies a powerful mathematical tool: Bayes’ Theorem. This seemingly simple equation underpins a vast array of machine learning applications, from spam filtering to medical diagnosis. Let’s unravel its magic.

Bayes’ Theorem is a fundamental concept in probability theory that describes how to update our beliefs about an event based on new evidence. In simpler terms, it helps us revise our initial guesses (prior probabilities) in light of fresh information. The theorem is expressed mathematically as:

P(A|B) = [P(B|A) * P(A)] / P(B)

Where:

• P(A|B) is the posterior probability: the probability of event A happening given that event B has already occurred. This is what we want to calculate.
• P(B|A) is the likelihood: the probability of event B happening given that event A has already occurred.
• P(A) is the prior probability: our initial belief about the probability of event A happening before considering any new evidence.
• P(B) is the marginal likelihood (or evidence): the probability of event B happening regardless of whether A happened or not. It acts as a normalizing constant.

Understanding the Math with an Analogy

Let’s imagine you’re a doctor trying to diagnose a patient with a rare disease (event A). You know the disease is quite uncommon (low prior probability P(A)). A specific test (event B) is available, and you know its accuracy: the probability of testing positive given the disease (P(B|A)) and the probability of testing positive even without the disease (P(B|¬A), where ¬A means “not A”). Bayes’ Theorem helps you calculate the probability that the patient actually has the disease (P(A|B)) given a positive test result.

Bayes’ Theorem in Action: A Simple Example

Let’s say the prior probability of having the disease is P(A) = 0.01 (1%). The test is 90% accurate when the patient has the disease (P(B|A) = 0.9) and 5% likely to give a false positive (P(B|¬A) = 0.05). If the patient tests positive (B), what’s the probability they actually have the disease (P(A|B))?

First, we need to calculate P(B):

P(B) = P(B|A) * P(A) + P(B|¬A) * P(¬A) = (0.9 * 0.01) + (0.05 * 0.99) ≈ 0.0585

Now we can apply Bayes’ Theorem:

P(A|B) = (0.9 * 0.01) / 0.0585 ≈ 0.154

Even with a positive test, the probability of having the disease is only around 15.4%, highlighting the importance of considering prior probabilities and test accuracy.

Implementing Bayes’ Theorem in Python (Naive Bayes Classifier)

One of the most common applications of Bayes’ Theorem in ML is the Naive Bayes classifier. This algorithm assumes that features are conditionally independent given the class label (a simplification, hence “naive”). Let’s illustrate a simple text classification example (spam/not spam):

# Simple Naive Bayes Classifier (pseudo-code)  # Training data: list of (text, label) tuples training_data = [("free money", "spam"), ("meeting tomorrow", "ham")] # Vocabulary: set of unique words vocabulary = set(" ".join(text for text, _ in training_data).split()) # Calculate word probabilities for each class # (Simplified for demonstration – real implementation uses smoothing techniques) spam_word_probs = {} ham_word_probs = {} # ... (Code to count word occurrences in spam and ham and calculate probabilities)...  # Classify new text def classify(text): words = text.split() spam_prob = prior_prob_spam # Prior probability of spam  ham_prob = prior_prob_ham # Prior probability of ham  for word in words: if word in vocabulary: spam_prob *= spam_word_probs.get(word, 1e-6) # Avoid zero probabilities  ham_prob *= ham_word_probs.get(word, 1e-6) # Apply Bayes' Theorem (simplified):  if spam_prob > ham_prob: return "spam" else: return "ham" print(classify("free money offer")) # Output: spam (likely) 

Real-World Applications

Bayes’ Theorem’s applications are widespread:

• Spam filtering: Classifying emails as spam or not spam based on word frequencies.
• Medical diagnosis: Predicting the probability of a disease given symptoms and test results.
• Recommendation systems: Suggesting products or services based on user preferences and past behavior.
• Sentiment analysis: Determining the emotional tone of text (positive, negative, neutral).
• Image classification: Identifying objects in images.

Challenges and Limitations

• Prior probability estimation: Choosing appropriate prior probabilities can be challenging and significantly impact results.
• Feature independence assumption (Naive Bayes): This assumption is often violated in real-world scenarios, affecting accuracy.
• Zero-probability problem: If a word never appears in the training data for a specific class, its probability becomes zero, impacting calculations. Smoothing techniques help mitigate this.

The Future of Bayes’ Theorem in ML

Bayes’ Theorem remains a cornerstone of machine learning, despite its limitations. Ongoing research focuses on improving its accuracy and efficiency, including developing more sophisticated methods for handling dependent features and estimating prior probabilities. Its simplicity and interpretability make it a valuable tool, particularly in applications where understanding the reasoning behind predictions is crucial. As data continues to grow exponentially, the power of Bayes’ Theorem to process and interpret this information will only become more significant.

Source: DEV Community.