The on-wiki version of this update can be found here:
A few days ago we were asked for a mission statement for Wikifunctions, and
we realized we didn’t have one yet. James Forrester then wrote a first
draft, which the team slightly improved, intentionally inspired by the
language used in the Wikimedia movement's vision:
“A Wikimedia project for everyone to collaboratively create and maintain a
library of code functions to support the Wikimedia projects and beyond, for
everyone to call and re-use in the world's natural and programming
I don’t expect this to be the final version, and you are all invited to
improve it. It was pointed out to us that it is still a bit long and wordy.
That said, let's take a closer look at the text as it is now:
*“A Wikimedia project”*: Wikifunctions is a project
<https://meta.wikimedia.org/wiki/Wikimedia_projects> by and of the
Wikimedia movement, in the same sense as Wikipedia, Wikidata, Wiktionary,
Wikimedia Commons, and the other seven projects. In that sense, it is both
a wiki website and a community.
*“for everyone”*: When you think about the question of who will benefit
from Wikifunctions, the answer is that we target everyone. There are
practical limitations in reaching truly everyone: for example, a computer
is a prerequisite for being able to benefit from Wikifunctions. That is
different from e.g. Wikipedia or Wikivoyage, where the print-out of a page
can be very useful without having to have a computer. But for a function to
be useful, a computer will be needed in order to evaluate the function.
Besides such limitations, we aim to be accessible
<https://en.wikipedia.org/wiki/Computer_accessibility>, to be multilingual,
and to run in many different contexts, both on- and offline.
*“to collaboratively create and maintain”*: Collaborative creation and
maintenance is the core tenet of the Wikimedia projects. We don’t want
individuals to have "ownership" over a function or a set of functions, to
control what is accepted to the project, or decide which changes would be
welcome. This is a collaborative effort, and the default assumption is that
everyone can contribute new function definitions, implementations for new
functions, that everyone can improve the documentation and the test
coverage of these.
*“a library of code functions”*: This defines the new knowledge format that
this project is addressing: code functions
<https://en.wikipedia.org/wiki/Subroutine>. We are not talking about
functions <https://en.wikipedia.org/wiki/Function_(mathematics)>, but about
functions for which we can provide executable implementations. We want to
build a shared library of such functions that are connected with each
other, that use each other, and that are built on top of each other. A
single, comprehensive, common library also helps us to truly build on each
other’s work. For example, if one searches the Web today for a function
that calculates how many days have passed between two given dates, one can
easily find faulty implementations that do not take leap days into account.
By having one common library of functions to which anyone can contribute,
we hope that we can increase the overall quality of code in the world.
*“to support the Wikimedia projects”*: As with Commons and Wikidata, the
founding, primary goal of Wikifunctions is to support the Wikimedia
projects. We want to first focus on functions that are useful for the
Wikimedia projects, that can help reduce the maintenance costs in the other
projects, and unlock new capabilities for the projects that have not been
*“and beyond”*: Alongside the primary goal, we don’t want to restrict the
functions to only what is directly useful for the Wikimedia projects. On
the contrary, we want to provide a comprehensive library of functions
useful in many different areas: text processing, mathematics, natural
sciences, health care, environmental studies, decision making, natural
language generation, and many other areas.
*“for everyone to call”*: Everyone will be able to go to Wikifunctions,
find a function, enter the input arguments, and have the system evaluate
the function and see the result. We plan that making these calls will be
possible via direct evaluation on the Wikifunctions site, via inclusion on
a Wikimedia project, and via API calls. We expect there to be substantial
value to the world exposed through the API and its use on third party
sites, tools, and apps, in the same way that Wikidata statements, Wikimedia
Commons media files, and snippets of Wikipedia and other prose content
projects are re-used around the Web. Using a function does not need to be a
direct experience, but can also be embedded in another experience: for
example, it should be easy for a spreadsheet user to use a function from
Wikifunctions, or to allow third-party apps to use functions from
Wikifunctions, to have Wikifunctions functions be exposed through voice
interfaces or command lines, and many more ways.
*”and re-use”*: For many people and use cases the above direct calls will
be sufficient. But we cannot provide the computational resources for
everyone and for all use cases. So we must make it easy for a user to take
functions from Wikifunctions and re-use them, running them on computational
resources they provide, or embed them in completely new contexts. As with
all other Wikimedia projects, it should be very easy to download or export
code from Wikifunctions for use elsewhere, as well as the simpler direct
*“in the world’s natural”*: Wikifunctions aims to support all the languages
of our users – our editors, our functionaries, our translators, our
readers, our re-users, and all the people we don't yet reach. It will be
possible to run functions in Wikifunctions from an interface in the
language of the user, but also the natural language generation libraries in
Wikifunctions will target hundreds of languages.
*“and programming languages.”*: Wikifunctions will allow people to write
function implementations in a large number of programming languages.
Unfortunately, adding a programming language to Wikifunctions will always
be a bit of work, which will be somewhat of a bottleneck, and will require
us to stage the deployment of programming languages. We will start with
aim to support many other languages in a relatively short period of time.
Thanks to Moriel Schottlender
<https://meta.wikimedia.org/wiki/User:Mooeypoo> and Diana Montalion for
prompting the question, and everyone on the team and beyond for thinking
through it and helping with getting to a first draft of the mission