If you ever wondered what contributing to Firefox feels like but you never had
the time to read and follow through our
instructions to setup a build environment
or wanted to avoid screwing around with your precious system then this might
be for you.
This article will guide you through a small list of steps that in the end
will leave you with a virtual machine ready to modify and build your own
development version of Firefox.
I hope this will be valuable to novice programmers that do not have a full
C++ development environment at hand as well as to the more experienced
folks with little time and lots of curiosity.
Note: The Open Virtualization Format (OVF)
is supported by other Virtualization Environments such as VMWare, etc. You
can use those if already installed instead of VirtualBox.
Go to the VirtualBox Downloads
page and download the latest version available for your operating system.
Should you already have VirtualBox installed then please ensure you are running
the latest version by checking for updates before continuing.
Download the Firefox Build Environment
Now is the time to download the virtual machine containing our development
environment ready to modify and build Firefox. You can get it here:
Downloading ~2.6 GB might take a while if you are on a slow connection, sorry.
Set up the virtual machine
Once the image has been downloaded you can double-click the .ova file
and import the new virtual machine into VirtualBox. Please give it at least
2048MB of RAM (4096MB if you can) and the same number of processors that your
host machine has available. Building Firefox takes up a lot of resources and
you want it to build as fast as possible.
Now that your virtual machine is ready, boot it and wait for the Ubuntu desktop
to be shown. A terminal will pop up automatically and do some last steps before
we can get started. After a successful installation Sublime 2 should start
Note: Should you ever need root credentials, use “firefox-dev” as the
password. If you want to change your Language and Keyboard settings then
follow the instructions on
How to change the UI Language in Ubuntu.
Click Tools > Build to start the process. This might take a long time
depending on the features of your host machine, please be patient. You can
watch the build progress in the text editor’s console at the bottom. Once the
build has finished you can use Tools > Run to start your custom Firefox
build and check that everything works as expected.
Note: if you want to switch from an optimized to a debug build then
choose Tools > Build System > Firefox (Debug) and hit Tools > Build
again to start a debug build.
You successfully built Firefox for the first time and wonder what’s next? How
about picking a small bug for a start, contribute code and get your changes
shipped to half a billion people? If that sounds compelling then take a look
at Bugs Ahoy! and find something to
work on that sounds interesting to you.
If you are interested in digging deeper into the build system or the version
control system, or want to know more about how to create your first patch and
post it to our bug tracker then take a look at our
Code Firefox Lessons.
I would love to hear your feedback about the Firefox Build Environment!
Please tell me what can be improved and what you would like to see in the next
version. Do not hesitate to drop me a mail should you have a more detailed
Today marks the beginning of my fourth year at Mozilla. It has been an amazing
three years and the best job I could hope for. Since March I am now in the
position of an Engineering Manager with a few highly intelligent and great
people that I am very grateful to call my team.
I am super excited about all the personal and professional challenges I will
be facing this year. It is my core belief that it is all about growth and for
that Mozilla is exactly the right place to be.
I got to spend Wednesday through Friday in Edinburgh last week to attend
Scotland.JS. Edinburgh is a lovely city and I will
definitely return to get to know it better. It has great people, beers, food and
even a castle - what could one want more?
I arrived on Wednesday, just in time for the
TechMeetup. It took place in the Appleton Tower and
had about 70-80 attendees with quite diverse technical backgrounds. I had a very
interesting talk to a freelance patent attorney and also met a couple of people
I knew from recent conferences and meetups in Berlin. After we were out of free
pizza and beers we met most of the Scotland.JS attendees in a pub right next to
the Appleton Tower. Cue more beers and tech conversations.
Thursday was the first day of Scotland.JS that started with
a great keynote
from Jan Lehnardt. The most memorable talk of the
day was about
Functional Reactive Programming using Bacon.js
by Philip Roberts. There of course were a
lot more great talks but the possibilities of creating and combining event
streams kept my head spinning the most. At the end of the day we again went to a
neat pub near the venue and I headed to bed rather early, still a little tired
from travel and the day before.
Friday started with a short 20-minute walk through Edinburgh’s old town that I
needed to pass on my way to the venue. My favorite talk of the second and last
day was held by Dominic Tarr that tought us
the internals of leveldb.
I also really enjoyed Mark Boas talking about
making audio a first-class citizen of the web
- a very entertaining and impressive mix of technologies. A GitHub drinkup in
the venue’s own pub was a great way to end the conference - lots of good
conversations with Scotland.JS attendees and speakers as well as people from the
local tech community and visitors of the Scottish Ruby Conf.
I flew home the very next day and already miss Edinburgh with its neat little
value as a very interesting mix of nice welcoming people coming from so many
different technical backgrounds. Like after most conferences I feel a little
exhausted and my head is full of ideas for future or current (side-)projects. I
will try my best to return next year, it has been a lot of fun!
finite sequences that are usually implemented using Arrays. Array.prototype
includes a number of methods like map() and filter() that apply a given
function to all items of the Array and return the resulting new Array.
These tools however are not a good fit for infinite sequences as they always
consume the whole sequence at once to return a new one. Implementing infinite
sequences by yourself means you would have to come up with your own API that
clients need to adhere to. You often would keep state variables whose values
need to be maintained for the duration of the computation process.
Generators to the rescue
implementing the infinite sequence of all natural numbers turns out to be a
trivial task. We even have language support to iterate over them.
Now that we have a first infinite set we need a couple of functions that help us
working with, combining, and building new sequences.
Let us start with map() - a function at the very heart of functional
programming. It builds a new sequence by applying a function to all elements of
a given sequence.
Using the generator implementation of map() we can now easily write a function
called squares() that represents the set of squares of all natural numbers
(1², 2², 3², …, n²).
As we are using
we can also pass an Array to map() to retrieve a new generator with a finite
source. The given function is applied to value after value instead of to all
values at once when using Array.prototype.map.
Another common task is filtering specific values from a sequence. Our custom
implementation of filter() takes an iterator and a predicate - the returned
sequence will consist of all items of the original one for which the predicate
We can now use filter() to create the set of all even natural numbers.
A common derivation from filter() is filterNot() that simply negates the
given predicate. We can use that to implement even() as well.
Suppose we were to implement a sequence that represents all
Mersenne prime numbers.
Mersenne primes are defined as prime numbers of the form Mn = 2n - 1,
that is the set of all numbers of the given form that have no positive divisors
other than 1 and themselves. The set of Mersenne primes is
assumed to be infinite
though this remains unproven, yet.
Let us first define some helper functions. range(from, to) and forall() are
common helpers in functional programming languages. range() returns the set of
natural numbers in a given range. forall() returns whether the given predicate
holds for all items in the sequence and should therefore only be used for finite
mersenneNumbers() is the set of all numbers of the form Mn = 2n - 1.
isPrime() is a very simple and naive (and slow) primality checker that returns
whether the given candidate is divisible by any of the numbers in the range of
[2, candidate - 1]. We will use isPrime() as a filter to remove all non-prime
numbers from mersenneNumbers().
As a last example we will implement a function that flattens nested sequences.
Note that using for…of comes in handy again as we can use it to iterate
over Arrays and generators. Using flatten() we can now do:
Combining flatten() and map() to flatMap() we can implement another very
common function that flattens the result of applying a given function to all
items of a sequence. Let us use it to re-build the set of all natural numbers
from the set of all even natural numbers.
Generators are powerful
It is quite obvious that studying ES6 generators really repays. Thanks to Andy
Wingo these are available in the latest versions of
Chrome. They will be
can count on the community to come up with lots of great uses and libraries.
You have probably already heard of
generators and iterators
coming to a browser near you. They have been available in Firefox for a long
time and are used extensively all over the Mozilla code base. The V8 team
will implement iterators and generators
once ES6 has been finalized.
This post describes the current implementation in SpiderMonkey and tries to
include the current state of the ES6 draft and discussions.
A simple generator
Let us take a look at a simple example of a generator function that represents
an infinite sequence containing all the numbers from 0 to Number.MAX_VALUE.
Once it reaches MAX_VALUE it will not increase any further but always return
the same number.
The next() method simply returns the item next in the sequence.
As you surely noticed the generator of the first example produces iterators that
will never run out of items. The next example shows an iterator representing a
The given code implements a custom iterator without writing a generator
function. Note that it throws StopIteration as soon as it reaches the maximum
value to signal that the sequence is exhausted. It is a lot more elegant to
implement the same sequence using a generator function:
Generator functions will automatically throw StopIteration when terminating.
So how should one consume iterators with finite sequences?
In Java for example, you would check iter.hasNext() and stop when it returns
StopIteration when it is being thrown.
You might wonder if there is a better way to do this and indeed there is. Using
for…in or for…of you do not have to catch StopIteration yourself, the
loop will terminate normally without the exception being propagated:
StopIteration is special
StopIteration actually is a standard variable that is bound to an object of
class StopIteration. It is an ordinary object with no properties of its own
and it is not a constructor function.
As StopIteration is a singleton of type StopIteration you can also catch it
by checking for equality:
StopIteration is mutable
You should be aware that StopIteration is a mutable global. Just like
undefined it can be modified to hold any other value. If you write a library
and want to shield against modifications from outside you can use this neat
little trick I found on
Dave Herman’s blog:
The inner function is a generator that terminates immediately and therefore will
throw a StopIteration. The outer function simply catches and returns it.
StopIteration may become a constructor
states that StopIteration will become a constructor to maintain compatibility
with generator functions returning values.
The equality check from above would not work anymore so it might be better to
just use instanceof.
StopIteration may not be part of ES6
The Python way of throwing to denote the end of a sequence is backwards
compatible with old ECMAScript versions but there seem to be
peoplenot happywith the current proposal.
While I can’t tell whether StopIteration is really to be removed a couple of
alternative suggestions have been made:
Introduce a keyword to end a frame
To not misuse exceptions for normal control flow ES6 could introduce a
stopiteration or endframe keyword that would end the current frame with
an optional return value. The obvious downside is that it is probably not
Add an iterator.hasNext() method
Just like Java the iterator API could consist of the two methods next() and
hasNext(). The client would then need to check hasNext() every time before
Let next() always return an object
Custom iterators would be required to implement a single method but would not
need to throw. Instead they would return an object with the property done set
to true to indicate that the sequence has ended. The value property would be
used to store values passed to yield or return in a generator function.
Food for thought
This is in no way a complete list of possibilities or proposals that were
brought up on es-discuss so
please make up your own mind about the current iterators implementation and the
The future is bright
Whether or not StopIteration will end up in ES6, generators and iterators are
great and you should make sure to be prepared when they become available in
modern browsers as well as on Node.js.
I concentrated particularly on StopIteration but there are
out there that go way more into depth about generators and their usage. Make
sure to also take a look at libraries like Task.js that
combines generators with promises to cooperative tasks.