On this rainy october day (well, at least it rains where I’m writing this) of the great year 2020, let’s take another few minutes to reflect on some great practices that we have at Mozilla and that would deserve to take over the world.

Today, let’s talk about what you can do when your work is blocked.

Let’s continue this series on some of the great practices that we have at Mozilla and that your project may wish to adopt, too.

This time, let’s talk about Mozilla’s #introduction chatroom.

Until now, this blog has been using Disqus as a comment mechanism.

While it is very useful, I’m trying to switch to a less invasive (and I believe more privacy-safe): gitalk.

I’ve left Disqus on in the pages on which users had already left comments. For other pages, Disqus is now deactivated.

2020 is a crappy year for pretty much everyone. As you may have seen, this includes organizations such as Mozilla. So I figured it was the best time to actually talk about good stuff! This entry should be the first of a series of short articles dedicated to some great practices we have at Mozilla and that I think many open-source projects could adopt.

At its core, Mozilla is a community of open-source enthusiasts. When you’re new to an open-source community and you wish to start contributing somewhere, finding an entry point is often difficult.

This is where Mentored Bugs come in.

TL;DR: Firefox used to have a great extension mechanism based on the XUL and XPCOM. This mechanism served us well for a long time. However, it came at an ever-growing cost in terms of maintenance for both Firefox developers and add-on developers. On one side, this growing cost progressively killed any effort to make Firefox secure, fast or to try new things. On the other side, this growing cost progressively killed the community of add-on developers. Eventually, after spending years trying to protect this old add-on mechanism, Mozilla made the hard choice of removing this extension mechanism and replacing this with the less powerful but much more maintainable WebExtensions API. Thanks to this choice, Firefox developers can once again make the necessary changes to improve security, stability or speed.

During the past few days, I’ve been chatting with Firefox users, trying to separate fact from rumor regarding the consequences of the August 2020 Mozilla layoffs. One of the topics that came back a few times was the removal of XUL-based add-ons during the move to Firefox Quantum. I was very surprised to see that, years after it happened, some community members still felt hurt by this choice.

And then, as someone pointed out on reddit, I realized that we still haven’t taken the time to explain in-depth why we had no choice but to remove XUL-based add-ons.

So, if you’re ready for a dive into some of the internals of add-ons and Gecko, I’d like to take this opportunity to try and give you a bit more detail.

A number of programming languages offer a feature called “Named Arguments” or “Labeled Arguments”, which makes some function calls much more readable and safer.

Let’s see how hard it would be to add these in Rust.

If you’re using Firefox Nightly, you may have noticed the early prototype of a new task manager appearing at about:processes (if you wish to check it out, open this address in your address bar). It will evolve a lot yet, but let’s take a look at how we have already.

In this entry: getting data from the operating system.

Note: If you wish to contribute to Firefox and give us a hand with the Fission project, you can find me on chat.mozilla.org - I’m Yoric.

Problem statement

Project Folding@Home uses the spare CPU & GPU capabilities of a million users to simulate protein folding, something that can be useful to understand diseases and fight them.

Now, these days, Folding@Home has more users than it has server capacity to distribute and collect samples. This is where project BuildFirefox@Home comes in!

Project BuildFirefox@Home attempts to solve a pain point that many of our individual contributors encounter: building Firefox is slow. To do this, we just need to use the unused computational power of Folding@Home users.

About types and effects

In most strongly-typed programming languages, the type of a function or method will let you find out what type of arguments (including this / self) it needs, whether it can mutate them and what sort of return value it can produce. By looking at the type of a function, you can easily determine whether it can be applied in a given context, whether it will produce the type of result, and whether you need to copy arguments before calling them.

Years ago, Andrew Kennedy published a foundational paper about a type checker for units of measure, and later implemented it for F#. To this day, F# is the only mainstream programming language which provides first class support to make sure that you will not accidentally confuse meters and feet, euros and dollars, but that you can still convert between watts·hours and joules.

I decided to see whether this could be implemented in and for Rust. The answer is not only yes, but it was fun :)