This week's newsletter embeds a few images. The on-wiki version might
be easier to read or break less:
https://meta.wikimedia.org/wiki/Abstract_Wikipedia/Updates/2023-01-19
----
State of Wikifunctions January 2023Where are we?
Since this is our 100th Update newsletter, and it's also a good way to
start 2023, we wanted to give a general overview of the status of the
project, and what is left to do before we launch.
Last year, we saw major progress. We launched the Wikifunctions Beta
<https://wikifunctions.beta.wmflabs.org/wiki/Wikifunctions:Main_Page>, and
saw some engagement there - thank you for everyone trying it out! We also
had the participation of the
Google.org fellows, which led to some
reshuffling of our work to accommodate the limited availability of specific
skills. It was a busy year!
<https://meta.wikimedia.org/wiki/File:Function_in_Wikifunctions_during_development_Phase_Kappa.png>
<https://meta.wikimedia.org/wiki/File:Function_in_Wikifunctions_during_development_Phase_Kappa.png>
Function in Wikifunctions early 2022
<https://meta.wikimedia.org/wiki/File:Function_in_Wikifunctions_during_development_Phase_Theta.png>
<https://meta.wikimedia.org/wiki/File:Function_in_Wikifunctions_during_development_Phase_Theta.png>
Function in Wikifunctions early 2023
<https://meta.wikimedia.org/wiki/File:Object_in_Wikifunctions_during_development_Phase_Kappa.png>
<https://meta.wikimedia.org/wiki/File:Object_in_Wikifunctions_during_development_Phase_Kappa.png>
Object in Wikifunctions early 2022
<https://meta.wikimedia.org/wiki/File:Object_in_Wikifunctions_during_development_Phase_Theta.png>
<https://meta.wikimedia.org/wiki/File:Object_in_Wikifunctions_during_development_Phase_Theta.png>
Object in Wikifunctions, currently in development
Wikifunctions already provides a large number of features:
- Users can *call functions*
- Wikifunctions allows running implementations in *Python* and in
*JavaScript*
- Wikifunctions allows *composing* implementations from functions which
ultimately are written in different programming languages
- Wikifunctions allows for *user-defined types* and user-defined
validators for these types
- Contributors can create *instances* of user-defined and pre-built
types and store them on-wiki
- There is an easy-to-use workflow for *creating functions*
- *Generic types* and *generic functions* are supported by the backend,
allowing for powerful implementations
- Functions can have *several implementations*, and the backend selects
an implementation to run for a given function call
- *Test cases* are run against the given implementations
- The community can *approve and deactivate* individual implementations
and test cases, providing a mechanism for the community to work out what
each function exactly means
- The whole frontend is fully *multi-lingual*, and supports showing and
editing labels in hundreds of languages
- The site works both on *desktop and mobile*. We're excited to provide
an environment where mobile users can benefit from and also create
functions.
- Various *metadata* are collected when a function runs, and made
available in the UI
Just two weeks ago, my eight year old daughter was asking me what I was
working on, and I gave her a quick tour of Wikifunctions. I showed her
the reverse
function <https://wikifunctions.beta.wmflabs.org/wiki/Z10268> on
Wikifunctions, and she thoroughly enjoyed coming up with seemingly
meaningless strings to enter into Wikifunctions, run the function, and make
the system display bad words to us.
The last few weeks we have been focusing on rescheduling and reprioritizing
features in order to quickly move toward launch.
We are currently in the middle of designing and implementing our user
experience. You can see the changes that have landed, and the changes we
are working on in the two pairs of screenshots below.
For now, you can get a preview of the new object viewer
<https://wikifunctions.beta.wmflabs.org/w/index.php?title=Z10426&view=default-view>
and
contrast it with the current object viewer
<https://wikifunctions.beta.wmflabs.org/w/index.php?title=Z10426> on the
Beta. The interactive features on complex objects are especially
interesting to play around with and compare. This view is in heavy
development right now.
We have also landed a major patch for persistent caching of test results,
which will help with some major performance issues that many Beta visitors
may have noticed. Moreover, it will soon enable another major step: based
on the metadata of the test results, the backend will start selecting
better performing implementations. Whereas currently it is selecting an
implementation randomly, in the near future it will be considerably smarter
than that.
What is left?
What are the main pieces of work we hope to do before we launch
Wikifunctions?
- ensure that function evaluation always runs *correctly*; there are a
few stubborn edge cases left to be addressed (current phase, θ, Goal 2)
- complete the design and implementation of the *user experience*, so
that readers and contributors have a pleasant experience using
Wikifunctions (current phase, θ, Goals 5, 9 and 10)
- create and manage *user rights* relevant to Wikifunctions, as there
are a few new rights that the current wikis don’t have (current phase, θ,
Goal 6)
- display *edit history / diffs*, so it becomes possible to understand
changes in the wiki (current phase, θ, Goal 6)
- fixing a few issues with *error reporting* (next phase, ι)
- provide a *language switcher* for the website, so that users can use
and read Wikifunctions in their own language (next phase, ι)
- collect *metrics* that will help us to understand how Wikifunctions
develops, and to recognize opportunities and bottlenecks in the system
(next phase, ι)
- get *search* working, to help folks find their way around (next phase,
ι)
- enable users to write *documentation for their own functions*, to
explain their functions and foster their use (next phase, ι)
There is still plenty of work to do. You can follow the progress either on
the Beta, where we run the newest development version, or through these
updates, where we will continue to report on our progress.
Looking forward to 2023!
Development update (as of January 13, 2023)
- Major progress on *Goal 4* (Implementing the Function view). In a
closing event, we closed two of the three Critical User Journeys (here
<https://phabricator.wikimedia.org/T318930> and here
<https://phabricator.wikimedia.org/T318936>) associated with this Goal,
and identified the remaining tasks for this Goal. Since then, all but one
could be closed and the last one
<https://phabricator.wikimedia.org/T326656> is in review. We’re very
likely to close this last Critical User Journey
<https://phabricator.wikimedia.org/T318933> on this Goal next week,
including Goal 4 itself too.
- The Experience workstream has appropriately shifted to *Goal 5* mostly
(Implementing the default object viewer). This week we saw the design
for lists <https://phabricator.wikimedia.org/T310827> being locked in,
and the first parts land.
- In *Goal 3* (Meta-data) we only have three tasks left! A major patch
<https://gerrit.wikimedia.org/r/c/mediawiki/extensions/WikiLambda/%2B/819176/>,
which has been cooking since the summer, has finally hit the review, and
which will considerably improve the performance characteristics of the
system.
- We had the *first volunteer’s corner* of the year. We used Jitsi this
time (but couldn’t use the Foundation instance), and we had seven
volunteers attending. The session was lively and had numerous questions,
and we hope to recruit a new volunteer developer to our wider ecosystem.